hermet pushed a commit to branch master. http://git.enlightenment.org/core/efl.git/commit/?id=dad166f84a02cfffc2a07bc804e7b7e35ed4a40d
commit dad166f84a02cfffc2a07bc804e7b7e35ed4a40d Author: Hermet Park <[email protected]> Date: Tue Aug 20 18:18:31 2019 +0900 ector: code refactoring. Current vector drawing requires several methods for compositing, it's shouldnt have only masking but other blending functions such as matte in lottie, porter&duff in android, etc. Previously we didn't specify this method name, just reserved the options and now we started to define the methods with ector_renderer_composite_method() instead of mask_set(). --- src/lib/ector/Ector.h | 2 + src/lib/ector/ector_renderer.c | 8 +- src/lib/ector/ector_renderer.eo | 9 +- src/lib/ector/ector_renderer_gradient.eo | 2 + src/lib/ector/ector_types.eot | 10 ++ .../ector/software/ector_renderer_software_image.c | 28 +-- .../software/ector_renderer_software_image.eo | 2 +- .../ector/software/ector_renderer_software_shape.c | 32 ++-- .../software/ector_renderer_software_shape.eo | 2 +- src/lib/ector/software/ector_software_private.h | 8 +- src/lib/ector/software/ector_software_rasterizer.c | 137 +++++++-------- src/lib/evas/Evas.h | 2 + src/lib/evas/canvas/efl_canvas_vg_container.c | 192 ++++++++++----------- src/lib/evas/canvas/efl_canvas_vg_container.eo | 2 +- .../evas/canvas/efl_canvas_vg_gradient_linear.c | 6 +- .../evas/canvas/efl_canvas_vg_gradient_radial.c | 6 +- src/lib/evas/canvas/efl_canvas_vg_image.c | 6 +- src/lib/evas/canvas/efl_canvas_vg_node.c | 8 +- src/lib/evas/canvas/efl_canvas_vg_node.eo | 9 +- src/lib/evas/canvas/efl_canvas_vg_node_eo.legacy.c | 4 +- src/lib/evas/canvas/efl_canvas_vg_object.c | 4 +- src/lib/evas/canvas/efl_canvas_vg_shape.c | 12 +- src/lib/evas/canvas/evas_vg_private.h | 28 +-- src/static_libs/vg_common/vg_common_json.c | 39 ++--- 24 files changed, 265 insertions(+), 293 deletions(-) diff --git a/src/lib/ector/Ector.h b/src/lib/ector/Ector.h index 01a71d6e6e..2a391a7963 100644 --- a/src/lib/ector/Ector.h +++ b/src/lib/ector/Ector.h @@ -86,6 +86,8 @@ extern "C" { #ifdef EFL_BETA_API_SUPPORT +#include "ector_types.eot.h" + /** * @typedef Ector_Surface * The base type to render content into. diff --git a/src/lib/ector/ector_renderer.c b/src/lib/ector/ector_renderer.c index d0efab6a6c..cc7e0ec27c 100644 --- a/src/lib/ector/ector_renderer.c +++ b/src/lib/ector/ector_renderer.c @@ -146,10 +146,10 @@ _ector_renderer_crc_get(const Eo *obj EINA_UNUSED, } static void -_ector_renderer_mask_set(Eo *obj EINA_UNUSED, - Ector_Renderer_Data *pd EINA_UNUSED, - Ector_Buffer *mask EINA_UNUSED, - int op EINA_UNUSED) +_ector_renderer_comp_method_set(Eo *obj EINA_UNUSED, + Ector_Renderer_Data *pd EINA_UNUSED, + Ector_Buffer *comp EINA_UNUSED, + Ector_Renderer_Composite_Method method EINA_UNUSED) { } diff --git a/src/lib/ector/ector_renderer.eo b/src/lib/ector/ector_renderer.eo index 57726f3df1..8d702ae294 100644 --- a/src/lib/ector/ector_renderer.eo +++ b/src/lib/ector/ector_renderer.eo @@ -1,4 +1,5 @@ import eina_types; +import ector_types; abstract @beta Ector.Renderer extends Efl.Object { @@ -78,13 +79,13 @@ abstract @beta Ector.Renderer extends Efl.Object return: uint; [[CRC value]] } } - @property mask { - [[Set Mask Image to this Renderer]] + @property comp_method { + [[Set Composite Buffer to this Renderer]] set { } values { - mask: Ector.Buffer; [[Mask Image Buffer]] - op: int; [[Masking option]] + comp: Ector.Buffer; [[Composite Buffer]] + method: Ector.Renderer.Composite_Method; [[Composite method]] } } draw @pure_virtual { diff --git a/src/lib/ector/ector_renderer_gradient.eo b/src/lib/ector/ector_renderer_gradient.eo index fda0e33261..376326f88b 100644 --- a/src/lib/ector/ector_renderer_gradient.eo +++ b/src/lib/ector/ector_renderer_gradient.eo @@ -1,3 +1,5 @@ +import ector_types; + mixin @beta Ector.Renderer.Gradient requires Efl.Object extends Efl.Gfx.Gradient { [[Ector gradient renderer mixin]] diff --git a/src/lib/ector/ector_types.eot b/src/lib/ector/ector_types.eot index 1e1a96bd1c..c051d16edd 100644 --- a/src/lib/ector/ector_types.eot +++ b/src/lib/ector/ector_types.eot @@ -1,2 +1,12 @@ type @extern GLshort: short; [[GLshort type]] /* FIXME: We should not expose this in the API but probably redefine it. */ +enum @beta Ector.Renderer.Composite_Method +{ + none, + matte_alpha, + matte_alpha_inverse, + mask_add, + mask_substract, + mask_intersect, + mask_difference +} diff --git a/src/lib/ector/software/ector_renderer_software_image.c b/src/lib/ector/software/ector_renderer_software_image.c index cb8d93ad6c..bc45c387f4 100644 --- a/src/lib/ector/software/ector_renderer_software_image.c +++ b/src/lib/ector/software/ector_renderer_software_image.c @@ -21,10 +21,10 @@ struct _Ector_Renderer_Software_Image_Data Ector_Software_Surface_Data *surface; Ector_Renderer_Image_Data *image; Ector_Renderer_Data *base; - Ector_Buffer *mask; - int mask_op; - int opacity; - Eina_Matrix3 inv_m; + Ector_Buffer *comp; + Ector_Renderer_Composite_Method comp_method; + int opacity; + Eina_Matrix3 inv_m; struct { int x1, y1, x2, y2; } boundary; @@ -101,7 +101,7 @@ _ector_renderer_software_image_ector_renderer_draw(Eo *obj EINA_UNUSED, return EINA_TRUE; const int pix_stride = pd->surface->rasterizer->fill_data.raster_buffer->stride / 4; - Ector_Software_Buffer_Base_Data *mask = pd->mask ? efl_data_scope_get(pd->mask, ECTOR_SOFTWARE_BUFFER_BASE_MIXIN) : NULL; + Ector_Software_Buffer_Base_Data *comp = pd->comp ? efl_data_scope_get(pd->comp, ECTOR_SOFTWARE_BUFFER_BASE_MIXIN) : NULL; Ector_Software_Buffer_Base_Data *bpd = efl_data_scope_get(pd->image->buffer, ECTOR_SOFTWARE_BUFFER_BASE_MIXIN); double im11, im12, im21, im22, im31, im32; uint32_t *dst_buf, *src_buf; @@ -128,10 +128,10 @@ _ector_renderer_software_image_ector_renderer_draw(Eo *obj EINA_UNUSED, continue; uint32_t *src = src_buf + (rx + (ry * image_w)); //FIXME: use to stride uint32_t temp = 0x0; - if (mask) + if (comp) { - uint32_t *m = mask->pixels.u32 + ((int)local_x + ((int)local_y * mask->generic->w)); - //FIXME : This masking can work only matte case. + uint32_t *m = comp->pixels.u32 + ((int)local_x + ((int)local_y * comp->generic->w)); + //FIXME : This comping can work only matte case. // We need consider to inverse matte case. temp = draw_mul_256((((*m)>>24) * pd->opacity)>>8, *src); } @@ -182,13 +182,13 @@ _ector_renderer_software_image_ector_renderer_crc_get(const Eo *obj, } static void -_ector_renderer_software_image_ector_renderer_mask_set(Eo *obj EINA_UNUSED, - Ector_Renderer_Software_Image_Data *pd, - Ector_Buffer *mask, - int op) +_ector_renderer_software_image_ector_renderer_comp_method_set(Eo *obj EINA_UNUSED, + Ector_Renderer_Software_Image_Data *pd, + Ector_Buffer *comp, + Ector_Renderer_Composite_Method method) { - pd->mask = mask; - pd->mask_op = op; + pd->comp = comp; + pd->comp_method = method; } #include "ector_renderer_software_image.eo.c" diff --git a/src/lib/ector/software/ector_renderer_software_image.eo b/src/lib/ector/software/ector_renderer_software_image.eo index 8a3f9c51e7..477170242b 100644 --- a/src/lib/ector/software/ector_renderer_software_image.eo +++ b/src/lib/ector/software/ector_renderer_software_image.eo @@ -5,7 +5,7 @@ class @beta Ector.Renderer.Software.Image extends Ector.Renderer.Software implem implements { Ector.Renderer.prepare; Ector.Renderer.draw; - Ector.Renderer.mask { set; } + Ector.Renderer.comp_method { set; } Ector.Renderer.crc { get; } Efl.Object.constructor; Efl.Object.destructor; diff --git a/src/lib/ector/software/ector_renderer_software_shape.c b/src/lib/ector/software/ector_renderer_software_shape.c index b9cf1faaed..00a95b85f2 100644 --- a/src/lib/ector/software/ector_renderer_software_shape.c +++ b/src/lib/ector/software/ector_renderer_software_shape.c @@ -38,8 +38,8 @@ struct _Ector_Renderer_Software_Shape_Data Shape_Rle_Data *shape_data; Shape_Rle_Data *outline_data; - Ector_Buffer *mask; - int mask_op; + Ector_Buffer *comp; + Ector_Renderer_Composite_Method comp_method; Ector_Software_Shape_Task *task; @@ -674,8 +674,8 @@ _ector_renderer_software_shape_ector_renderer_draw(Eo *obj, ector_software_rasterizer_draw_rle_data(pd->surface->rasterizer, x, y, mul_col, op, pd->shape_data, - pd->mask, - pd->mask_op); + pd->comp, + pd->comp_method); } else { @@ -689,8 +689,8 @@ _ector_renderer_software_shape_ector_renderer_draw(Eo *obj, ector_software_rasterizer_draw_rle_data(pd->surface->rasterizer, x, y, mul_col, op, pd->shape_data, - pd->mask, - pd->mask_op); + pd->comp, + pd->comp_method); } } @@ -702,8 +702,8 @@ _ector_renderer_software_shape_ector_renderer_draw(Eo *obj, ector_software_rasterizer_draw_rle_data(pd->surface->rasterizer, x, y, mul_col, op, pd->outline_data, - pd->mask, - pd->mask_op); + pd->comp, + pd->comp_method); } else { @@ -717,8 +717,8 @@ _ector_renderer_software_shape_ector_renderer_draw(Eo *obj, ector_software_rasterizer_draw_rle_data(pd->surface->rasterizer, x, y, mul_col, op, pd->outline_data, - pd->mask, - pd->mask_op); + pd->comp, + pd->comp_method); } } @@ -828,14 +828,14 @@ _ector_renderer_software_shape_ector_renderer_crc_get(const Eo *obj, } static void -_ector_renderer_software_shape_ector_renderer_mask_set(Eo *obj EINA_UNUSED, - Ector_Renderer_Software_Shape_Data *pd, - Ector_Buffer *mask, - int op) +_ector_renderer_software_shape_ector_renderer_comp_method_set(Eo *obj EINA_UNUSED, + Ector_Renderer_Software_Shape_Data *pd, + Ector_Buffer *comp, + Ector_Renderer_Composite_Method method) { //Use ref/unref. - pd->mask = mask; - pd->mask_op = op; + pd->comp = comp; + pd->comp_method = method; } #include "ector_renderer_software_shape.eo.c" diff --git a/src/lib/ector/software/ector_renderer_software_shape.eo b/src/lib/ector/software/ector_renderer_software_shape.eo index 4ea56f9260..83b87c0121 100644 --- a/src/lib/ector/software/ector_renderer_software_shape.eo +++ b/src/lib/ector/software/ector_renderer_software_shape.eo @@ -6,7 +6,7 @@ class @beta Ector.Renderer.Software.Shape extends Ector.Renderer.Software implem Ector.Renderer.prepare; Ector.Renderer.draw; Ector.Renderer.Software.op_fill; - Ector.Renderer.mask { set; } + Ector.Renderer.comp_method { set; } Ector.Renderer.crc { get; } Efl.Gfx.Path.commit; Efl.Object.constructor; diff --git a/src/lib/ector/software/ector_software_private.h b/src/lib/ector/software/ector_software_private.h index 62d1c3f8fd..7ac63b5646 100644 --- a/src/lib/ector/software/ector_software_private.h +++ b/src/lib/ector/software/ector_software_private.h @@ -83,8 +83,8 @@ typedef struct _Span_Data int offx, offy; Clip_Data clip; - Ector_Software_Buffer_Base_Data *mask; - int mask_op; + Ector_Software_Buffer_Base_Data *comp; + Ector_Renderer_Composite_Method comp_method; Eina_Matrix3 inv; Span_Data_Type type; Eina_Bool fast_matrix; @@ -136,8 +136,8 @@ void ector_software_rasterizer_draw_rle_data(Software_Rasterizer *rasterizer, int x, int y, uint32_t mul_col, Efl_Gfx_Render_Op op, Shape_Rle_Data* rle, - Ector_Buffer *mask, - int mask_op); + Ector_Buffer *comp, + Ector_Renderer_Composite_Method comp_method); void ector_software_rasterizer_destroy_rle_data(Shape_Rle_Data *rle); diff --git a/src/lib/ector/software/ector_software_rasterizer.c b/src/lib/ector/software/ector_software_rasterizer.c index 2b995c9e81..d4b67561fe 100644 --- a/src/lib/ector/software/ector_software_rasterizer.c +++ b/src/lib/ector/software/ector_software_rasterizer.c @@ -11,21 +11,6 @@ #include "draw.h" -//FIXME: This enum add temporarily to help understanding of additional code -//related to masking in prepare_mask. -//This needs to be formally declared through the eo class. -typedef enum _EFL_CANVAS_VG_NODE_BLEND_TYPE -{ - EFL_CANVAS_VG_NODE_BLEND_TYPE_NONE = 0, - EFL_CANVAS_VG_NODE_BLEND_TYPE_ALPHA, - EFL_CANVAS_VG_NODE_BLEND_TYPE_ALPHA_INV, - EFL_CANVAS_VG_NODE_BLEND_TYPE_MASK_ADD, - EFL_CANVAS_VG_NODE_BLEND_TYPE_MASK_SUBSTRACT, - EFL_CANVAS_VG_NODE_BLEND_TYPE_MASK_INTERSECT, - EFL_CANVAS_VG_NODE_BLEND_TYPE_MASK_DIFFERENCE -}EFL_CANVAS_VG_NODE_BLEND_TYPE; -// - static void _blend_argb(int count, const SW_FT_Span *spans, void *user_data) { @@ -49,12 +34,12 @@ _blend_argb(int count, const SW_FT_Span *spans, void *user_data) } static void -_blend_alpha(int count, const SW_FT_Span *spans, void *user_data) +_comp_matte_alpha(int count, const SW_FT_Span *spans, void *user_data) { Span_Data *sd = user_data; const int pix_stride = sd->raster_buffer->stride / 4; - Ector_Software_Buffer_Base_Data *mask = sd->mask; - if (!mask || !mask->pixels.u32) return; + Ector_Software_Buffer_Base_Data *comp = sd->comp; + if (!comp || !comp->pixels.u32) return; // multiply the color with mul_col if any uint32_t color = DRAW_MUL4_SYM(sd->color, sd->mul_col); @@ -63,7 +48,7 @@ _blend_alpha(int count, const SW_FT_Span *spans, void *user_data) // move to the offset location uint32_t *buffer = sd->raster_buffer->pixels.u32 + ((pix_stride * sd->offy) + sd->offx); - uint32_t *mbuffer = mask->pixels.u32; + uint32_t *mbuffer = comp->pixels.u32; //Temp buffer for intermediate processing int tsize = sd->raster_buffer->generic->w; @@ -73,12 +58,12 @@ _blend_alpha(int count, const SW_FT_Span *spans, void *user_data) { uint32_t *target = buffer + ((pix_stride * spans->y) + spans->x); uint32_t *mtarget = - mbuffer + ((mask->generic->w * spans->y) + spans->x); + mbuffer + ((comp->generic->w * spans->y) + spans->x); uint32_t *temp = tbuffer; memset(temp, 0x00, sizeof(uint32_t) * spans->len); comp_func(temp, spans->len, color, spans->coverage); - //masking + //composite for (int i = 0; i < spans->len; i++) { *temp = draw_mul_256(((*mtarget)>>24), *temp); @@ -93,12 +78,12 @@ _blend_alpha(int count, const SW_FT_Span *spans, void *user_data) } static void -_blend_alpha_inv(int count, const SW_FT_Span *spans, void *user_data) +_comp_matte_alpha_inv(int count, const SW_FT_Span *spans, void *user_data) { Span_Data *sd = user_data; const int pix_stride = sd->raster_buffer->stride / 4; - Ector_Software_Buffer_Base_Data *mask = sd->mask; - if (!mask || !mask->pixels.u32) return; + Ector_Software_Buffer_Base_Data *comp = sd->comp; + if (!comp || !comp->pixels.u32) return; // multiply the color with mul_col if any uint32_t color = DRAW_MUL4_SYM(sd->color, sd->mul_col); @@ -107,7 +92,7 @@ _blend_alpha_inv(int count, const SW_FT_Span *spans, void *user_data) // move to the offset location uint32_t *buffer = sd->raster_buffer->pixels.u32 + ((pix_stride * sd->offy) + sd->offx); - uint32_t *mbuffer = mask->pixels.u32; + uint32_t *mbuffer = comp->pixels.u32; //Temp buffer for intermediate processing int tsize = sd->raster_buffer->generic->w; @@ -117,12 +102,12 @@ _blend_alpha_inv(int count, const SW_FT_Span *spans, void *user_data) { uint32_t *target = buffer + ((pix_stride * spans->y) + spans->x); uint32_t *mtarget = - mbuffer + ((mask->generic->w * spans->y) + spans->x); + mbuffer + ((comp->generic->w * spans->y) + spans->x); uint32_t *temp = tbuffer; memset(temp, 0x00, sizeof(uint32_t) * spans->len); comp_func(temp, spans->len, color, spans->coverage); - //masking + //composite for (int i = 0; i < spans->len; i++) { if (*mtarget) @@ -138,22 +123,22 @@ _blend_alpha_inv(int count, const SW_FT_Span *spans, void *user_data) } static void -_blend_mask_add(int count, const SW_FT_Span *spans, void *user_data) +_comp_mask_add(int count, const SW_FT_Span *spans, void *user_data) { Span_Data *sd = user_data; - Ector_Software_Buffer_Base_Data *mask = sd->mask; - if (!mask || !mask->pixels.u32) return; + Ector_Software_Buffer_Base_Data *comp = sd->comp; + if (!comp || !comp->pixels.u32) return; uint32_t color = DRAW_MUL4_SYM(sd->color, sd->mul_col); RGBA_Comp_Func_Solid comp_func = efl_draw_func_solid_span_get(sd->op, color); - uint32_t *mbuffer = mask->pixels.u32; + uint32_t *mbuffer = comp->pixels.u32; int tsize = sd->raster_buffer->generic->w; uint32_t *ttarget = alloca(sizeof(uint32_t) * tsize); while (count--) { - uint32_t *mtarget = mbuffer + ((mask->generic->w * spans->y) + spans->x); + uint32_t *mtarget = mbuffer + ((comp->generic->w * spans->y) + spans->x); memset(ttarget, 0x00, sizeof(uint32_t) * spans->len); comp_func(ttarget, spans->len, color, spans->coverage); for (int i = 0; i < spans->len; i++) @@ -163,22 +148,22 @@ _blend_mask_add(int count, const SW_FT_Span *spans, void *user_data) } static void -_blend_mask_sub(int count, const SW_FT_Span *spans, void *user_data) +_comp_mask_sub(int count, const SW_FT_Span *spans, void *user_data) { Span_Data *sd = user_data; - Ector_Software_Buffer_Base_Data *mask = sd->mask; - if (!mask || !mask->pixels.u32) return; + Ector_Software_Buffer_Base_Data *comp = sd->comp; + if (!comp || !comp->pixels.u32) return; uint32_t color = DRAW_MUL4_SYM(sd->color, sd->mul_col); RGBA_Comp_Func_Solid comp_func = efl_draw_func_solid_span_get(sd->op, color); - uint32_t *mbuffer = mask->pixels.u32; + uint32_t *mbuffer = comp->pixels.u32; int tsize = sd->raster_buffer->generic->w; uint32_t *ttarget = alloca(sizeof(uint32_t) * tsize); while (count--) { - uint32_t *mtarget = mbuffer + ((mask->generic->w * spans->y) + spans->x); + uint32_t *mtarget = mbuffer + ((comp->generic->w * spans->y) + spans->x); memset(ttarget, 0x00, sizeof(uint32_t) * spans->len); comp_func(ttarget, spans->len, color, spans->coverage); for (int i = 0; i < spans->len; i++) @@ -189,28 +174,28 @@ _blend_mask_sub(int count, const SW_FT_Span *spans, void *user_data) static void -_blend_mask_ins(int count, const SW_FT_Span *spans, void *user_data) +_comp_mask_ins(int count, const SW_FT_Span *spans, void *user_data) { Span_Data *sd = user_data; - Ector_Software_Buffer_Base_Data *mask = sd->mask; - if (!mask || !mask->pixels.u32) return; + Ector_Software_Buffer_Base_Data *comp = sd->comp; + if (!comp || !comp->pixels.u32) return; uint32_t color = DRAW_MUL4_SYM(sd->color, sd->mul_col); RGBA_Comp_Func_Solid comp_func = efl_draw_func_solid_span_get(sd->op, color); - uint32_t *mbuffer = mask->pixels.u32; + uint32_t *mbuffer = comp->pixels.u32; int tsize = sd->raster_buffer->generic->w; uint32_t *ttarget = alloca(sizeof(uint32_t) * tsize); - for(unsigned int y = 0; y < mask->generic->h; y++) + for(unsigned int y = 0; y < comp->generic->h; y++) { - for(unsigned int x = 0; x < mask->generic->w; x++) + for(unsigned int x = 0; x < comp->generic->w; x++) { - if (x == (unsigned int)spans->x && x + spans->len <= mask->generic->w && + if (x == (unsigned int)spans->x && x + spans->len <= comp->generic->w && y == (unsigned int)spans->y && count > 0) { memset(ttarget, 0x00, sizeof(uint32_t) * spans->len); - uint32_t *mtarget = mbuffer + ((mask->generic->w * spans->y) + spans->x); + uint32_t *mtarget = mbuffer + ((comp->generic->w * spans->y) + spans->x); comp_func(ttarget, spans->len, color, spans->coverage); for (int c = 0; c < spans->len; c++) mtarget[c] = draw_mul_256(ttarget[c]>>24, mtarget[c]); @@ -220,7 +205,7 @@ _blend_mask_ins(int count, const SW_FT_Span *spans, void *user_data) } else { - mbuffer[x + (mask->generic->w * y)] = (0x00FFFFFF & mbuffer[x + (mask->generic->w * y)]); + mbuffer[x + (comp->generic->w * y)] = (0x00FFFFFF & mbuffer[x + (comp->generic->w * y)]); } } } @@ -228,15 +213,15 @@ _blend_mask_ins(int count, const SW_FT_Span *spans, void *user_data) static void -_blend_mask_diff(int count, const SW_FT_Span *spans, void *user_data) +_comp_mask_diff(int count, const SW_FT_Span *spans, void *user_data) { Span_Data *sd = user_data; - Ector_Software_Buffer_Base_Data *mask = sd->mask; - if (!mask || !mask->pixels.u32) return; + Ector_Software_Buffer_Base_Data *comp = sd->comp; + if (!comp || !comp->pixels.u32) return; uint32_t color = DRAW_MUL4_SYM(sd->color, sd->mul_col); RGBA_Comp_Func_Solid comp_func = efl_draw_func_solid_span_get(sd->op, color); - uint32_t *mbuffer = mask->pixels.u32; + uint32_t *mbuffer = comp->pixels.u32; int tsize = sd->raster_buffer->generic->w; uint32_t *ttarget = alloca(sizeof(uint32_t) * tsize); @@ -244,7 +229,7 @@ _blend_mask_diff(int count, const SW_FT_Span *spans, void *user_data) while (count--) { memset(ttarget, 0x00, sizeof(uint32_t) * spans->len); - uint32_t *mtarget = mbuffer + ((mask->generic->w * spans->y) + spans->x); + uint32_t *mtarget = mbuffer + ((comp->generic->w * spans->y) + spans->x); comp_func(ttarget, spans->len, color, spans->coverage); for (int i = 0; i < spans->len; i++) mtarget[i] = draw_mul_256(0xFF - (mtarget[i]>>24), ttarget[i]) + draw_mul_256(0xFF - (ttarget[i]>>24), mtarget[i]); @@ -310,8 +295,8 @@ _blend_gradient_alpha(int count, const SW_FT_Span *spans, void *user_data) if (!fetchfunc) return; - Ector_Software_Buffer_Base_Data *mask = data->mask; - uint32_t *mbuffer = mask->pixels.u32; + Ector_Software_Buffer_Base_Data *comp = data->comp; + uint32_t *mbuffer = comp->pixels.u32; //Temp buffer for intermediate processing uint32_t *tbuffer = malloc(sizeof(uint32_t) * data->raster_buffer->generic->w); @@ -324,7 +309,7 @@ _blend_gradient_alpha(int count, const SW_FT_Span *spans, void *user_data) while (count--) { uint32_t *target = buffer + ((data->raster_buffer->generic->w * spans->y) + spans->x); - uint32_t *mtarget = mbuffer + ((mask->generic->w * spans->y) + spans->x); + uint32_t *mtarget = mbuffer + ((comp->generic->w * spans->y) + spans->x); uint32_t *temp = tbuffer; int length = spans->len; memset(temp, 0x00, sizeof(uint32_t) * spans->len); @@ -367,8 +352,8 @@ _blend_gradient_alpha_inv(int count, const SW_FT_Span *spans, void *user_data) if (!fetchfunc) return; - Ector_Software_Buffer_Base_Data *mask = data->mask; - uint32_t *mbuffer = mask->pixels.u32; + Ector_Software_Buffer_Base_Data *comp = data->comp; + uint32_t *mbuffer = comp->pixels.u32; //Temp buffer for intermediate processing uint32_t *tbuffer = malloc(sizeof(uint32_t) * data->raster_buffer->generic->w); @@ -381,7 +366,7 @@ _blend_gradient_alpha_inv(int count, const SW_FT_Span *spans, void *user_data) while (count--) { uint32_t *target = buffer + ((data->raster_buffer->generic->w * spans->y) + spans->x); - uint32_t *mtarget = mbuffer + ((mask->generic->w * spans->y) + spans->x); + uint32_t *mtarget = mbuffer + ((comp->generic->w * spans->y) + spans->x); uint32_t *temp = tbuffer; int length = spans->len; memset(temp, 0x00, sizeof(uint32_t) * spans->len); @@ -599,38 +584,38 @@ static void _adjust_span_fill_methods(Span_Data *spdata) { //Blending Function - if (spdata->mask) + if (spdata->comp) { - switch (spdata->mask_op) + switch (spdata->comp_method) { default: - case EFL_CANVAS_VG_NODE_BLEND_TYPE_ALPHA: + case ECTOR_RENDERER_COMPOSITE_METHOD_MATTE_ALPHA: if (spdata->type == Solid) - spdata->unclipped_blend = &_blend_alpha; + spdata->unclipped_blend = &_comp_matte_alpha; else if (spdata->type == LinearGradient || spdata->type == RadialGradient) spdata->unclipped_blend = &_blend_gradient_alpha; else //None spdata->unclipped_blend = NULL; break; - case EFL_CANVAS_VG_NODE_BLEND_TYPE_ALPHA_INV: + case ECTOR_RENDERER_COMPOSITE_METHOD_MATTE_ALPHA_INVERSE: if (spdata->type == Solid) - spdata->unclipped_blend = &_blend_alpha_inv; + spdata->unclipped_blend = &_comp_matte_alpha_inv; else if (spdata->type == LinearGradient || spdata->type == RadialGradient) spdata->unclipped_blend = &_blend_gradient_alpha_inv; else //None spdata->unclipped_blend = NULL; break; - case EFL_CANVAS_VG_NODE_BLEND_TYPE_MASK_ADD: - spdata->unclipped_blend = &_blend_mask_add; + case ECTOR_RENDERER_COMPOSITE_METHOD_MASK_ADD: + spdata->unclipped_blend = &_comp_mask_add; break; - case EFL_CANVAS_VG_NODE_BLEND_TYPE_MASK_SUBSTRACT: - spdata->unclipped_blend = &_blend_mask_sub; + case ECTOR_RENDERER_COMPOSITE_METHOD_MASK_SUBSTRACT: + spdata->unclipped_blend = &_comp_mask_sub; break; - case EFL_CANVAS_VG_NODE_BLEND_TYPE_MASK_INTERSECT: - spdata->unclipped_blend = &_blend_mask_ins; + case ECTOR_RENDERER_COMPOSITE_METHOD_MASK_INTERSECT: + spdata->unclipped_blend = &_comp_mask_ins; break; - case EFL_CANVAS_VG_NODE_BLEND_TYPE_MASK_DIFFERENCE: - spdata->unclipped_blend = &_blend_mask_diff; + case ECTOR_RENDERER_COMPOSITE_METHOD_MASK_DIFFERENCE: + spdata->unclipped_blend = &_comp_mask_diff; break; } } @@ -910,8 +895,8 @@ void ector_software_rasterizer_draw_rle_data(Software_Rasterizer *rasterizer, int x, int y, uint32_t mul_col, Efl_Gfx_Render_Op op, Shape_Rle_Data* rle, - Ector_Buffer *mask, - int mask_op) + Ector_Buffer *comp, + Ector_Renderer_Composite_Method comp_method) { if (!rle) return; if (!rasterizer->fill_data.raster_buffer->pixels.u32) return; @@ -920,9 +905,9 @@ ector_software_rasterizer_draw_rle_data(Software_Rasterizer *rasterizer, rasterizer->fill_data.offy = y; rasterizer->fill_data.mul_col = mul_col; rasterizer->fill_data.op = op; - rasterizer->fill_data.mask = - mask ? efl_data_scope_get(mask, ECTOR_SOFTWARE_BUFFER_BASE_MIXIN) : NULL; - rasterizer->fill_data.mask_op = mask_op; + rasterizer->fill_data.comp = + comp ? efl_data_scope_get(comp, ECTOR_SOFTWARE_BUFFER_BASE_MIXIN) : NULL; + rasterizer->fill_data.comp_method = comp_method; _setup_span_fill_matrix(rasterizer); _adjust_span_fill_methods(&rasterizer->fill_data); diff --git a/src/lib/evas/Evas.h b/src/lib/evas/Evas.h index 9044398971..d35e82dfc1 100644 --- a/src/lib/evas/Evas.h +++ b/src/lib/evas/Evas.h @@ -172,6 +172,8 @@ /* This include has been added to support Eo in Evas */ #include <Efl.h> +#include <Ector.h> + #include <Evas_Loader.h> #ifdef EAPI diff --git a/src/lib/evas/canvas/efl_canvas_vg_container.c b/src/lib/evas/canvas/efl_canvas_vg_container.c index 2daa65fb80..9f42b2340c 100644 --- a/src/lib/evas/canvas/efl_canvas_vg_container.c +++ b/src/lib/evas/canvas/efl_canvas_vg_container.c @@ -5,23 +5,6 @@ #define MY_CLASS EFL_CANVAS_VG_CONTAINER_CLASS - -//FIXME: This enum add temporarily to help understanding of additional code -//related to masking in prepare_mask. -//This needs to be formally declared through the eo class. -//This is a list of blending supported via efl_canvas_vg_node_mask_set(). -typedef enum _EFL_CANVAS_VG_NODE_BLEND_TYPE -{ - EFL_CANVAS_VG_NODE_BLEND_TYPE_NONE = 0, - EFL_CANVAS_VG_NODE_BLEND_TYPE_ALPHA, - EFL_CANVAS_VG_NODE_BLEND_TYPE_ALPHA_INV, - EFL_CANVAS_VG_NODE_BLEND_TYPE_MASK_ADD, - EFL_CANVAS_VG_NODE_BLEND_TYPE_MASK_SUBSTRACT, - EFL_CANVAS_VG_NODE_BLEND_TYPE_MASK_INTERSECT, - EFL_CANVAS_VG_NODE_BLEND_TYPE_MASK_DIFFERENCE -}EFL_CANVAS_VG_NODE_BLEND_TYPE; -// - static void _invalidate_cb(void *data EINA_UNUSED, const Efl_Event *event) { @@ -40,7 +23,7 @@ _invalidate_cb(void *data EINA_UNUSED, const Efl_Event *event) } static void -_draw_mask(Evas_Object_Protected_Data *obj, Efl_VG *node, +_draw_comp(Evas_Object_Protected_Data *obj, Efl_VG *node, Ector_Surface *ector, void *engine, void *output, void *context) { @@ -51,11 +34,11 @@ _draw_mask(Evas_Object_Protected_Data *obj, Efl_VG *node, Efl_Canvas_Vg_Container_Data *cd = efl_data_scope_get(node, EFL_CANVAS_VG_CONTAINER_CLASS); - //Draw Mask Image. + //Draw Composite Image. Efl_VG *child; Eina_List *l; EINA_LIST_FOREACH(cd->children, l, child) - _draw_mask(obj, child, ector, engine, output, context); + _draw_comp(obj, child, ector, engine, output, context); } else { @@ -65,93 +48,94 @@ _draw_mask(Evas_Object_Protected_Data *obj, Efl_VG *node, } static Ector_Buffer * -_prepare_mask(Evas_Object_Protected_Data *obj, //vector object - Efl_Canvas_Vg_Node* mask_obj, +_prepare_comp(Evas_Object_Protected_Data *obj, //vector object + Efl_Canvas_Vg_Node* comp_target, void *engine, void *output, void *context, Ector_Surface *surface, Eina_Matrix3 *ptransform, Eina_Matrix3 *ctransform, - Ector_Buffer *mask, - int mask_op) + Ector_Buffer *comp, + Ector_Renderer_Composite_Method comp_method) { - Efl_Canvas_Vg_Container_Data *pd = efl_data_scope_get(mask_obj, MY_CLASS); + Efl_Canvas_Vg_Container_Data *pd = efl_data_scope_get(comp_target, MY_CLASS); Efl_Canvas_Vg_Node_Data *nd = - efl_data_scope_get(mask_obj, EFL_CANVAS_VG_NODE_CLASS); - if (nd->flags == EFL_GFX_CHANGE_FLAG_NONE) return pd->mask.buffer; + efl_data_scope_get(comp_target, EFL_CANVAS_VG_NODE_CLASS); + if (nd->flags == EFL_GFX_CHANGE_FLAG_NONE) return pd->comp.buffer; uint32_t init_buffer = 0x0; - //1. Mask Size + //1. Composite Size Eina_Rect mbound; mbound.x = 0; mbound.y = 0; mbound.w = obj->cur->geometry.w; mbound.h = obj->cur->geometry.h; - //FIXME: If mask typs is SUBSTRACT or INTERSECT, buffer fills in white color(Full alpha color). - if (pd->mask.option == EFL_CANVAS_VG_NODE_BLEND_TYPE_MASK_SUBSTRACT || pd->mask.option == EFL_CANVAS_VG_NODE_BLEND_TYPE_MASK_INTERSECT) + //FIXME: If composite method is SUBSTRACT or INTERSECT, buffer fills in white color(Full alpha color). + if (pd->comp.method == ECTOR_RENDERER_COMPOSITE_METHOD_MASK_SUBSTRACT || + pd->comp.method == ECTOR_RENDERER_COMPOSITE_METHOD_MASK_INTERSECT) init_buffer = 0xFFFFFFFF; //2. Reusable ector buffer? - if (!pd->mask.buffer || (pd->mask.bound.w != mbound.w) || - (pd->mask.bound.h != mbound.h)) + if (!pd->comp.buffer || (pd->comp.bound.w != mbound.w) || + (pd->comp.bound.h != mbound.h)) { - if (pd->mask.pixels) free(pd->mask.pixels); - if (pd->mask.buffer) efl_unref(pd->mask.buffer); - pd->mask.pixels = malloc(sizeof(uint32_t) * (mbound.w * mbound.h)); - memset(pd->mask.pixels, init_buffer, sizeof(uint32_t) * (mbound.w * mbound.h)); - pd->mask.buffer = ENFN->ector_buffer_new(ENC, obj->layer->evas->evas, + if (pd->comp.pixels) free(pd->comp.pixels); + if (pd->comp.buffer) efl_unref(pd->comp.buffer); + pd->comp.pixels = malloc(sizeof(uint32_t) * (mbound.w * mbound.h)); + memset(pd->comp.pixels, init_buffer, sizeof(uint32_t) * (mbound.w * mbound.h)); + pd->comp.buffer = ENFN->ector_buffer_new(ENC, obj->layer->evas->evas, mbound.w, mbound.h, EFL_GFX_COLORSPACE_ARGB8888, ECTOR_BUFFER_FLAG_DRAWABLE | ECTOR_BUFFER_FLAG_CPU_READABLE | ECTOR_BUFFER_FLAG_CPU_WRITABLE); - ector_buffer_pixels_set(pd->mask.buffer, pd->mask.pixels, + ector_buffer_pixels_set(pd->comp.buffer, pd->comp.pixels, mbound.w, mbound.h, 0, EFL_GFX_COLORSPACE_ARGB8888, EINA_TRUE); - pd->mask.bound.w = mbound.w; - pd->mask.bound.h = mbound.h; - pd->mask.vg_pd = obj; + pd->comp.bound.w = mbound.w; + pd->comp.bound.h = mbound.h; + pd->comp.vg_pd = obj; } else { - if (pd->mask.pixels) - memset(pd->mask.pixels, init_buffer, sizeof(uint32_t) * mbound.w * mbound.h); + if (pd->comp.pixels) + memset(pd->comp.pixels, init_buffer, sizeof(uint32_t) * mbound.w * mbound.h); } - pd->mask.bound.x = mbound.x; - pd->mask.bound.y = mbound.y; + pd->comp.bound.x = mbound.x; + pd->comp.bound.y = mbound.y; - if (!pd->mask.buffer) ERR("Mask Buffer is invalid"); + if (!pd->comp.buffer) ERR("Composite Buffer is invalid"); - //FIXME: This code means that there is another masking container. - if (pd->mask.option >= EFL_CANVAS_VG_NODE_BLEND_TYPE_MASK_ADD) + //FIXME: This code means that there is another composite container. + if (pd->comp.method >= ECTOR_RENDERER_COMPOSITE_METHOD_MASK_ADD) { - Efl_Canvas_Vg_Container_Data *src_pd = pd; - mask = pd->mask.buffer; - for (Efl_VG *mask_src = pd->mask_src; mask_src; mask_src = src_pd->mask_src) + Efl_Canvas_Vg_Container_Data *target_pd = pd; + comp = pd->comp.buffer; + for (Efl_VG *comp_target = pd->comp_target; comp_target; comp_target = target_pd->comp_target) { - Efl_Canvas_Vg_Container_Data *target_pd = NULL; - src_pd = efl_data_scope_get(mask_src, MY_CLASS); - target_pd = efl_data_scope_get(eina_list_nth(src_pd->mask.target, 0), MY_CLASS); - _evas_vg_render_pre(obj, mask_src, + Efl_Canvas_Vg_Container_Data *src_pd = NULL; + target_pd = efl_data_scope_get(comp_target, MY_CLASS); + src_pd = efl_data_scope_get(eina_list_nth(target_pd->comp.src, 0), MY_CLASS); + _evas_vg_render_pre(obj, comp_target, engine, output, context, surface, - ctransform, mask, target_pd->mask.option); + ctransform, comp, src_pd->comp.method); } } //3. Prepare Drawing shapes. - _evas_vg_render_pre(obj, mask_obj, + _evas_vg_render_pre(obj, comp_target, engine, output, context, surface, - ptransform, mask, mask_op); + ptransform, comp, comp_method); - //4. Generating Mask Image. - ector_buffer_pixels_set(surface, pd->mask.pixels, mbound.w, mbound.h, 0, + //4. Generating Composite Image. + ector_buffer_pixels_set(surface, pd->comp.pixels, mbound.w, mbound.h, 0, EFL_GFX_COLORSPACE_ARGB8888, EINA_TRUE); ector_surface_reference_point_set(surface, -mbound.x, -mbound.y); - _draw_mask(obj, mask_obj, surface, engine, output, context); + _draw_comp(obj, comp_target, surface, engine, output, context); - return pd->mask.buffer; + return pd->comp.buffer; } static void @@ -161,8 +145,8 @@ _efl_canvas_vg_container_render_pre(Evas_Object_Protected_Data *vg_pd, void *engine, void *output, void *context, Ector_Surface *surface, Eina_Matrix3 *ptransform, - Ector_Buffer *mask, - int mask_op, + Ector_Buffer *comp, + Ector_Renderer_Composite_Method comp_method, void *data) { Efl_Canvas_Vg_Container_Data *pd = data; @@ -177,27 +161,27 @@ _efl_canvas_vg_container_render_pre(Evas_Object_Protected_Data *vg_pd, EFL_CANVAS_VG_COMPUTE_MATRIX(ctransform, ptransform, nd); - //Container may have mask source. - //FIXME : _prepare_mask() should only work in cases with matte or main mask. - // This condition is valid because the main mask use same type as matte alpha. - if (pd->mask_src && - (pd->mask.option == EFL_CANVAS_VG_NODE_BLEND_TYPE_ALPHA || - pd->mask.option == EFL_CANVAS_VG_NODE_BLEND_TYPE_ALPHA_INV)) + //Container may have composite target. + //FIXME : _prepare_comp() should only work in cases with matte or masking. + // This condition is valid because the masking use same type as matte. + if (pd->comp_target && + (pd->comp.method == ECTOR_RENDERER_COMPOSITE_METHOD_MATTE_ALPHA || + pd->comp.method == ECTOR_RENDERER_COMPOSITE_METHOD_MATTE_ALPHA_INVERSE)) { - mask_op = pd->mask.option; - mask = _prepare_mask(vg_pd, pd->mask_src, + comp_method = pd->comp.method; + comp = _prepare_comp(vg_pd, pd->comp_target, engine, output, context, surface, - ptransform, ctransform, mask, mask_op); + ptransform, ctransform, comp, comp_method); } EINA_LIST_FOREACH(pd->children, l, child) { - //Don't need to update mask nodes. + //Don't need to update composite nodes. if (efl_isa(child, MY_CLASS)) { Efl_Canvas_Vg_Container_Data *child_cd = efl_data_scope_get(child, MY_CLASS); - if (child_cd->mask.target) continue; + if (child_cd->comp.src) continue; } //Skip Gradients. they will be updated by Shape. @@ -212,7 +196,7 @@ _efl_canvas_vg_container_render_pre(Evas_Object_Protected_Data *vg_pd, _evas_vg_render_pre(vg_pd, child, engine, output, context, surface, - ctransform, mask, mask_op); + ctransform, comp, comp_method); } } @@ -243,12 +227,12 @@ _efl_canvas_vg_container_efl_object_destructor(Eo *obj, if (pd->blend_pixels) free(pd->blend_pixels); if (pd->blend_buffer) efl_unref(pd->blend_buffer); - //Destroy mask surface - if (pd->mask.buffer) efl_unref(pd->mask.buffer); - if (pd->mask.pixels) free(pd->mask.pixels); + //Destroy comp surface + if (pd->comp.buffer) efl_unref(pd->comp.buffer); + if (pd->comp.pixels) free(pd->comp.pixels); - efl_unref(pd->mask_src); - eina_list_free(pd->mask.target); + efl_unref(pd->comp_target); + eina_list_free(pd->comp.src); eina_hash_free(pd->names); efl_destructor(efl_super(obj, MY_CLASS)); @@ -333,14 +317,14 @@ _efl_canvas_vg_container_efl_gfx_path_interpolate(Eo *obj, Efl_Canvas_Vg_Contain if (!r) break; } - //Interpolates Mask + //Interpolates Composite Efl_Canvas_Vg_Container_Data *fromd = efl_data_scope_get(from, MY_CLASS); Efl_Canvas_Vg_Container_Data *tod = efl_data_scope_get(to, MY_CLASS); - if (fromd->mask_src && tod->mask_src && pd->mask_src) + if (fromd->comp_target && tod->comp_target && pd->comp_target) { - if (!efl_gfx_path_interpolate(pd->mask_src, - fromd->mask_src, tod->mask_src, pos_map)) + if (!efl_gfx_path_interpolate(pd->comp_target, + fromd->comp_target, tod->comp_target, pos_map)) return EINA_FALSE; } @@ -351,30 +335,30 @@ _efl_canvas_vg_container_efl_gfx_path_interpolate(Eo *obj, Efl_Canvas_Vg_Contain } static void -_efl_canvas_vg_container_efl_canvas_vg_node_mask_set(Eo *obj, - Efl_Canvas_Vg_Container_Data *pd, - Efl_Canvas_Vg_Node *mask, - int op) +_efl_canvas_vg_container_efl_canvas_vg_node_comp_method_set(Eo *obj, + Efl_Canvas_Vg_Container_Data *pd, + Efl_Canvas_Vg_Node *target, + Ector_Renderer_Composite_Method method) { - if (pd->mask_src == mask) return; + if (pd->comp_target == target) return; - EINA_SAFETY_ON_FALSE_RETURN(efl_isa(mask, MY_CLASS)); + EINA_SAFETY_ON_FALSE_RETURN(efl_isa(target, MY_CLASS)); - if (pd->mask_src) + if (pd->comp_target) { Efl_Canvas_Vg_Container_Data *pd2 = - efl_data_scope_get(pd->mask_src, MY_CLASS); - pd2->mask.target = eina_list_remove(pd2->mask.target, obj); + efl_data_scope_get(pd->comp_target, MY_CLASS); + pd2->comp.src = eina_list_remove(pd2->comp.src, obj); } - if (mask) + if (target) { - Efl_Canvas_Vg_Container_Data *pd2 = efl_data_scope_get(mask, MY_CLASS); - pd2->mask.target = eina_list_append(pd2->mask.target, obj); + Efl_Canvas_Vg_Container_Data *pd2 = efl_data_scope_get(target, MY_CLASS); + pd2->comp.src = eina_list_append(pd2->comp.src, obj); } - pd->mask.option = op; - efl_replace(&pd->mask_src, mask); + pd->comp.method = method; + efl_replace(&pd->comp_target, target); efl_canvas_vg_node_change(obj); } @@ -400,12 +384,12 @@ _efl_canvas_vg_container_efl_duplicate_duplicate(const Eo *obj, container = efl_duplicate(efl_super(obj, MY_CLASS)); efl_event_callback_add(container, EFL_EVENT_INVALIDATE, _invalidate_cb, NULL); - //Copy Mask - if (pd->mask_src) + //Copy Composite + if (pd->comp_target) { - Eo * mask_src = efl_duplicate(pd->mask_src); - efl_parent_set(mask_src, container); - efl_canvas_vg_node_mask_set(container, mask_src, pd->mask.option); + Eo * comp_target = efl_duplicate(pd->comp_target); + efl_parent_set(comp_target, container); + efl_canvas_vg_node_comp_method_set(container, comp_target, pd->comp.method); } //Copy Children diff --git a/src/lib/evas/canvas/efl_canvas_vg_container.eo b/src/lib/evas/canvas/efl_canvas_vg_container.eo index a987246531..7b1397d447 100644 --- a/src/lib/evas/canvas/efl_canvas_vg_container.eo +++ b/src/lib/evas/canvas/efl_canvas_vg_container.eo @@ -21,6 +21,6 @@ class @beta Efl.Canvas.Vg.Container extends Efl.Canvas.Vg.Node Efl.Gfx.Path.bounds_get; Efl.Gfx.Path.interpolate; Efl.Duplicate.duplicate; - Efl.Canvas.Vg.Node.mask { set; } + Efl.Canvas.Vg.Node.comp_method { set; } } } diff --git a/src/lib/evas/canvas/efl_canvas_vg_gradient_linear.c b/src/lib/evas/canvas/efl_canvas_vg_gradient_linear.c index 0b1435202b..bfef7200c6 100644 --- a/src/lib/evas/canvas/efl_canvas_vg_gradient_linear.c +++ b/src/lib/evas/canvas/efl_canvas_vg_gradient_linear.c @@ -64,8 +64,8 @@ _efl_canvas_vg_gradient_linear_render_pre(Evas_Object_Protected_Data *vg_pd EINA void *context EINA_UNUSED, Ector_Surface *surface, Eina_Matrix3 *ptransform, - Ector_Buffer *mask, - int mask_op, + Ector_Buffer *comp, + Ector_Renderer_Composite_Method comp_method, void *data) { Efl_Canvas_Vg_Gradient_Linear_Data *pd = data; @@ -94,7 +94,7 @@ _efl_canvas_vg_gradient_linear_render_pre(Evas_Object_Protected_Data *vg_pd EINA efl_gfx_gradient_linear_start_set(nd->renderer, pd->start.x, pd->start.y); efl_gfx_gradient_linear_end_set(nd->renderer, pd->end.x, pd->end.y); ector_renderer_prepare(nd->renderer); - ector_renderer_mask_set(nd->renderer, mask, mask_op); + ector_renderer_comp_method_set(nd->renderer, comp, comp_method); } static Eo * diff --git a/src/lib/evas/canvas/efl_canvas_vg_gradient_radial.c b/src/lib/evas/canvas/efl_canvas_vg_gradient_radial.c index 691dc5dec8..aea143fc21 100644 --- a/src/lib/evas/canvas/efl_canvas_vg_gradient_radial.c +++ b/src/lib/evas/canvas/efl_canvas_vg_gradient_radial.c @@ -80,8 +80,8 @@ _efl_canvas_vg_gradient_radial_render_pre(Evas_Object_Protected_Data *vg_pd EINA void *context EINA_UNUSED, Ector_Surface *surface, Eina_Matrix3 *ptransform, - Ector_Buffer *mask, - int mask_op, + Ector_Buffer *comp, + Ector_Renderer_Composite_Method comp_method, void *data) { Efl_Canvas_Vg_Gradient_Radial_Data *pd = data; @@ -111,7 +111,7 @@ _efl_canvas_vg_gradient_radial_render_pre(Evas_Object_Protected_Data *vg_pd EINA efl_gfx_gradient_radial_focal_set(nd->renderer, pd->focal.x, pd->focal.y); efl_gfx_gradient_radial_radius_set(nd->renderer, pd->radius); ector_renderer_prepare(nd->renderer); - ector_renderer_mask_set(nd->renderer, mask, mask_op); + ector_renderer_comp_method_set(nd->renderer, comp, comp_method); } static Eo * diff --git a/src/lib/evas/canvas/efl_canvas_vg_image.c b/src/lib/evas/canvas/efl_canvas_vg_image.c index d008fd74f9..e6a4337b69 100644 --- a/src/lib/evas/canvas/efl_canvas_vg_image.c +++ b/src/lib/evas/canvas/efl_canvas_vg_image.c @@ -21,8 +21,8 @@ _efl_canvas_vg_image_render_pre(Evas_Object_Protected_Data *vg_pd, void *engine EINA_UNUSED, void *output EINA_UNUSED, void *context EINA_UNUSED, Ector_Surface *surface, Eina_Matrix3 *ptransform, - Ector_Buffer *mask, - int mask_op, + Ector_Buffer *comp, + Ector_Renderer_Composite_Method comp_method, void *data) { Efl_Canvas_Vg_Image_Data *pd = data; @@ -63,7 +63,7 @@ _efl_canvas_vg_image_render_pre(Evas_Object_Protected_Data *vg_pd, ector_renderer_color_set(nd->renderer, nd->r, nd->g, nd->b, nd->a); ector_renderer_visibility_set(nd->renderer, nd->visibility); - ector_renderer_mask_set(nd->renderer, mask, mask_op); + ector_renderer_comp_method_set(nd->renderer, comp, comp_method); ector_renderer_prepare(nd->renderer); } diff --git a/src/lib/evas/canvas/efl_canvas_vg_node.c b/src/lib/evas/canvas/efl_canvas_vg_node.c index 95dcdc5152..b5332fa09f 100644 --- a/src/lib/evas/canvas/efl_canvas_vg_node.c +++ b/src/lib/evas/canvas/efl_canvas_vg_node.c @@ -73,10 +73,10 @@ _efl_canvas_vg_node_transformation_get(const Eo *obj EINA_UNUSED, Efl_Canvas_Vg_ } static void -_efl_canvas_vg_node_mask_set(Eo *obj EINA_UNUSED, - Efl_Canvas_Vg_Node_Data *pd EINA_UNUSED, - Efl_Canvas_Vg_Node *mask EINA_UNUSED, - int op EINA_UNUSED) +_efl_canvas_vg_node_comp_method_set(Eo *obj EINA_UNUSED, + Efl_Canvas_Vg_Node_Data *pd EINA_UNUSED, + Efl_Canvas_Vg_Node *target EINA_UNUSED, + Ector_Renderer_Composite_Method method EINA_UNUSED) { } diff --git a/src/lib/evas/canvas/efl_canvas_vg_node.eo b/src/lib/evas/canvas/efl_canvas_vg_node.eo index 641cda1c11..1cf8dfd220 100644 --- a/src/lib/evas/canvas/efl_canvas_vg_node.eo +++ b/src/lib/evas/canvas/efl_canvas_vg_node.eo @@ -1,4 +1,5 @@ import eina_types; +import ector_types; abstract @beta Efl.Canvas.Vg.Node extends Efl.Object implements Efl.Gfx.Entity, Efl.Gfx.Color, Efl.Gfx.Stack, Efl.Duplicate, Efl.Gfx.Path { @@ -35,13 +36,13 @@ abstract @beta Efl.Canvas.Vg.Node extends Efl.Object implements Efl.Gfx.Entity, y: double; [[$origin y position.]] } } - @property mask { - [[Set Mask Node to this renderer]] + @property comp_method { + [[Set a composite target node to this node object.]] set { } values { - mask: Efl.Canvas.Vg.Node; [[Mask object]] - op: int; [[Masking Option. Reserved]] + target: Efl.Canvas.Vg.Node; [[Composite target node]] + method: Ector.Renderer.Composite_Method; [[Composite Method.]] } } } diff --git a/src/lib/evas/canvas/efl_canvas_vg_node_eo.legacy.c b/src/lib/evas/canvas/efl_canvas_vg_node_eo.legacy.c index eda76165cb..559434b294 100644 --- a/src/lib/evas/canvas/efl_canvas_vg_node_eo.legacy.c +++ b/src/lib/evas/canvas/efl_canvas_vg_node_eo.legacy.c @@ -24,7 +24,7 @@ evas_vg_node_origin_get(const Efl_Canvas_Vg_Node *obj, double *x, double *y) } EAPI void -evas_vg_node_mask_set(Efl_Canvas_Vg_Node *obj, Efl_Canvas_Vg_Node *mask, int op) +evas_vg_node_mask_set(Efl_Canvas_Vg_Node *obj, Efl_Canvas_Vg_Node *mask, int op EINA_UNUSED) { - efl_canvas_vg_node_mask_set(obj, mask, op); + efl_canvas_vg_node_comp_method_set(obj, mask, 0); } diff --git a/src/lib/evas/canvas/efl_canvas_vg_object.c b/src/lib/evas/canvas/efl_canvas_vg_object.c index 56f892023b..ebcdce50cc 100644 --- a/src/lib/evas/canvas/efl_canvas_vg_object.c +++ b/src/lib/evas/canvas/efl_canvas_vg_object.c @@ -396,7 +396,7 @@ _evas_vg_render(Evas_Object_Protected_Data *obj, Efl_Canvas_Vg_Object_Data *pd, Eina_List *l; Efl_Canvas_Vg_Container_Data *cd = efl_data_scope_get(node, EFL_CANVAS_VG_CONTAINER_CLASS); - if (cd->mask.target) return; //Don't draw mask itself. + if (cd->comp.src) return; //Don't draw composite target itself. int alpha = 255; efl_gfx_color_get(node, NULL, NULL, NULL, &alpha); @@ -508,7 +508,7 @@ _render_to_buffer(Evas_Object_Protected_Data *obj, Efl_Canvas_Vg_Object_Data *pd evas_common_draw_context_set_render_op(context, _EVAS_RENDER_COPY); evas_common_draw_context_set_color(context, 255, 255, 255, 255); - //ector begin - end for drawing mask images. + //ector begin - end for drawing composite images. //ENFN->ector_begin(engine, buffer, context, ector, 0, 0, EINA_FALSE, EINA_FALSE); _evas_vg_render_pre(obj, root, engine, buffer, context, ector, NULL, NULL, 0); //ENFN->ector_end(engine, buffer, context, ector, EINA_FALSE); diff --git a/src/lib/evas/canvas/efl_canvas_vg_shape.c b/src/lib/evas/canvas/efl_canvas_vg_shape.c index c7a3c65863..87fc58249b 100644 --- a/src/lib/evas/canvas/efl_canvas_vg_shape.c +++ b/src/lib/evas/canvas/efl_canvas_vg_shape.c @@ -78,8 +78,8 @@ _efl_canvas_vg_shape_render_pre(Evas_Object_Protected_Data *vg_pd, void *engine, void *output, void *context, Ector_Surface *surface, Eina_Matrix3 *ptransform, - Ector_Buffer *mask, - int mask_op, + Ector_Buffer *comp, + Ector_Renderer_Composite_Method comp_method, void *data) { Efl_Canvas_Vg_Shape_Data *pd = data; @@ -93,13 +93,13 @@ _efl_canvas_vg_shape_render_pre(Evas_Object_Protected_Data *vg_pd, fill = _evas_vg_render_pre(vg_pd, pd->fill, engine, output, context, - surface, ctransform, mask, mask_op); + surface, ctransform, comp, comp_method); stroke_fill = _evas_vg_render_pre(vg_pd, pd->stroke.fill, engine, output, context, - surface, ctransform, mask, mask_op); + surface, ctransform, comp, comp_method); stroke_marker = _evas_vg_render_pre(vg_pd, pd->stroke.marker, engine, output, context, - surface, ctransform, mask, mask_op); + surface, ctransform, comp, comp_method); if (!nd->renderer) { @@ -117,7 +117,7 @@ _efl_canvas_vg_shape_render_pre(Evas_Object_Protected_Data *vg_pd, efl_gfx_path_copy_from(nd->renderer, obj); efl_gfx_path_commit(nd->renderer); ector_renderer_prepare(nd->renderer); - ector_renderer_mask_set(nd->renderer, mask, mask_op); + ector_renderer_comp_method_set(nd->renderer, comp, comp_method); } static Eo * diff --git a/src/lib/evas/canvas/evas_vg_private.h b/src/lib/evas/canvas/evas_vg_private.h index 0fad40d15c..6b226fa85f 100644 --- a/src/lib/evas/canvas/evas_vg_private.h +++ b/src/lib/evas/canvas/evas_vg_private.h @@ -67,7 +67,7 @@ struct _Efl_Canvas_Vg_Node_Data void (*render_pre)(Evas_Object_Protected_Data *vg_pd, Efl_VG *node, Efl_Canvas_Vg_Node_Data *nd, void *engine, void *output, void *contenxt, Ector_Surface *surface, - Eina_Matrix3 *ptransform, Ector_Buffer *mask, int mask_op, void *data); + Eina_Matrix3 *ptransform, Ector_Buffer *comp, Ector_Renderer_Composite_Method comp_method, void *data); void *data; double x, y; @@ -78,24 +78,24 @@ struct _Efl_Canvas_Vg_Node_Data Eina_Bool changed : 1; }; -typedef struct _Vg_Mask +typedef struct _Vg_Composite { - Evas_Object_Protected_Data *vg_pd; //Vector Object (for accessing backend engine) - Ector_Buffer *buffer; //Mask Ector Buffer - void *pixels; //Mask pixel buffer (actual data) - Eina_Rect bound; //Mask boundary - Eina_List *target; //Mask target - int option; //Mask option -} Vg_Mask; + Evas_Object_Protected_Data *vg_pd; //Vector Object (for accessing backend engine) + Ector_Buffer *buffer; //Composite Ector Buffer + void *pixels; //Composite pixel buffer (actual data) + Eina_Rect bound; //Composite boundary + Eina_List *src; //Composite Sources + Ector_Renderer_Composite_Method method; //Composite Method +} Vg_Comp; struct _Efl_Canvas_Vg_Container_Data { Eina_List *children; Eina_Hash *names; - //Masking feature. - Efl_Canvas_Vg_Node *mask_src; //Mask Source - Vg_Mask mask; //Mask source data + //Composite feature. + Efl_Canvas_Vg_Node *comp_target; //Composite target + Vg_Comp comp; //Composite target data //Layer transparency feature. This buffer is only valid when the layer has transparency. Ector_Buffer *blend_buffer; @@ -150,13 +150,13 @@ _evas_vg_render_pre(Evas_Object_Protected_Data *vg_pd, Efl_VG *child, void *engine, void *output, void *context, Ector_Surface *surface, Eina_Matrix3 *transform, - Ector_Buffer *mask, int mask_op) + Ector_Buffer *comp, Ector_Renderer_Composite_Method comp_method) { if (!child) return NULL; Efl_Canvas_Vg_Node_Data *nd = efl_data_scope_get(child, EFL_CANVAS_VG_NODE_CLASS); if (nd) nd->render_pre(vg_pd, child, nd, engine, output, context, surface, - transform, mask, mask_op, nd->data); + transform, comp, comp_method, nd->data); return nd; } diff --git a/src/static_libs/vg_common/vg_common_json.c b/src/static_libs/vg_common/vg_common_json.c index 47923c95aa..b0aac7631c 100644 --- a/src/static_libs/vg_common/vg_common_json.c +++ b/src/static_libs/vg_common/vg_common_json.c @@ -9,21 +9,6 @@ #include <rlottie_capi.h> -//FIXME: This enum add temporarily to help understanding of additional code -//related to masking in prepare_mask. -//This needs to be formally declared through the eo class. -typedef enum _EFL_CANVAS_VG_NODE_BLEND_TYPE -{ - EFL_CANVAS_VG_NODE_BLEND_TYPE_NONE = 0, - EFL_CANVAS_VG_NODE_BLEND_TYPE_ALPHA, - EFL_CANVAS_VG_NODE_BLEND_TYPE_ALPHA_INV, - EFL_CANVAS_VG_NODE_BLEND_TYPE_MASK_ADD, - EFL_CANVAS_VG_NODE_BLEND_TYPE_MASK_SUBSTRACT, - EFL_CANVAS_VG_NODE_BLEND_TYPE_MASK_INTERSECT, - EFL_CANVAS_VG_NODE_BLEND_TYPE_MASK_DIFFERENCE -}EFL_CANVAS_VG_NODE_BLEND_TYPE; -// - static char* _get_key_val(void *key) { @@ -309,10 +294,10 @@ _construct_masks(Efl_Canvas_Vg_Container *mtarget, LOTMask *masks, unsigned int efl_key_data_set(mtarget, key, msource); } - //FIXME : EFL_CANVAS_VG_NODE_BLEND_TYPE_ALPHA option is temporary - //Currently matte alpha implemtnes is same the mask intersect impletment. + //FIXME : ECTOR_RENDERER_COMPOSITE_METHOD_ALPHA option is temporary + //Currently matte alpha implements is same the mask intersect implement. //It has been implemented as a multiplication calculation. - efl_canvas_vg_node_mask_set(mtarget, msource, EFL_CANVAS_VG_NODE_BLEND_TYPE_ALPHA); + efl_canvas_vg_node_comp_method_set(mtarget, msource, ECTOR_RENDERER_COMPOSITE_METHOD_MATTE_ALPHA); mtarget = msource; @@ -330,24 +315,24 @@ _construct_masks(Efl_Canvas_Vg_Container *mtarget, LOTMask *masks, unsigned int } _construct_mask_nodes(msource, mask, depth + 1); - EFL_CANVAS_VG_NODE_BLEND_TYPE mask_mode; + Ector_Renderer_Composite_Method mask_mode; switch (mask->mMode) { case MaskSubstract: - mask_mode = EFL_CANVAS_VG_NODE_BLEND_TYPE_MASK_SUBSTRACT; + mask_mode = ECTOR_RENDERER_COMPOSITE_METHOD_MASK_SUBSTRACT; break; case MaskIntersect: - mask_mode = EFL_CANVAS_VG_NODE_BLEND_TYPE_MASK_INTERSECT; + mask_mode = ECTOR_RENDERER_COMPOSITE_METHOD_MASK_INTERSECT; break; case MaskDifference: - mask_mode = EFL_CANVAS_VG_NODE_BLEND_TYPE_MASK_DIFFERENCE; + mask_mode = ECTOR_RENDERER_COMPOSITE_METHOD_MASK_DIFFERENCE; break; case MaskAdd: default: - mask_mode = EFL_CANVAS_VG_NODE_BLEND_TYPE_MASK_ADD; + mask_mode = ECTOR_RENDERER_COMPOSITE_METHOD_MASK_ADD; break; } - efl_canvas_vg_node_mask_set(mtarget, msource, mask_mode); + efl_canvas_vg_node_comp_method_set(mtarget, msource, mask_mode); mtarget = msource; } } @@ -395,7 +380,7 @@ _update_vg_tree(Efl_Canvas_Vg_Container *root, const LOTLayerNode *layer, int de if (matte_mode != 0) { - efl_canvas_vg_node_mask_set(ptree, ctree, matte_mode); + efl_canvas_vg_node_comp_method_set(ptree, ctree, matte_mode); mtarget = ctree; } matte_mode = (int) clayer->mMatte; @@ -415,10 +400,10 @@ _update_vg_tree(Efl_Canvas_Vg_Container *root, const LOTLayerNode *layer, int de matte_mode = 0; break; case MatteAlpha: - matte_mode = EFL_CANVAS_VG_NODE_BLEND_TYPE_ALPHA; + matte_mode = ECTOR_RENDERER_COMPOSITE_METHOD_MATTE_ALPHA; break; case MatteAlphaInv: - matte_mode = EFL_CANVAS_VG_NODE_BLEND_TYPE_ALPHA_INV; + matte_mode = ECTOR_RENDERER_COMPOSITE_METHOD_MATTE_ALPHA_INVERSE; break; case MatteLuma: matte_mode = 0; --
