From 9815d034c2c6e056b45ac682038a262ab7ce0f9b Mon Sep 17 00:00:00 2001 From: Hermet Park Date: Wed, 21 Aug 2019 16:51:59 +0900 Subject: [PATCH] Revert "ector: code refactoring." This reverts commit bacf73015e591c820fd2b7308d83e0844f9e3c43. --- 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 - .../software/ector_renderer_software_image.c | 28 +-- .../software/ector_renderer_software_image.eo | 2 +- .../software/ector_renderer_software_shape.c | 32 +-- .../software/ector_renderer_software_shape.eo | 2 +- .../ector/software/ector_software_private.h | 8 +- .../software/ector_software_rasterizer.c | 137 +++++++------ src/lib/evas/Evas.h | 2 - src/lib/evas/canvas/efl_canvas_vg_container.c | 192 ++++++++++-------- .../evas/canvas/efl_canvas_vg_container.eo | 2 +- .../canvas/efl_canvas_vg_gradient_linear.c | 6 +- .../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 +- .../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, 293 insertions(+), 265 deletions(-) diff --git a/src/lib/ector/Ector.h b/src/lib/ector/Ector.h index 2a391a7963..01a71d6e6e 100644 --- a/src/lib/ector/Ector.h +++ b/src/lib/ector/Ector.h @@ -86,8 +86,6 @@ 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 cc7e0ec27c..d0efab6a6c 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_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) +_ector_renderer_mask_set(Eo *obj EINA_UNUSED, + Ector_Renderer_Data *pd EINA_UNUSED, + Ector_Buffer *mask EINA_UNUSED, + int op EINA_UNUSED) { } diff --git a/src/lib/ector/ector_renderer.eo b/src/lib/ector/ector_renderer.eo index 8d702ae294..57726f3df1 100644 --- a/src/lib/ector/ector_renderer.eo +++ b/src/lib/ector/ector_renderer.eo @@ -1,5 +1,4 @@ import eina_types; -import ector_types; abstract @beta Ector.Renderer extends Efl.Object { @@ -79,13 +78,13 @@ abstract @beta Ector.Renderer extends Efl.Object return: uint; [[CRC value]] } } - @property comp_method { - [[Set Composite Buffer to this Renderer]] + @property mask { + [[Set Mask Image to this Renderer]] set { } values { - comp: Ector.Buffer; [[Composite Buffer]] - method: Ector.Renderer.Composite_Method; [[Composite method]] + mask: Ector.Buffer; [[Mask Image Buffer]] + op: int; [[Masking option]] } } draw @pure_virtual { diff --git a/src/lib/ector/ector_renderer_gradient.eo b/src/lib/ector/ector_renderer_gradient.eo index 376326f88b..fda0e33261 100644 --- a/src/lib/ector/ector_renderer_gradient.eo +++ b/src/lib/ector/ector_renderer_gradient.eo @@ -1,5 +1,3 @@ -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 c051d16edd..1e1a96bd1c 100644 --- a/src/lib/ector/ector_types.eot +++ b/src/lib/ector/ector_types.eot @@ -1,12 +1,2 @@ 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 bc45c387f4..cb8d93ad6c 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 *comp; - Ector_Renderer_Composite_Method comp_method; - int opacity; - Eina_Matrix3 inv_m; + Ector_Buffer *mask; + int mask_op; + 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 *comp = pd->comp ? efl_data_scope_get(pd->comp, ECTOR_SOFTWARE_BUFFER_BASE_MIXIN) : NULL; + 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 *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 (comp) + if (mask) { - uint32_t *m = comp->pixels.u32 + ((int)local_x + ((int)local_y * comp->generic->w)); - //FIXME : This comping can work only matte case. + uint32_t *m = mask->pixels.u32 + ((int)local_x + ((int)local_y * mask->generic->w)); + //FIXME : This masking 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_comp_method_set(Eo *obj EINA_UNUSED, - Ector_Renderer_Software_Image_Data *pd, - Ector_Buffer *comp, - Ector_Renderer_Composite_Method method) +_ector_renderer_software_image_ector_renderer_mask_set(Eo *obj EINA_UNUSED, + Ector_Renderer_Software_Image_Data *pd, + Ector_Buffer *mask, + int op) { - pd->comp = comp; - pd->comp_method = method; + pd->mask = mask; + pd->mask_op = op; } #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 477170242b..8a3f9c51e7 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.comp_method { set; } + Ector.Renderer.mask { 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 00a95b85f2..b9cf1faaed 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 *comp; - Ector_Renderer_Composite_Method comp_method; + Ector_Buffer *mask; + int mask_op; 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->comp, - pd->comp_method); + pd->mask, + pd->mask_op); } 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->comp, - pd->comp_method); + pd->mask, + pd->mask_op); } } @@ -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->comp, - pd->comp_method); + pd->mask, + pd->mask_op); } 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->comp, - pd->comp_method); + pd->mask, + pd->mask_op); } } @@ -828,14 +828,14 @@ _ector_renderer_software_shape_ector_renderer_crc_get(const Eo *obj, } static void -_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) +_ector_renderer_software_shape_ector_renderer_mask_set(Eo *obj EINA_UNUSED, + Ector_Renderer_Software_Shape_Data *pd, + Ector_Buffer *mask, + int op) { //Use ref/unref. - pd->comp = comp; - pd->comp_method = method; + pd->mask = mask; + pd->mask_op = op; } #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 83b87c0121..4ea56f9260 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.comp_method { set; } + Ector.Renderer.mask { 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 7ac63b5646..62d1c3f8fd 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 *comp; - Ector_Renderer_Composite_Method comp_method; + Ector_Software_Buffer_Base_Data *mask; + int mask_op; 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 *comp, - Ector_Renderer_Composite_Method comp_method); + Ector_Buffer *mask, + int mask_op); 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 d4b67561fe..2b995c9e81 100644 --- a/src/lib/ector/software/ector_software_rasterizer.c +++ b/src/lib/ector/software/ector_software_rasterizer.c @@ -11,6 +11,21 @@ #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) { @@ -34,12 +49,12 @@ _blend_argb(int count, const SW_FT_Span *spans, void *user_data) } static void -_comp_matte_alpha(int count, const SW_FT_Span *spans, void *user_data) +_blend_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 *comp = sd->comp; - if (!comp || !comp->pixels.u32) return; + Ector_Software_Buffer_Base_Data *mask = sd->mask; + if (!mask || !mask->pixels.u32) return; // multiply the color with mul_col if any uint32_t color = DRAW_MUL4_SYM(sd->color, sd->mul_col); @@ -48,7 +63,7 @@ _comp_matte_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 = comp->pixels.u32; + uint32_t *mbuffer = mask->pixels.u32; //Temp buffer for intermediate processing int tsize = sd->raster_buffer->generic->w; @@ -58,12 +73,12 @@ _comp_matte_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 + ((comp->generic->w * spans->y) + spans->x); + mbuffer + ((mask->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); - //composite + //masking for (int i = 0; i < spans->len; i++) { *temp = draw_mul_256(((*mtarget)>>24), *temp); @@ -78,12 +93,12 @@ _comp_matte_alpha(int count, const SW_FT_Span *spans, void *user_data) } static void -_comp_matte_alpha_inv(int count, const SW_FT_Span *spans, void *user_data) +_blend_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 *comp = sd->comp; - if (!comp || !comp->pixels.u32) return; + Ector_Software_Buffer_Base_Data *mask = sd->mask; + if (!mask || !mask->pixels.u32) return; // multiply the color with mul_col if any uint32_t color = DRAW_MUL4_SYM(sd->color, sd->mul_col); @@ -92,7 +107,7 @@ _comp_matte_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 = comp->pixels.u32; + uint32_t *mbuffer = mask->pixels.u32; //Temp buffer for intermediate processing int tsize = sd->raster_buffer->generic->w; @@ -102,12 +117,12 @@ _comp_matte_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 + ((comp->generic->w * spans->y) + spans->x); + mbuffer + ((mask->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); - //composite + //masking for (int i = 0; i < spans->len; i++) { if (*mtarget) @@ -123,22 +138,22 @@ _comp_matte_alpha_inv(int count, const SW_FT_Span *spans, void *user_data) } static void -_comp_mask_add(int count, const SW_FT_Span *spans, void *user_data) +_blend_mask_add(int count, const SW_FT_Span *spans, void *user_data) { Span_Data *sd = user_data; - Ector_Software_Buffer_Base_Data *comp = sd->comp; - if (!comp || !comp->pixels.u32) return; + Ector_Software_Buffer_Base_Data *mask = sd->mask; + if (!mask || !mask->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 = comp->pixels.u32; + uint32_t *mbuffer = mask->pixels.u32; int tsize = sd->raster_buffer->generic->w; uint32_t *ttarget = alloca(sizeof(uint32_t) * tsize); while (count--) { - uint32_t *mtarget = mbuffer + ((comp->generic->w * spans->y) + spans->x); + uint32_t *mtarget = mbuffer + ((mask->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++) @@ -148,22 +163,22 @@ _comp_mask_add(int count, const SW_FT_Span *spans, void *user_data) } static void -_comp_mask_sub(int count, const SW_FT_Span *spans, void *user_data) +_blend_mask_sub(int count, const SW_FT_Span *spans, void *user_data) { Span_Data *sd = user_data; - Ector_Software_Buffer_Base_Data *comp = sd->comp; - if (!comp || !comp->pixels.u32) return; + Ector_Software_Buffer_Base_Data *mask = sd->mask; + if (!mask || !mask->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 = comp->pixels.u32; + uint32_t *mbuffer = mask->pixels.u32; int tsize = sd->raster_buffer->generic->w; uint32_t *ttarget = alloca(sizeof(uint32_t) * tsize); while (count--) { - uint32_t *mtarget = mbuffer + ((comp->generic->w * spans->y) + spans->x); + uint32_t *mtarget = mbuffer + ((mask->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++) @@ -174,28 +189,28 @@ _comp_mask_sub(int count, const SW_FT_Span *spans, void *user_data) static void -_comp_mask_ins(int count, const SW_FT_Span *spans, void *user_data) +_blend_mask_ins(int count, const SW_FT_Span *spans, void *user_data) { Span_Data *sd = user_data; - Ector_Software_Buffer_Base_Data *comp = sd->comp; - if (!comp || !comp->pixels.u32) return; + Ector_Software_Buffer_Base_Data *mask = sd->mask; + if (!mask || !mask->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 = comp->pixels.u32; + uint32_t *mbuffer = mask->pixels.u32; int tsize = sd->raster_buffer->generic->w; uint32_t *ttarget = alloca(sizeof(uint32_t) * tsize); - for(unsigned int y = 0; y < comp->generic->h; y++) + for(unsigned int y = 0; y < mask->generic->h; y++) { - for(unsigned int x = 0; x < comp->generic->w; x++) + for(unsigned int x = 0; x < mask->generic->w; x++) { - if (x == (unsigned int)spans->x && x + spans->len <= comp->generic->w && + if (x == (unsigned int)spans->x && x + spans->len <= mask->generic->w && y == (unsigned int)spans->y && count > 0) { memset(ttarget, 0x00, sizeof(uint32_t) * spans->len); - uint32_t *mtarget = mbuffer + ((comp->generic->w * spans->y) + spans->x); + uint32_t *mtarget = mbuffer + ((mask->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]); @@ -205,7 +220,7 @@ _comp_mask_ins(int count, const SW_FT_Span *spans, void *user_data) } else { - mbuffer[x + (comp->generic->w * y)] = (0x00FFFFFF & mbuffer[x + (comp->generic->w * y)]); + mbuffer[x + (mask->generic->w * y)] = (0x00FFFFFF & mbuffer[x + (mask->generic->w * y)]); } } } @@ -213,15 +228,15 @@ _comp_mask_ins(int count, const SW_FT_Span *spans, void *user_data) static void -_comp_mask_diff(int count, const SW_FT_Span *spans, void *user_data) +_blend_mask_diff(int count, const SW_FT_Span *spans, void *user_data) { Span_Data *sd = user_data; - Ector_Software_Buffer_Base_Data *comp = sd->comp; - if (!comp || !comp->pixels.u32) return; + Ector_Software_Buffer_Base_Data *mask = sd->mask; + if (!mask || !mask->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 = comp->pixels.u32; + uint32_t *mbuffer = mask->pixels.u32; int tsize = sd->raster_buffer->generic->w; uint32_t *ttarget = alloca(sizeof(uint32_t) * tsize); @@ -229,7 +244,7 @@ _comp_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 + ((comp->generic->w * spans->y) + spans->x); + uint32_t *mtarget = mbuffer + ((mask->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]); @@ -295,8 +310,8 @@ _blend_gradient_alpha(int count, const SW_FT_Span *spans, void *user_data) if (!fetchfunc) return; - Ector_Software_Buffer_Base_Data *comp = data->comp; - uint32_t *mbuffer = comp->pixels.u32; + Ector_Software_Buffer_Base_Data *mask = data->mask; + uint32_t *mbuffer = mask->pixels.u32; //Temp buffer for intermediate processing uint32_t *tbuffer = malloc(sizeof(uint32_t) * data->raster_buffer->generic->w); @@ -309,7 +324,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 + ((comp->generic->w * spans->y) + spans->x); + uint32_t *mtarget = mbuffer + ((mask->generic->w * spans->y) + spans->x); uint32_t *temp = tbuffer; int length = spans->len; memset(temp, 0x00, sizeof(uint32_t) * spans->len); @@ -352,8 +367,8 @@ _blend_gradient_alpha_inv(int count, const SW_FT_Span *spans, void *user_data) if (!fetchfunc) return; - Ector_Software_Buffer_Base_Data *comp = data->comp; - uint32_t *mbuffer = comp->pixels.u32; + Ector_Software_Buffer_Base_Data *mask = data->mask; + uint32_t *mbuffer = mask->pixels.u32; //Temp buffer for intermediate processing uint32_t *tbuffer = malloc(sizeof(uint32_t) * data->raster_buffer->generic->w); @@ -366,7 +381,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 + ((comp->generic->w * spans->y) + spans->x); + uint32_t *mtarget = mbuffer + ((mask->generic->w * spans->y) + spans->x); uint32_t *temp = tbuffer; int length = spans->len; memset(temp, 0x00, sizeof(uint32_t) * spans->len); @@ -584,38 +599,38 @@ static void _adjust_span_fill_methods(Span_Data *spdata) { //Blending Function - if (spdata->comp) + if (spdata->mask) { - switch (spdata->comp_method) + switch (spdata->mask_op) { default: - case ECTOR_RENDERER_COMPOSITE_METHOD_MATTE_ALPHA: + case EFL_CANVAS_VG_NODE_BLEND_TYPE_ALPHA: if (spdata->type == Solid) - spdata->unclipped_blend = &_comp_matte_alpha; + spdata->unclipped_blend = &_blend_alpha; else if (spdata->type == LinearGradient || spdata->type == RadialGradient) spdata->unclipped_blend = &_blend_gradient_alpha; else //None spdata->unclipped_blend = NULL; break; - case ECTOR_RENDERER_COMPOSITE_METHOD_MATTE_ALPHA_INVERSE: + case EFL_CANVAS_VG_NODE_BLEND_TYPE_ALPHA_INV: if (spdata->type == Solid) - spdata->unclipped_blend = &_comp_matte_alpha_inv; + spdata->unclipped_blend = &_blend_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 ECTOR_RENDERER_COMPOSITE_METHOD_MASK_ADD: - spdata->unclipped_blend = &_comp_mask_add; + case EFL_CANVAS_VG_NODE_BLEND_TYPE_MASK_ADD: + spdata->unclipped_blend = &_blend_mask_add; break; - case ECTOR_RENDERER_COMPOSITE_METHOD_MASK_SUBSTRACT: - spdata->unclipped_blend = &_comp_mask_sub; + case EFL_CANVAS_VG_NODE_BLEND_TYPE_MASK_SUBSTRACT: + spdata->unclipped_blend = &_blend_mask_sub; break; - case ECTOR_RENDERER_COMPOSITE_METHOD_MASK_INTERSECT: - spdata->unclipped_blend = &_comp_mask_ins; + case EFL_CANVAS_VG_NODE_BLEND_TYPE_MASK_INTERSECT: + spdata->unclipped_blend = &_blend_mask_ins; break; - case ECTOR_RENDERER_COMPOSITE_METHOD_MASK_DIFFERENCE: - spdata->unclipped_blend = &_comp_mask_diff; + case EFL_CANVAS_VG_NODE_BLEND_TYPE_MASK_DIFFERENCE: + spdata->unclipped_blend = &_blend_mask_diff; break; } } @@ -895,8 +910,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 *comp, - Ector_Renderer_Composite_Method comp_method) + Ector_Buffer *mask, + int mask_op) { if (!rle) return; if (!rasterizer->fill_data.raster_buffer->pixels.u32) return; @@ -905,9 +920,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.comp = - comp ? efl_data_scope_get(comp, ECTOR_SOFTWARE_BUFFER_BASE_MIXIN) : NULL; - rasterizer->fill_data.comp_method = comp_method; + rasterizer->fill_data.mask = + mask ? efl_data_scope_get(mask, ECTOR_SOFTWARE_BUFFER_BASE_MIXIN) : NULL; + rasterizer->fill_data.mask_op = mask_op; _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 d35e82dfc1..9044398971 100644 --- a/src/lib/evas/Evas.h +++ b/src/lib/evas/Evas.h @@ -172,8 +172,6 @@ /* This include has been added to support Eo in Evas */ #include -#include - #include #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 9f42b2340c..2daa65fb80 100644 --- a/src/lib/evas/canvas/efl_canvas_vg_container.c +++ b/src/lib/evas/canvas/efl_canvas_vg_container.c @@ -5,6 +5,23 @@ #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) { @@ -23,7 +40,7 @@ _invalidate_cb(void *data EINA_UNUSED, const Efl_Event *event) } static void -_draw_comp(Evas_Object_Protected_Data *obj, Efl_VG *node, +_draw_mask(Evas_Object_Protected_Data *obj, Efl_VG *node, Ector_Surface *ector, void *engine, void *output, void *context) { @@ -34,11 +51,11 @@ _draw_comp(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 Composite Image. + //Draw Mask Image. Efl_VG *child; Eina_List *l; EINA_LIST_FOREACH(cd->children, l, child) - _draw_comp(obj, child, ector, engine, output, context); + _draw_mask(obj, child, ector, engine, output, context); } else { @@ -48,94 +65,93 @@ _draw_comp(Evas_Object_Protected_Data *obj, Efl_VG *node, } static Ector_Buffer * -_prepare_comp(Evas_Object_Protected_Data *obj, //vector object - Efl_Canvas_Vg_Node* comp_target, +_prepare_mask(Evas_Object_Protected_Data *obj, //vector object + Efl_Canvas_Vg_Node* mask_obj, void *engine, void *output, void *context, Ector_Surface *surface, Eina_Matrix3 *ptransform, Eina_Matrix3 *ctransform, - Ector_Buffer *comp, - Ector_Renderer_Composite_Method comp_method) + Ector_Buffer *mask, + int mask_op) { - Efl_Canvas_Vg_Container_Data *pd = efl_data_scope_get(comp_target, MY_CLASS); + Efl_Canvas_Vg_Container_Data *pd = efl_data_scope_get(mask_obj, MY_CLASS); Efl_Canvas_Vg_Node_Data *nd = - efl_data_scope_get(comp_target, EFL_CANVAS_VG_NODE_CLASS); - if (nd->flags == EFL_GFX_CHANGE_FLAG_NONE) return pd->comp.buffer; + efl_data_scope_get(mask_obj, EFL_CANVAS_VG_NODE_CLASS); + if (nd->flags == EFL_GFX_CHANGE_FLAG_NONE) return pd->mask.buffer; uint32_t init_buffer = 0x0; - //1. Composite Size + //1. Mask Size Eina_Rect mbound; mbound.x = 0; mbound.y = 0; mbound.w = obj->cur->geometry.w; mbound.h = obj->cur->geometry.h; - //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) + //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) init_buffer = 0xFFFFFFFF; //2. Reusable ector buffer? - if (!pd->comp.buffer || (pd->comp.bound.w != mbound.w) || - (pd->comp.bound.h != mbound.h)) + if (!pd->mask.buffer || (pd->mask.bound.w != mbound.w) || + (pd->mask.bound.h != mbound.h)) { - 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, + 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, 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->comp.buffer, pd->comp.pixels, + ector_buffer_pixels_set(pd->mask.buffer, pd->mask.pixels, mbound.w, mbound.h, 0, EFL_GFX_COLORSPACE_ARGB8888, EINA_TRUE); - pd->comp.bound.w = mbound.w; - pd->comp.bound.h = mbound.h; - pd->comp.vg_pd = obj; + pd->mask.bound.w = mbound.w; + pd->mask.bound.h = mbound.h; + pd->mask.vg_pd = obj; } else { - if (pd->comp.pixels) - memset(pd->comp.pixels, init_buffer, sizeof(uint32_t) * mbound.w * mbound.h); + if (pd->mask.pixels) + memset(pd->mask.pixels, init_buffer, sizeof(uint32_t) * mbound.w * mbound.h); } - pd->comp.bound.x = mbound.x; - pd->comp.bound.y = mbound.y; + pd->mask.bound.x = mbound.x; + pd->mask.bound.y = mbound.y; - if (!pd->comp.buffer) ERR("Composite Buffer is invalid"); + if (!pd->mask.buffer) ERR("Mask Buffer is invalid"); - //FIXME: This code means that there is another composite container. - if (pd->comp.method >= ECTOR_RENDERER_COMPOSITE_METHOD_MASK_ADD) + //FIXME: This code means that there is another masking container. + if (pd->mask.option >= EFL_CANVAS_VG_NODE_BLEND_TYPE_MASK_ADD) { - 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 *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 *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, + 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, engine, output, context, surface, - ctransform, comp, src_pd->comp.method); + ctransform, mask, target_pd->mask.option); } } //3. Prepare Drawing shapes. - _evas_vg_render_pre(obj, comp_target, + _evas_vg_render_pre(obj, mask_obj, engine, output, context, surface, - ptransform, comp, comp_method); + ptransform, mask, mask_op); - //4. Generating Composite Image. - ector_buffer_pixels_set(surface, pd->comp.pixels, mbound.w, mbound.h, 0, + //4. Generating Mask Image. + ector_buffer_pixels_set(surface, pd->mask.pixels, mbound.w, mbound.h, 0, EFL_GFX_COLORSPACE_ARGB8888, EINA_TRUE); ector_surface_reference_point_set(surface, -mbound.x, -mbound.y); - _draw_comp(obj, comp_target, surface, engine, output, context); + _draw_mask(obj, mask_obj, surface, engine, output, context); - return pd->comp.buffer; + return pd->mask.buffer; } static void @@ -145,8 +161,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 *comp, - Ector_Renderer_Composite_Method comp_method, + Ector_Buffer *mask, + int mask_op, void *data) { Efl_Canvas_Vg_Container_Data *pd = data; @@ -161,27 +177,27 @@ _efl_canvas_vg_container_render_pre(Evas_Object_Protected_Data *vg_pd, EFL_CANVAS_VG_COMPUTE_MATRIX(ctransform, ptransform, nd); - //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)) + //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)) { - comp_method = pd->comp.method; - comp = _prepare_comp(vg_pd, pd->comp_target, + mask_op = pd->mask.option; + mask = _prepare_mask(vg_pd, pd->mask_src, engine, output, context, surface, - ptransform, ctransform, comp, comp_method); + ptransform, ctransform, mask, mask_op); } EINA_LIST_FOREACH(pd->children, l, child) { - //Don't need to update composite nodes. + //Don't need to update mask nodes. if (efl_isa(child, MY_CLASS)) { Efl_Canvas_Vg_Container_Data *child_cd = efl_data_scope_get(child, MY_CLASS); - if (child_cd->comp.src) continue; + if (child_cd->mask.target) continue; } //Skip Gradients. they will be updated by Shape. @@ -196,7 +212,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, comp, comp_method); + ctransform, mask, mask_op); } } @@ -227,12 +243,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 comp surface - if (pd->comp.buffer) efl_unref(pd->comp.buffer); - if (pd->comp.pixels) free(pd->comp.pixels); + //Destroy mask surface + if (pd->mask.buffer) efl_unref(pd->mask.buffer); + if (pd->mask.pixels) free(pd->mask.pixels); - efl_unref(pd->comp_target); - eina_list_free(pd->comp.src); + efl_unref(pd->mask_src); + eina_list_free(pd->mask.target); eina_hash_free(pd->names); efl_destructor(efl_super(obj, MY_CLASS)); @@ -317,14 +333,14 @@ _efl_canvas_vg_container_efl_gfx_path_interpolate(Eo *obj, Efl_Canvas_Vg_Contain if (!r) break; } - //Interpolates Composite + //Interpolates Mask 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->comp_target && tod->comp_target && pd->comp_target) + if (fromd->mask_src && tod->mask_src && pd->mask_src) { - if (!efl_gfx_path_interpolate(pd->comp_target, - fromd->comp_target, tod->comp_target, pos_map)) + if (!efl_gfx_path_interpolate(pd->mask_src, + fromd->mask_src, tod->mask_src, pos_map)) return EINA_FALSE; } @@ -335,30 +351,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_comp_method_set(Eo *obj, - Efl_Canvas_Vg_Container_Data *pd, - Efl_Canvas_Vg_Node *target, - Ector_Renderer_Composite_Method method) +_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) { - if (pd->comp_target == target) return; + if (pd->mask_src == mask) return; - EINA_SAFETY_ON_FALSE_RETURN(efl_isa(target, MY_CLASS)); + EINA_SAFETY_ON_FALSE_RETURN(efl_isa(mask, MY_CLASS)); - if (pd->comp_target) + if (pd->mask_src) { Efl_Canvas_Vg_Container_Data *pd2 = - efl_data_scope_get(pd->comp_target, MY_CLASS); - pd2->comp.src = eina_list_remove(pd2->comp.src, obj); + efl_data_scope_get(pd->mask_src, MY_CLASS); + pd2->mask.target = eina_list_remove(pd2->mask.target, obj); } - if (target) + if (mask) { - Efl_Canvas_Vg_Container_Data *pd2 = efl_data_scope_get(target, MY_CLASS); - pd2->comp.src = eina_list_append(pd2->comp.src, obj); + Efl_Canvas_Vg_Container_Data *pd2 = efl_data_scope_get(mask, MY_CLASS); + pd2->mask.target = eina_list_append(pd2->mask.target, obj); } - pd->comp.method = method; - efl_replace(&pd->comp_target, target); + pd->mask.option = op; + efl_replace(&pd->mask_src, mask); efl_canvas_vg_node_change(obj); } @@ -384,12 +400,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 Composite - if (pd->comp_target) + //Copy Mask + if (pd->mask_src) { - 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); + 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); } //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 7b1397d447..a987246531 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.comp_method { set; } + Efl.Canvas.Vg.Node.mask { 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 bfef7200c6..0b1435202b 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 *comp, - Ector_Renderer_Composite_Method comp_method, + Ector_Buffer *mask, + int mask_op, 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_comp_method_set(nd->renderer, comp, comp_method); + ector_renderer_mask_set(nd->renderer, mask, mask_op); } 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 aea143fc21..691dc5dec8 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 *comp, - Ector_Renderer_Composite_Method comp_method, + Ector_Buffer *mask, + int mask_op, 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_comp_method_set(nd->renderer, comp, comp_method); + ector_renderer_mask_set(nd->renderer, mask, mask_op); } 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 e6a4337b69..d008fd74f9 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 *comp, - Ector_Renderer_Composite_Method comp_method, + Ector_Buffer *mask, + int mask_op, 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_comp_method_set(nd->renderer, comp, comp_method); + ector_renderer_mask_set(nd->renderer, mask, mask_op); 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 b5332fa09f..95dcdc5152 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_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) +_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) { } diff --git a/src/lib/evas/canvas/efl_canvas_vg_node.eo b/src/lib/evas/canvas/efl_canvas_vg_node.eo index 1cf8dfd220..641cda1c11 100644 --- a/src/lib/evas/canvas/efl_canvas_vg_node.eo +++ b/src/lib/evas/canvas/efl_canvas_vg_node.eo @@ -1,5 +1,4 @@ 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 { @@ -36,13 +35,13 @@ abstract @beta Efl.Canvas.Vg.Node extends Efl.Object implements Efl.Gfx.Entity, y: double; [[$origin y position.]] } } - @property comp_method { - [[Set a composite target node to this node object.]] + @property mask { + [[Set Mask Node to this renderer]] set { } values { - target: Efl.Canvas.Vg.Node; [[Composite target node]] - method: Ector.Renderer.Composite_Method; [[Composite Method.]] + mask: Efl.Canvas.Vg.Node; [[Mask object]] + op: int; [[Masking Option. Reserved]] } } } 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 559434b294..eda76165cb 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 EINA_UNUSED) +evas_vg_node_mask_set(Efl_Canvas_Vg_Node *obj, Efl_Canvas_Vg_Node *mask, int op) { - efl_canvas_vg_node_comp_method_set(obj, mask, 0); + efl_canvas_vg_node_mask_set(obj, mask, op); } diff --git a/src/lib/evas/canvas/efl_canvas_vg_object.c b/src/lib/evas/canvas/efl_canvas_vg_object.c index ebcdce50cc..56f892023b 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->comp.src) return; //Don't draw composite target itself. + if (cd->mask.target) return; //Don't draw mask 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 composite images. + //ector begin - end for drawing mask 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 87fc58249b..c7a3c65863 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 *comp, - Ector_Renderer_Composite_Method comp_method, + Ector_Buffer *mask, + int mask_op, 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, comp, comp_method); + surface, ctransform, mask, mask_op); stroke_fill = _evas_vg_render_pre(vg_pd, pd->stroke.fill, engine, output, context, - surface, ctransform, comp, comp_method); + surface, ctransform, mask, mask_op); stroke_marker = _evas_vg_render_pre(vg_pd, pd->stroke.marker, engine, output, context, - surface, ctransform, comp, comp_method); + surface, ctransform, mask, mask_op); 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_comp_method_set(nd->renderer, comp, comp_method); + ector_renderer_mask_set(nd->renderer, mask, mask_op); } static Eo * diff --git a/src/lib/evas/canvas/evas_vg_private.h b/src/lib/evas/canvas/evas_vg_private.h index 6b226fa85f..0fad40d15c 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 *comp, Ector_Renderer_Composite_Method comp_method, void *data); + Eina_Matrix3 *ptransform, Ector_Buffer *mask, int mask_op, void *data); void *data; double x, y; @@ -78,24 +78,24 @@ struct _Efl_Canvas_Vg_Node_Data Eina_Bool changed : 1; }; -typedef struct _Vg_Composite +typedef struct _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; + 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; struct _Efl_Canvas_Vg_Container_Data { Eina_List *children; Eina_Hash *names; - //Composite feature. - Efl_Canvas_Vg_Node *comp_target; //Composite target - Vg_Comp comp; //Composite target data + //Masking feature. + Efl_Canvas_Vg_Node *mask_src; //Mask Source + Vg_Mask mask; //Mask source 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 *comp, Ector_Renderer_Composite_Method comp_method) + Ector_Buffer *mask, int mask_op) { 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, comp, comp_method, nd->data); + transform, mask, mask_op, 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 b0aac7631c..47923c95aa 100644 --- a/src/static_libs/vg_common/vg_common_json.c +++ b/src/static_libs/vg_common/vg_common_json.c @@ -9,6 +9,21 @@ #include +//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) { @@ -294,10 +309,10 @@ _construct_masks(Efl_Canvas_Vg_Container *mtarget, LOTMask *masks, unsigned int efl_key_data_set(mtarget, key, msource); } - //FIXME : ECTOR_RENDERER_COMPOSITE_METHOD_ALPHA option is temporary - //Currently matte alpha implements is same the mask intersect implement. + //FIXME : EFL_CANVAS_VG_NODE_BLEND_TYPE_ALPHA option is temporary + //Currently matte alpha implemtnes is same the mask intersect impletment. //It has been implemented as a multiplication calculation. - efl_canvas_vg_node_comp_method_set(mtarget, msource, ECTOR_RENDERER_COMPOSITE_METHOD_MATTE_ALPHA); + efl_canvas_vg_node_mask_set(mtarget, msource, EFL_CANVAS_VG_NODE_BLEND_TYPE_ALPHA); mtarget = msource; @@ -315,24 +330,24 @@ _construct_masks(Efl_Canvas_Vg_Container *mtarget, LOTMask *masks, unsigned int } _construct_mask_nodes(msource, mask, depth + 1); - Ector_Renderer_Composite_Method mask_mode; + EFL_CANVAS_VG_NODE_BLEND_TYPE mask_mode; switch (mask->mMode) { case MaskSubstract: - mask_mode = ECTOR_RENDERER_COMPOSITE_METHOD_MASK_SUBSTRACT; + mask_mode = EFL_CANVAS_VG_NODE_BLEND_TYPE_MASK_SUBSTRACT; break; case MaskIntersect: - mask_mode = ECTOR_RENDERER_COMPOSITE_METHOD_MASK_INTERSECT; + mask_mode = EFL_CANVAS_VG_NODE_BLEND_TYPE_MASK_INTERSECT; break; case MaskDifference: - mask_mode = ECTOR_RENDERER_COMPOSITE_METHOD_MASK_DIFFERENCE; + mask_mode = EFL_CANVAS_VG_NODE_BLEND_TYPE_MASK_DIFFERENCE; break; case MaskAdd: default: - mask_mode = ECTOR_RENDERER_COMPOSITE_METHOD_MASK_ADD; + mask_mode = EFL_CANVAS_VG_NODE_BLEND_TYPE_MASK_ADD; break; } - efl_canvas_vg_node_comp_method_set(mtarget, msource, mask_mode); + efl_canvas_vg_node_mask_set(mtarget, msource, mask_mode); mtarget = msource; } } @@ -380,7 +395,7 @@ _update_vg_tree(Efl_Canvas_Vg_Container *root, const LOTLayerNode *layer, int de if (matte_mode != 0) { - efl_canvas_vg_node_comp_method_set(ptree, ctree, matte_mode); + efl_canvas_vg_node_mask_set(ptree, ctree, matte_mode); mtarget = ctree; } matte_mode = (int) clayer->mMatte; @@ -400,10 +415,10 @@ _update_vg_tree(Efl_Canvas_Vg_Container *root, const LOTLayerNode *layer, int de matte_mode = 0; break; case MatteAlpha: - matte_mode = ECTOR_RENDERER_COMPOSITE_METHOD_MATTE_ALPHA; + matte_mode = EFL_CANVAS_VG_NODE_BLEND_TYPE_ALPHA; break; case MatteAlphaInv: - matte_mode = ECTOR_RENDERER_COMPOSITE_METHOD_MATTE_ALPHA_INVERSE; + matte_mode = EFL_CANVAS_VG_NODE_BLEND_TYPE_ALPHA_INV; break; case MatteLuma: matte_mode = 0;