kimcinoo
/
efl
forked from enlightenment/efl
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

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().
This commit is contained in:
Hermet Park 2019-08-20 18:18:31 +09:00
parent ead8a28057
commit dad166f84a
24 changed files with 265 additions and 293 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/lib/ector/Ector.h
View File

@ -86,6 +86,8 @@ extern "C" {
#ifdef EFL_BETA_API_SUPPORT #ifdef EFL_BETA_API_SUPPORT
#include "ector_types.eot.h"
/** /**
* @typedef Ector_Surface * @typedef Ector_Surface
* The base type to render content into. * The base type to render content into.

8
src/lib/ector/ector_renderer.c
View File

@ -146,10 +146,10 @@ _ector_renderer_crc_get(const Eo *obj EINA_UNUSED,
} }
static void static void
_ector_renderer_mask_set(Eo *obj EINA_UNUSED, _ector_renderer_comp_method_set(Eo *obj EINA_UNUSED,
Ector_Renderer_Data *pd EINA_UNUSED, Ector_Renderer_Data *pd EINA_UNUSED,
Ector_Buffer *mask EINA_UNUSED, Ector_Buffer *comp EINA_UNUSED,
int op EINA_UNUSED) Ector_Renderer_Composite_Method method EINA_UNUSED)
{ {
} }

9
src/lib/ector/ector_renderer.eo
View File

@ -1,4 +1,5 @@
import eina_types; import eina_types;
import ector_types;
abstract @beta Ector.Renderer extends Efl.Object abstract @beta Ector.Renderer extends Efl.Object
{ {
@ -78,13 +79,13 @@ abstract @beta Ector.Renderer extends Efl.Object
return: uint; [[CRC value]] return: uint; [[CRC value]]
} }
} }
@property mask { @property comp_method {
[[Set Mask Image to this Renderer]] [[Set Composite Buffer to this Renderer]]
set { set {
} }
values { values {
mask: Ector.Buffer; [[Mask Image Buffer]] comp: Ector.Buffer; [[Composite Buffer]]
op: int; [[Masking option]] method: Ector.Renderer.Composite_Method; [[Composite method]]
} }
} }
draw @pure_virtual { draw @pure_virtual {

2
src/lib/ector/ector_renderer_gradient.eo
View File

@ -1,3 +1,5 @@
import ector_types;
mixin @beta Ector.Renderer.Gradient requires Efl.Object extends Efl.Gfx.Gradient mixin @beta Ector.Renderer.Gradient requires Efl.Object extends Efl.Gfx.Gradient
{ {
[[Ector gradient renderer mixin]] [[Ector gradient renderer mixin]]

10
src/lib/ector/ector_types.eot
View File

@ -1,2 +1,12 @@
type @extern GLshort: short; [[GLshort type]] /* FIXME: We should not expose this in the API but probably redefine it. */ 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
}

28
src/lib/ector/software/ector_renderer_software_image.c
View File

@ -21,10 +21,10 @@ struct _Ector_Renderer_Software_Image_Data
Ector_Software_Surface_Data *surface; Ector_Software_Surface_Data *surface;
Ector_Renderer_Image_Data *image; Ector_Renderer_Image_Data *image;
Ector_Renderer_Data *base; Ector_Renderer_Data *base;
Ector_Buffer *mask; Ector_Buffer *comp;
int mask_op; Ector_Renderer_Composite_Method comp_method;
int opacity; int opacity;
Eina_Matrix3 inv_m; Eina_Matrix3 inv_m;
struct { struct {
int x1, y1, x2, y2; int x1, y1, x2, y2;
} boundary; } boundary;
@ -101,7 +101,7 @@ _ector_renderer_software_image_ector_renderer_draw(Eo *obj EINA_UNUSED,
return EINA_TRUE; return EINA_TRUE;
const int pix_stride = pd->surface->rasterizer->fill_data.raster_buffer->stride / 4; 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); 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; double im11, im12, im21, im22, im31, im32;
uint32_t *dst_buf, *src_buf; uint32_t *dst_buf, *src_buf;
@ -128,10 +128,10 @@ _ector_renderer_software_image_ector_renderer_draw(Eo *obj EINA_UNUSED,
continue; continue;
uint32_t *src = src_buf + (rx + (ry * image_w)); //FIXME: use to stride uint32_t *src = src_buf + (rx + (ry * image_w)); //FIXME: use to stride
uint32_t temp = 0x0; uint32_t temp = 0x0;
if (mask) if (comp)
{ {
uint32_t *m = mask->pixels.u32 + ((int)local_x + ((int)local_y * mask->generic->w)); uint32_t *m = comp->pixels.u32 + ((int)local_x + ((int)local_y * comp->generic->w));
//FIXME : This masking can work only matte case. //FIXME : This comping can work only matte case.
// We need consider to inverse matte case. // We need consider to inverse matte case.
temp = draw_mul_256((((*m)>>24) * pd->opacity)>>8, *src); 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 static void
_ector_renderer_software_image_ector_renderer_mask_set(Eo *obj EINA_UNUSED, _ector_renderer_software_image_ector_renderer_comp_method_set(Eo *obj EINA_UNUSED,
Ector_Renderer_Software_Image_Data *pd, Ector_Renderer_Software_Image_Data *pd,
Ector_Buffer *mask, Ector_Buffer *comp,
int op) Ector_Renderer_Composite_Method method)
{ {
pd->mask = mask; pd->comp = comp;
pd->mask_op = op; pd->comp_method = method;
} }
#include "ector_renderer_software_image.eo.c" #include "ector_renderer_software_image.eo.c"

2
src/lib/ector/software/ector_renderer_software_image.eo
View File

@ -5,7 +5,7 @@ class @beta Ector.Renderer.Software.Image extends Ector.Renderer.Software implem
implements { implements {
Ector.Renderer.prepare; Ector.Renderer.prepare;
Ector.Renderer.draw; Ector.Renderer.draw;
Ector.Renderer.mask { set; } Ector.Renderer.comp_method { set; }
Ector.Renderer.crc { get; } Ector.Renderer.crc { get; }
Efl.Object.constructor; Efl.Object.constructor;
Efl.Object.destructor; Efl.Object.destructor;

32
src/lib/ector/software/ector_renderer_software_shape.c
View File

@ -38,8 +38,8 @@ struct _Ector_Renderer_Software_Shape_Data
Shape_Rle_Data *shape_data; Shape_Rle_Data *shape_data;
Shape_Rle_Data *outline_data; Shape_Rle_Data *outline_data;
Ector_Buffer *mask; Ector_Buffer *comp;
int mask_op; Ector_Renderer_Composite_Method comp_method;
Ector_Software_Shape_Task *task; 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, ector_software_rasterizer_draw_rle_data(pd->surface->rasterizer,
x, y, mul_col, op, x, y, mul_col, op,
pd->shape_data, pd->shape_data,
pd->mask, pd->comp,
pd->mask_op); pd->comp_method);
} }
else else
{ {
@ -689,8 +689,8 @@ _ector_renderer_software_shape_ector_renderer_draw(Eo *obj,
ector_software_rasterizer_draw_rle_data(pd->surface->rasterizer, ector_software_rasterizer_draw_rle_data(pd->surface->rasterizer,
x, y, mul_col, op, x, y, mul_col, op,
pd->shape_data, pd->shape_data,
pd->mask, pd->comp,
pd->mask_op); 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, ector_software_rasterizer_draw_rle_data(pd->surface->rasterizer,
x, y, mul_col, op, x, y, mul_col, op,
pd->outline_data, pd->outline_data,
pd->mask, pd->comp,
pd->mask_op); pd->comp_method);
} }
else else
{ {
@ -717,8 +717,8 @@ _ector_renderer_software_shape_ector_renderer_draw(Eo *obj,
ector_software_rasterizer_draw_rle_data(pd->surface->rasterizer, ector_software_rasterizer_draw_rle_data(pd->surface->rasterizer,
x, y, mul_col, op, x, y, mul_col, op,
pd->outline_data, pd->outline_data,
pd->mask, pd->comp,
pd->mask_op); pd->comp_method);
} }
} }
@ -828,14 +828,14 @@ _ector_renderer_software_shape_ector_renderer_crc_get(const Eo *obj,
} }
static void static void
_ector_renderer_software_shape_ector_renderer_mask_set(Eo *obj EINA_UNUSED, _ector_renderer_software_shape_ector_renderer_comp_method_set(Eo *obj EINA_UNUSED,
Ector_Renderer_Software_Shape_Data *pd, Ector_Renderer_Software_Shape_Data *pd,
Ector_Buffer *mask, Ector_Buffer *comp,
int op) Ector_Renderer_Composite_Method method)
{ {
//Use ref/unref. //Use ref/unref.
pd->mask = mask; pd->comp = comp;
pd->mask_op = op; pd->comp_method = method;
} }
#include "ector_renderer_software_shape.eo.c" #include "ector_renderer_software_shape.eo.c"

2
src/lib/ector/software/ector_renderer_software_shape.eo
View File

@ -6,7 +6,7 @@ class @beta Ector.Renderer.Software.Shape extends Ector.Renderer.Software implem
Ector.Renderer.prepare; Ector.Renderer.prepare;
Ector.Renderer.draw; Ector.Renderer.draw;
Ector.Renderer.Software.op_fill; Ector.Renderer.Software.op_fill;
Ector.Renderer.mask { set; } Ector.Renderer.comp_method { set; }
Ector.Renderer.crc { get; } Ector.Renderer.crc { get; }
Efl.Gfx.Path.commit; Efl.Gfx.Path.commit;
Efl.Object.constructor; Efl.Object.constructor;

8
src/lib/ector/software/ector_software_private.h
View File

@ -83,8 +83,8 @@ typedef struct _Span_Data
int offx, offy; int offx, offy;
Clip_Data clip; Clip_Data clip;
Ector_Software_Buffer_Base_Data *mask; Ector_Software_Buffer_Base_Data *comp;
int mask_op; Ector_Renderer_Composite_Method comp_method;
Eina_Matrix3 inv; Eina_Matrix3 inv;
Span_Data_Type type; Span_Data_Type type;
Eina_Bool fast_matrix; 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, int x, int y, uint32_t mul_col,
Efl_Gfx_Render_Op op, Efl_Gfx_Render_Op op,
Shape_Rle_Data* rle, Shape_Rle_Data* rle,
Ector_Buffer *mask, Ector_Buffer *comp,
int mask_op); Ector_Renderer_Composite_Method comp_method);
void ector_software_rasterizer_destroy_rle_data(Shape_Rle_Data *rle); void ector_software_rasterizer_destroy_rle_data(Shape_Rle_Data *rle);

137
src/lib/ector/software/ector_software_rasterizer.c
View File

@ -11,21 +11,6 @@
#include "draw.h" #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 static void
_blend_argb(int count, const SW_FT_Span *spans, void *user_data) _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 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; Span_Data *sd = user_data;
const int pix_stride = sd->raster_buffer->stride / 4; const int pix_stride = sd->raster_buffer->stride / 4;
Ector_Software_Buffer_Base_Data *mask = sd->mask; Ector_Software_Buffer_Base_Data *comp = sd->comp;
if (!mask || !mask->pixels.u32) return; if (!comp || !comp->pixels.u32) return;
// multiply the color with mul_col if any // multiply the color with mul_col if any
uint32_t color = DRAW_MUL4_SYM(sd->color, sd->mul_col); 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 // move to the offset location
uint32_t *buffer = uint32_t *buffer =
sd->raster_buffer->pixels.u32 + ((pix_stride * sd->offy) + sd->offx); 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 //Temp buffer for intermediate processing
int tsize = sd->raster_buffer->generic->w; 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 *target = buffer + ((pix_stride * spans->y) + spans->x);
uint32_t *mtarget = uint32_t *mtarget =
mbuffer + ((mask->generic->w * spans->y) + spans->x); mbuffer + ((comp->generic->w * spans->y) + spans->x);
uint32_t *temp = tbuffer; uint32_t *temp = tbuffer;
memset(temp, 0x00, sizeof(uint32_t) * spans->len); memset(temp, 0x00, sizeof(uint32_t) * spans->len);
comp_func(temp, spans->len, color, spans->coverage); comp_func(temp, spans->len, color, spans->coverage);
//masking //composite
for (int i = 0; i < spans->len; i++) for (int i = 0; i < spans->len; i++)
{ {
*temp = draw_mul_256(((*mtarget)>>24), *temp); *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 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; Span_Data *sd = user_data;
const int pix_stride = sd->raster_buffer->stride / 4; const int pix_stride = sd->raster_buffer->stride / 4;
Ector_Software_Buffer_Base_Data *mask = sd->mask; Ector_Software_Buffer_Base_Data *comp = sd->comp;
if (!mask || !mask->pixels.u32) return; if (!comp || !comp->pixels.u32) return;
// multiply the color with mul_col if any // multiply the color with mul_col if any
uint32_t color = DRAW_MUL4_SYM(sd->color, sd->mul_col); 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 // move to the offset location
uint32_t *buffer = uint32_t *buffer =
sd->raster_buffer->pixels.u32 + ((pix_stride * sd->offy) + sd->offx); 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 //Temp buffer for intermediate processing
int tsize = sd->raster_buffer->generic->w; 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 *target = buffer + ((pix_stride * spans->y) + spans->x);
uint32_t *mtarget = uint32_t *mtarget =
mbuffer + ((mask->generic->w * spans->y) + spans->x); mbuffer + ((comp->generic->w * spans->y) + spans->x);
uint32_t *temp = tbuffer; uint32_t *temp = tbuffer;
memset(temp, 0x00, sizeof(uint32_t) * spans->len); memset(temp, 0x00, sizeof(uint32_t) * spans->len);
comp_func(temp, spans->len, color, spans->coverage); comp_func(temp, spans->len, color, spans->coverage);
//masking //composite
for (int i = 0; i < spans->len; i++) for (int i = 0; i < spans->len; i++)
{ {
if (*mtarget) if (*mtarget)
@ -138,22 +123,22 @@ _blend_alpha_inv(int count, const SW_FT_Span *spans, void *user_data)
} }
static void 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; Span_Data *sd = user_data;
Ector_Software_Buffer_Base_Data *mask = sd->mask; Ector_Software_Buffer_Base_Data *comp = sd->comp;
if (!mask || !mask->pixels.u32) return; if (!comp || !comp->pixels.u32) return;
uint32_t color = DRAW_MUL4_SYM(sd->color, sd->mul_col); 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); 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; int tsize = sd->raster_buffer->generic->w;
uint32_t *ttarget = alloca(sizeof(uint32_t) * tsize); uint32_t *ttarget = alloca(sizeof(uint32_t) * tsize);
while (count--) 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); memset(ttarget, 0x00, sizeof(uint32_t) * spans->len);
comp_func(ttarget, spans->len, color, spans->coverage); comp_func(ttarget, spans->len, color, spans->coverage);
for (int i = 0; i < spans->len; i++) 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 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; Span_Data *sd = user_data;
Ector_Software_Buffer_Base_Data *mask = sd->mask; Ector_Software_Buffer_Base_Data *comp = sd->comp;
if (!mask || !mask->pixels.u32) return; if (!comp || !comp->pixels.u32) return;
uint32_t color = DRAW_MUL4_SYM(sd->color, sd->mul_col); 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); 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; int tsize = sd->raster_buffer->generic->w;
uint32_t *ttarget = alloca(sizeof(uint32_t) * tsize); uint32_t *ttarget = alloca(sizeof(uint32_t) * tsize);
while (count--) 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); memset(ttarget, 0x00, sizeof(uint32_t) * spans->len);
comp_func(ttarget, spans->len, color, spans->coverage); comp_func(ttarget, spans->len, color, spans->coverage);
for (int i = 0; i < spans->len; i++) 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 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; Span_Data *sd = user_data;
Ector_Software_Buffer_Base_Data *mask = sd->mask; Ector_Software_Buffer_Base_Data *comp = sd->comp;
if (!mask || !mask->pixels.u32) return; if (!comp || !comp->pixels.u32) return;
uint32_t color = DRAW_MUL4_SYM(sd->color, sd->mul_col); 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); 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; int tsize = sd->raster_buffer->generic->w;
uint32_t *ttarget = alloca(sizeof(uint32_t) * tsize); 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) y == (unsigned int)spans->y && count > 0)
{ {
memset(ttarget, 0x00, sizeof(uint32_t) * spans->len); 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); comp_func(ttarget, spans->len, color, spans->coverage);
for (int c = 0; c < spans->len; c++) for (int c = 0; c < spans->len; c++)
mtarget[c] = draw_mul_256(ttarget[c]>>24, mtarget[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 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 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; Span_Data *sd = user_data;
Ector_Software_Buffer_Base_Data *mask = sd->mask; Ector_Software_Buffer_Base_Data *comp = sd->comp;
if (!mask || !mask->pixels.u32) return; if (!comp || !comp->pixels.u32) return;
uint32_t color = DRAW_MUL4_SYM(sd->color, sd->mul_col); 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); 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; int tsize = sd->raster_buffer->generic->w;
uint32_t *ttarget = alloca(sizeof(uint32_t) * tsize); 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--) while (count--)
{ {
memset(ttarget, 0x00, sizeof(uint32_t) * spans->len); 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); comp_func(ttarget, spans->len, color, spans->coverage);
for (int i = 0; i < spans->len; i++) 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]); 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) if (!fetchfunc)
return; return;
Ector_Software_Buffer_Base_Data *mask = data->mask; Ector_Software_Buffer_Base_Data *comp = data->comp;
uint32_t *mbuffer = mask->pixels.u32; uint32_t *mbuffer = comp->pixels.u32;
//Temp buffer for intermediate processing //Temp buffer for intermediate processing
uint32_t *tbuffer = malloc(sizeof(uint32_t) * data->raster_buffer->generic->w); 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--) while (count--)
{ {
uint32_t *target = buffer + ((data->raster_buffer->generic->w * spans->y) + spans->x); 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; uint32_t *temp = tbuffer;
int length = spans->len; int length = spans->len;
memset(temp, 0x00, sizeof(uint32_t) * 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) if (!fetchfunc)
return; return;
Ector_Software_Buffer_Base_Data *mask = data->mask; Ector_Software_Buffer_Base_Data *comp = data->comp;
uint32_t *mbuffer = mask->pixels.u32; uint32_t *mbuffer = comp->pixels.u32;
//Temp buffer for intermediate processing //Temp buffer for intermediate processing
uint32_t *tbuffer = malloc(sizeof(uint32_t) * data->raster_buffer->generic->w); 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--) while (count--)
{ {
uint32_t *target = buffer + ((data->raster_buffer->generic->w * spans->y) + spans->x); 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; uint32_t *temp = tbuffer;
int length = spans->len; int length = spans->len;
memset(temp, 0x00, sizeof(uint32_t) * spans->len); memset(temp, 0x00, sizeof(uint32_t) * spans->len);
@ -599,38 +584,38 @@ static void
_adjust_span_fill_methods(Span_Data *spdata) _adjust_span_fill_methods(Span_Data *spdata)
{ {
//Blending Function //Blending Function
if (spdata->mask) if (spdata->comp)
{ {
switch (spdata->mask_op) switch (spdata->comp_method)
{ {
default: default:
case EFL_CANVAS_VG_NODE_BLEND_TYPE_ALPHA: case ECTOR_RENDERER_COMPOSITE_METHOD_MATTE_ALPHA:
if (spdata->type == Solid) if (spdata->type == Solid)
spdata->unclipped_blend = &_blend_alpha; spdata->unclipped_blend = &_comp_matte_alpha;
else if (spdata->type == LinearGradient || spdata->type == RadialGradient) else if (spdata->type == LinearGradient || spdata->type == RadialGradient)
spdata->unclipped_blend = &_blend_gradient_alpha; spdata->unclipped_blend = &_blend_gradient_alpha;
else //None else //None
spdata->unclipped_blend = NULL; spdata->unclipped_blend = NULL;
break; break;
case EFL_CANVAS_VG_NODE_BLEND_TYPE_ALPHA_INV: case ECTOR_RENDERER_COMPOSITE_METHOD_MATTE_ALPHA_INVERSE:
if (spdata->type == Solid) 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) else if (spdata->type == LinearGradient || spdata->type == RadialGradient)
spdata->unclipped_blend = &_blend_gradient_alpha_inv; spdata->unclipped_blend = &_blend_gradient_alpha_inv;
else //None else //None
spdata->unclipped_blend = NULL; spdata->unclipped_blend = NULL;
break; break;
case EFL_CANVAS_VG_NODE_BLEND_TYPE_MASK_ADD: case ECTOR_RENDERER_COMPOSITE_METHOD_MASK_ADD:
spdata->unclipped_blend = &_blend_mask_add; spdata->unclipped_blend = &_comp_mask_add;
break; break;
case EFL_CANVAS_VG_NODE_BLEND_TYPE_MASK_SUBSTRACT: case ECTOR_RENDERER_COMPOSITE_METHOD_MASK_SUBSTRACT:
spdata->unclipped_blend = &_blend_mask_sub; spdata->unclipped_blend = &_comp_mask_sub;
break; break;
case EFL_CANVAS_VG_NODE_BLEND_TYPE_MASK_INTERSECT: case ECTOR_RENDERER_COMPOSITE_METHOD_MASK_INTERSECT:
spdata->unclipped_blend = &_blend_mask_ins; spdata->unclipped_blend = &_comp_mask_ins;
break; break;
case EFL_CANVAS_VG_NODE_BLEND_TYPE_MASK_DIFFERENCE: case ECTOR_RENDERER_COMPOSITE_METHOD_MASK_DIFFERENCE:
spdata->unclipped_blend = &_blend_mask_diff; spdata->unclipped_blend = &_comp_mask_diff;
break; break;
} }
} }
@ -910,8 +895,8 @@ void
ector_software_rasterizer_draw_rle_data(Software_Rasterizer *rasterizer, ector_software_rasterizer_draw_rle_data(Software_Rasterizer *rasterizer,
int x, int y, uint32_t mul_col, int x, int y, uint32_t mul_col,
Efl_Gfx_Render_Op op, Shape_Rle_Data* rle, Efl_Gfx_Render_Op op, Shape_Rle_Data* rle,
Ector_Buffer *mask, Ector_Buffer *comp,
int mask_op) Ector_Renderer_Composite_Method comp_method)
{ {
if (!rle) return; if (!rle) return;
if (!rasterizer->fill_data.raster_buffer->pixels.u32) 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.offy = y;
rasterizer->fill_data.mul_col = mul_col; rasterizer->fill_data.mul_col = mul_col;
rasterizer->fill_data.op = op; rasterizer->fill_data.op = op;
rasterizer->fill_data.mask = rasterizer->fill_data.comp =
mask ? efl_data_scope_get(mask, ECTOR_SOFTWARE_BUFFER_BASE_MIXIN) : NULL; comp ? efl_data_scope_get(comp, ECTOR_SOFTWARE_BUFFER_BASE_MIXIN) : NULL;
rasterizer->fill_data.mask_op = mask_op; rasterizer->fill_data.comp_method = comp_method;
_setup_span_fill_matrix(rasterizer); _setup_span_fill_matrix(rasterizer);
_adjust_span_fill_methods(&rasterizer->fill_data); _adjust_span_fill_methods(&rasterizer->fill_data);

2
src/lib/evas/Evas.h
View File

@ -172,6 +172,8 @@
/* This include has been added to support Eo in Evas */ /* This include has been added to support Eo in Evas */
#include <Efl.h> #include <Efl.h>
#include <Ector.h>
#include <Evas_Loader.h> #include <Evas_Loader.h>
#ifdef EAPI #ifdef EAPI

192
src/lib/evas/canvas/efl_canvas_vg_container.c
View File

@ -5,23 +5,6 @@
#define MY_CLASS EFL_CANVAS_VG_CONTAINER_CLASS #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 static void
_invalidate_cb(void *data EINA_UNUSED, const Efl_Event *event) _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 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, Ector_Surface *ector, void *engine, void *output,
void *context) void *context)
{ {
@ -51,11 +34,11 @@ _draw_mask(Evas_Object_Protected_Data *obj, Efl_VG *node,
Efl_Canvas_Vg_Container_Data *cd = Efl_Canvas_Vg_Container_Data *cd =
efl_data_scope_get(node, EFL_CANVAS_VG_CONTAINER_CLASS); efl_data_scope_get(node, EFL_CANVAS_VG_CONTAINER_CLASS);
//Draw Mask Image. //Draw Composite Image.
Efl_VG *child; Efl_VG *child;
Eina_List *l; Eina_List *l;
EINA_LIST_FOREACH(cd->children, l, child) EINA_LIST_FOREACH(cd->children, l, child)
_draw_mask(obj, child, ector, engine, output, context); _draw_comp(obj, child, ector, engine, output, context);
} }
else else
{ {
@ -65,93 +48,94 @@ _draw_mask(Evas_Object_Protected_Data *obj, Efl_VG *node,
} }
static Ector_Buffer * static Ector_Buffer *
_prepare_mask(Evas_Object_Protected_Data *obj, //vector object _prepare_comp(Evas_Object_Protected_Data *obj, //vector object
Efl_Canvas_Vg_Node* mask_obj, Efl_Canvas_Vg_Node* comp_target,
void *engine, void *output, void *context, void *engine, void *output, void *context,
Ector_Surface *surface, Ector_Surface *surface,
Eina_Matrix3 *ptransform, Eina_Matrix3 *ptransform,
Eina_Matrix3 *ctransform, Eina_Matrix3 *ctransform,
Ector_Buffer *mask, Ector_Buffer *comp,
int mask_op) 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_Canvas_Vg_Node_Data *nd =
efl_data_scope_get(mask_obj, EFL_CANVAS_VG_NODE_CLASS); efl_data_scope_get(comp_target, EFL_CANVAS_VG_NODE_CLASS);
if (nd->flags == EFL_GFX_CHANGE_FLAG_NONE) return pd->mask.buffer; if (nd->flags == EFL_GFX_CHANGE_FLAG_NONE) return pd->comp.buffer;
uint32_t init_buffer = 0x0; uint32_t init_buffer = 0x0;
//1. Mask Size //1. Composite Size
Eina_Rect mbound; Eina_Rect mbound;
mbound.x = 0; mbound.x = 0;
mbound.y = 0; mbound.y = 0;
mbound.w = obj->cur->geometry.w; mbound.w = obj->cur->geometry.w;
mbound.h = obj->cur->geometry.h; mbound.h = obj->cur->geometry.h;
//FIXME: If mask typs is SUBSTRACT or INTERSECT, buffer fills in white color(Full alpha color). //FIXME: If composite method 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) if (pd->comp.method == ECTOR_RENDERER_COMPOSITE_METHOD_MASK_SUBSTRACT ||
pd->comp.method == ECTOR_RENDERER_COMPOSITE_METHOD_MASK_INTERSECT)
init_buffer = 0xFFFFFFFF; init_buffer = 0xFFFFFFFF;
//2. Reusable ector buffer? //2. Reusable ector buffer?
if (!pd->mask.buffer || (pd->mask.bound.w != mbound.w) || if (!pd->comp.buffer || (pd->comp.bound.w != mbound.w) ||
(pd->mask.bound.h != mbound.h)) (pd->comp.bound.h != mbound.h))
{ {
if (pd->mask.pixels) free(pd->mask.pixels); if (pd->comp.pixels) free(pd->comp.pixels);
if (pd->mask.buffer) efl_unref(pd->mask.buffer); if (pd->comp.buffer) efl_unref(pd->comp.buffer);
pd->mask.pixels = malloc(sizeof(uint32_t) * (mbound.w * mbound.h)); pd->comp.pixels = malloc(sizeof(uint32_t) * (mbound.w * mbound.h));
memset(pd->mask.pixels, init_buffer, sizeof(uint32_t) * (mbound.w * mbound.h)); memset(pd->comp.pixels, init_buffer, sizeof(uint32_t) * (mbound.w * mbound.h));
pd->mask.buffer = ENFN->ector_buffer_new(ENC, obj->layer->evas->evas, pd->comp.buffer = ENFN->ector_buffer_new(ENC, obj->layer->evas->evas,
mbound.w, mbound.h, mbound.w, mbound.h,
EFL_GFX_COLORSPACE_ARGB8888, EFL_GFX_COLORSPACE_ARGB8888,
ECTOR_BUFFER_FLAG_DRAWABLE | ECTOR_BUFFER_FLAG_DRAWABLE |
ECTOR_BUFFER_FLAG_CPU_READABLE | ECTOR_BUFFER_FLAG_CPU_READABLE |
ECTOR_BUFFER_FLAG_CPU_WRITABLE); 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, mbound.w, mbound.h, 0,
EFL_GFX_COLORSPACE_ARGB8888, EINA_TRUE); EFL_GFX_COLORSPACE_ARGB8888, EINA_TRUE);
pd->mask.bound.w = mbound.w; pd->comp.bound.w = mbound.w;
pd->mask.bound.h = mbound.h; pd->comp.bound.h = mbound.h;
pd->mask.vg_pd = obj; pd->comp.vg_pd = obj;
} }
else else
{ {
if (pd->mask.pixels) if (pd->comp.pixels)
memset(pd->mask.pixels, init_buffer, sizeof(uint32_t) * mbound.w * mbound.h); memset(pd->comp.pixels, init_buffer, sizeof(uint32_t) * mbound.w * mbound.h);
} }
pd->mask.bound.x = mbound.x; pd->comp.bound.x = mbound.x;
pd->mask.bound.y = mbound.y; 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. //FIXME: This code means that there is another composite container.
if (pd->mask.option >= EFL_CANVAS_VG_NODE_BLEND_TYPE_MASK_ADD) if (pd->comp.method >= ECTOR_RENDERER_COMPOSITE_METHOD_MASK_ADD)
{ {
Efl_Canvas_Vg_Container_Data *src_pd = pd; Efl_Canvas_Vg_Container_Data *target_pd = pd;
mask = pd->mask.buffer; comp = pd->comp.buffer;
for (Efl_VG *mask_src = pd->mask_src; mask_src; mask_src = src_pd->mask_src) for (Efl_VG *comp_target = pd->comp_target; comp_target; comp_target = target_pd->comp_target)
{ {
Efl_Canvas_Vg_Container_Data *target_pd = NULL; Efl_Canvas_Vg_Container_Data *src_pd = NULL;
src_pd = efl_data_scope_get(mask_src, MY_CLASS); target_pd = efl_data_scope_get(comp_target, MY_CLASS);
target_pd = efl_data_scope_get(eina_list_nth(src_pd->mask.target, 0), MY_CLASS); src_pd = efl_data_scope_get(eina_list_nth(target_pd->comp.src, 0), MY_CLASS);
_evas_vg_render_pre(obj, mask_src, _evas_vg_render_pre(obj, comp_target,
engine, output, context, surface, engine, output, context, surface,
ctransform, mask, target_pd->mask.option); ctransform, comp, src_pd->comp.method);
} }
} }
//3. Prepare Drawing shapes. //3. Prepare Drawing shapes.
_evas_vg_render_pre(obj, mask_obj, _evas_vg_render_pre(obj, comp_target,
engine, output, context, engine, output, context,
surface, surface,
ptransform, mask, mask_op); ptransform, comp, comp_method);
//4. Generating Mask Image. //4. Generating Composite Image.
ector_buffer_pixels_set(surface, pd->mask.pixels, mbound.w, mbound.h, 0, ector_buffer_pixels_set(surface, pd->comp.pixels, mbound.w, mbound.h, 0,
EFL_GFX_COLORSPACE_ARGB8888, EINA_TRUE); EFL_GFX_COLORSPACE_ARGB8888, EINA_TRUE);
ector_surface_reference_point_set(surface, -mbound.x, -mbound.y); 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 static void
@ -161,8 +145,8 @@ _efl_canvas_vg_container_render_pre(Evas_Object_Protected_Data *vg_pd,
void *engine, void *output, void *context, void *engine, void *output, void *context,
Ector_Surface *surface, Ector_Surface *surface,
Eina_Matrix3 *ptransform, Eina_Matrix3 *ptransform,
Ector_Buffer *mask, Ector_Buffer *comp,
int mask_op, Ector_Renderer_Composite_Method comp_method,
void *data) void *data)
{ {
Efl_Canvas_Vg_Container_Data *pd = 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); EFL_CANVAS_VG_COMPUTE_MATRIX(ctransform, ptransform, nd);
//Container may have mask source. //Container may have composite target.
//FIXME : _prepare_mask() should only work in cases with matte or main mask. //FIXME : _prepare_comp() should only work in cases with matte or masking.
// This condition is valid because the main mask use same type as matte alpha. // This condition is valid because the masking use same type as matte.
if (pd->mask_src && if (pd->comp_target &&
(pd->mask.option == EFL_CANVAS_VG_NODE_BLEND_TYPE_ALPHA || (pd->comp.method == ECTOR_RENDERER_COMPOSITE_METHOD_MATTE_ALPHA ||
pd->mask.option == EFL_CANVAS_VG_NODE_BLEND_TYPE_ALPHA_INV)) pd->comp.method == ECTOR_RENDERER_COMPOSITE_METHOD_MATTE_ALPHA_INVERSE))
{ {
mask_op = pd->mask.option; comp_method = pd->comp.method;
mask = _prepare_mask(vg_pd, pd->mask_src, comp = _prepare_comp(vg_pd, pd->comp_target,
engine, output, context, surface, engine, output, context, surface,
ptransform, ctransform, mask, mask_op); ptransform, ctransform, comp, comp_method);
} }
EINA_LIST_FOREACH(pd->children, l, child) 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)) if (efl_isa(child, MY_CLASS))
{ {
Efl_Canvas_Vg_Container_Data *child_cd = Efl_Canvas_Vg_Container_Data *child_cd =
efl_data_scope_get(child, MY_CLASS); 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. //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, _evas_vg_render_pre(vg_pd, child,
engine, output, context, surface, 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_pixels) free(pd->blend_pixels);
if (pd->blend_buffer) efl_unref(pd->blend_buffer); if (pd->blend_buffer) efl_unref(pd->blend_buffer);
//Destroy mask surface //Destroy comp surface
if (pd->mask.buffer) efl_unref(pd->mask.buffer); if (pd->comp.buffer) efl_unref(pd->comp.buffer);
if (pd->mask.pixels) free(pd->mask.pixels); if (pd->comp.pixels) free(pd->comp.pixels);
efl_unref(pd->mask_src); efl_unref(pd->comp_target);
eina_list_free(pd->mask.target); eina_list_free(pd->comp.src);
eina_hash_free(pd->names); eina_hash_free(pd->names);
efl_destructor(efl_super(obj, MY_CLASS)); 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; 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 *fromd = efl_data_scope_get(from, MY_CLASS);
Efl_Canvas_Vg_Container_Data *tod = efl_data_scope_get(to, 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, if (!efl_gfx_path_interpolate(pd->comp_target,
fromd->mask_src, tod->mask_src, pos_map)) fromd->comp_target, tod->comp_target, pos_map))
return EINA_FALSE; return EINA_FALSE;
} }
@ -351,30 +335,30 @@ _efl_canvas_vg_container_efl_gfx_path_interpolate(Eo *obj, Efl_Canvas_Vg_Contain
} }
static void static void
_efl_canvas_vg_container_efl_canvas_vg_node_mask_set(Eo *obj, _efl_canvas_vg_container_efl_canvas_vg_node_comp_method_set(Eo *obj,
Efl_Canvas_Vg_Container_Data *pd, Efl_Canvas_Vg_Container_Data *pd,
Efl_Canvas_Vg_Node *mask, Efl_Canvas_Vg_Node *target,
int op) 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_Canvas_Vg_Container_Data *pd2 =
efl_data_scope_get(pd->mask_src, MY_CLASS); efl_data_scope_get(pd->comp_target, MY_CLASS);
pd2->mask.target = eina_list_remove(pd2->mask.target, obj); 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); Efl_Canvas_Vg_Container_Data *pd2 = efl_data_scope_get(target, MY_CLASS);
pd2->mask.target = eina_list_append(pd2->mask.target, obj); pd2->comp.src = eina_list_append(pd2->comp.src, obj);
} }
pd->mask.option = op; pd->comp.method = method;
efl_replace(&pd->mask_src, mask); efl_replace(&pd->comp_target, target);
efl_canvas_vg_node_change(obj); 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)); container = efl_duplicate(efl_super(obj, MY_CLASS));
efl_event_callback_add(container, EFL_EVENT_INVALIDATE, _invalidate_cb, NULL); efl_event_callback_add(container, EFL_EVENT_INVALIDATE, _invalidate_cb, NULL);
//Copy Mask //Copy Composite
if (pd->mask_src) if (pd->comp_target)
{ {
Eo * mask_src = efl_duplicate(pd->mask_src); Eo * comp_target = efl_duplicate(pd->comp_target);
efl_parent_set(mask_src, container); efl_parent_set(comp_target, container);
efl_canvas_vg_node_mask_set(container, mask_src, pd->mask.option); efl_canvas_vg_node_comp_method_set(container, comp_target, pd->comp.method);
} }
//Copy Children //Copy Children

2
src/lib/evas/canvas/efl_canvas_vg_container.eo
View File

@ -21,6 +21,6 @@ class @beta Efl.Canvas.Vg.Container extends Efl.Canvas.Vg.Node
Efl.Gfx.Path.bounds_get; Efl.Gfx.Path.bounds_get;
Efl.Gfx.Path.interpolate; Efl.Gfx.Path.interpolate;
Efl.Duplicate.duplicate; Efl.Duplicate.duplicate;
Efl.Canvas.Vg.Node.mask { set; } Efl.Canvas.Vg.Node.comp_method { set; }
} }
} }

6
src/lib/evas/canvas/efl_canvas_vg_gradient_linear.c
View File

@ -64,8 +64,8 @@ _efl_canvas_vg_gradient_linear_render_pre(Evas_Object_Protected_Data *vg_pd EINA
void *context EINA_UNUSED, void *context EINA_UNUSED,
Ector_Surface *surface, Ector_Surface *surface,
Eina_Matrix3 *ptransform, Eina_Matrix3 *ptransform,
Ector_Buffer *mask, Ector_Buffer *comp,
int mask_op, Ector_Renderer_Composite_Method comp_method,
void *data) void *data)
{ {
Efl_Canvas_Vg_Gradient_Linear_Data *pd = 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_start_set(nd->renderer, pd->start.x, pd->start.y);
efl_gfx_gradient_linear_end_set(nd->renderer, pd->end.x, pd->end.y); efl_gfx_gradient_linear_end_set(nd->renderer, pd->end.x, pd->end.y);
ector_renderer_prepare(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 * static Eo *

6
src/lib/evas/canvas/efl_canvas_vg_gradient_radial.c
View File

@ -80,8 +80,8 @@ _efl_canvas_vg_gradient_radial_render_pre(Evas_Object_Protected_Data *vg_pd EINA
void *context EINA_UNUSED, void *context EINA_UNUSED,
Ector_Surface *surface, Ector_Surface *surface,
Eina_Matrix3 *ptransform, Eina_Matrix3 *ptransform,
Ector_Buffer *mask, Ector_Buffer *comp,
int mask_op, Ector_Renderer_Composite_Method comp_method,
void *data) void *data)
{ {
Efl_Canvas_Vg_Gradient_Radial_Data *pd = 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_focal_set(nd->renderer, pd->focal.x, pd->focal.y);
efl_gfx_gradient_radial_radius_set(nd->renderer, pd->radius); efl_gfx_gradient_radial_radius_set(nd->renderer, pd->radius);
ector_renderer_prepare(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 * static Eo *

6
src/lib/evas/canvas/efl_canvas_vg_image.c
View File

@ -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, void *engine EINA_UNUSED, void *output EINA_UNUSED, void *context EINA_UNUSED,
Ector_Surface *surface, Ector_Surface *surface,
Eina_Matrix3 *ptransform, Eina_Matrix3 *ptransform,
Ector_Buffer *mask, Ector_Buffer *comp,
int mask_op, Ector_Renderer_Composite_Method comp_method,
void *data) void *data)
{ {
Efl_Canvas_Vg_Image_Data *pd = 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_color_set(nd->renderer, nd->r, nd->g, nd->b, nd->a);
ector_renderer_visibility_set(nd->renderer, nd->visibility); 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); ector_renderer_prepare(nd->renderer);
} }

8
src/lib/evas/canvas/efl_canvas_vg_node.c
View File

@ -73,10 +73,10 @@ _efl_canvas_vg_node_transformation_get(const Eo *obj EINA_UNUSED, Efl_Canvas_Vg_
} }
static void static void
_efl_canvas_vg_node_mask_set(Eo *obj 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_Data *pd EINA_UNUSED,
Efl_Canvas_Vg_Node *mask EINA_UNUSED, Efl_Canvas_Vg_Node *target EINA_UNUSED,
int op EINA_UNUSED) Ector_Renderer_Composite_Method method EINA_UNUSED)
{ {
} }

9
src/lib/evas/canvas/efl_canvas_vg_node.eo
View File

@ -1,4 +1,5 @@
import eina_types; 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 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.]] y: double; [[$origin y position.]]
} }
} }
@property mask { @property comp_method {
[[Set Mask Node to this renderer]] [[Set a composite target node to this node object.]]
set { set {
} }
values { values {
mask: Efl.Canvas.Vg.Node; [[Mask object]] target: Efl.Canvas.Vg.Node; [[Composite target node]]
op: int; [[Masking Option. Reserved]] method: Ector.Renderer.Composite_Method; [[Composite Method.]]
} }
} }
} }

4
src/lib/evas/canvas/efl_canvas_vg_node_eo.legacy.c
View File

@ -24,7 +24,7 @@ evas_vg_node_origin_get(const Efl_Canvas_Vg_Node *obj, double *x, double *y)
} }
EAPI void 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);
} }

4
src/lib/evas/canvas/efl_canvas_vg_object.c
View File

@ -396,7 +396,7 @@ _evas_vg_render(Evas_Object_Protected_Data *obj, Efl_Canvas_Vg_Object_Data *pd,
Eina_List *l; Eina_List *l;
Efl_Canvas_Vg_Container_Data *cd = efl_data_scope_get(node, EFL_CANVAS_VG_CONTAINER_CLASS); 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; int alpha = 255;
efl_gfx_color_get(node, NULL, NULL, NULL, &alpha); 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_render_op(context, _EVAS_RENDER_COPY);
evas_common_draw_context_set_color(context, 255, 255, 255, 255); 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); //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); _evas_vg_render_pre(obj, root, engine, buffer, context, ector, NULL, NULL, 0);
//ENFN->ector_end(engine, buffer, context, ector, EINA_FALSE); //ENFN->ector_end(engine, buffer, context, ector, EINA_FALSE);

12
src/lib/evas/canvas/efl_canvas_vg_shape.c
View File

@ -78,8 +78,8 @@ _efl_canvas_vg_shape_render_pre(Evas_Object_Protected_Data *vg_pd,
void *engine, void *output, void *context, void *engine, void *output, void *context,
Ector_Surface *surface, Ector_Surface *surface,
Eina_Matrix3 *ptransform, Eina_Matrix3 *ptransform,
Ector_Buffer *mask, Ector_Buffer *comp,
int mask_op, Ector_Renderer_Composite_Method comp_method,
void *data) void *data)
{ {
Efl_Canvas_Vg_Shape_Data *pd = 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, fill = _evas_vg_render_pre(vg_pd, pd->fill,
engine, output, context, engine, output, context,
surface, ctransform, mask, mask_op); surface, ctransform, comp, comp_method);
stroke_fill = _evas_vg_render_pre(vg_pd, pd->stroke.fill, stroke_fill = _evas_vg_render_pre(vg_pd, pd->stroke.fill,
engine, output, context, engine, output, context,
surface, ctransform, mask, mask_op); surface, ctransform, comp, comp_method);
stroke_marker = _evas_vg_render_pre(vg_pd, pd->stroke.marker, stroke_marker = _evas_vg_render_pre(vg_pd, pd->stroke.marker,
engine, output, context, engine, output, context,
surface, ctransform, mask, mask_op); surface, ctransform, comp, comp_method);
if (!nd->renderer) 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_copy_from(nd->renderer, obj);
efl_gfx_path_commit(nd->renderer); efl_gfx_path_commit(nd->renderer);
ector_renderer_prepare(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 * static Eo *

28
src/lib/evas/canvas/evas_vg_private.h
View File

@ -67,7 +67,7 @@ struct _Efl_Canvas_Vg_Node_Data
void (*render_pre)(Evas_Object_Protected_Data *vg_pd, Efl_VG *node, void (*render_pre)(Evas_Object_Protected_Data *vg_pd, Efl_VG *node,
Efl_Canvas_Vg_Node_Data *nd, Efl_Canvas_Vg_Node_Data *nd,
void *engine, void *output, void *contenxt, Ector_Surface *surface, 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; void *data;
double x, y; double x, y;
@ -78,24 +78,24 @@ struct _Efl_Canvas_Vg_Node_Data
Eina_Bool changed : 1; Eina_Bool changed : 1;
}; };
typedef struct _Vg_Mask typedef struct _Vg_Composite
{ {
Evas_Object_Protected_Data *vg_pd; //Vector Object (for accessing backend engine) Evas_Object_Protected_Data *vg_pd; //Vector Object (for accessing backend engine)
Ector_Buffer *buffer; //Mask Ector Buffer Ector_Buffer *buffer; //Composite Ector Buffer
void *pixels; //Mask pixel buffer (actual data) void *pixels; //Composite pixel buffer (actual data)
Eina_Rect bound; //Mask boundary Eina_Rect bound; //Composite boundary
Eina_List *target; //Mask target Eina_List *src; //Composite Sources
int option; //Mask option Ector_Renderer_Composite_Method method; //Composite Method
} Vg_Mask; } Vg_Comp;
struct _Efl_Canvas_Vg_Container_Data struct _Efl_Canvas_Vg_Container_Data
{ {
Eina_List *children; Eina_List *children;
Eina_Hash *names; Eina_Hash *names;
//Masking feature. //Composite feature.
Efl_Canvas_Vg_Node *mask_src; //Mask Source Efl_Canvas_Vg_Node *comp_target; //Composite target
Vg_Mask mask; //Mask source data Vg_Comp comp; //Composite target data
//Layer transparency feature. This buffer is only valid when the layer has transparency. //Layer transparency feature. This buffer is only valid when the layer has transparency.
Ector_Buffer *blend_buffer; 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, void *engine, void *output, void *context,
Ector_Surface *surface, Ector_Surface *surface,
Eina_Matrix3 *transform, Eina_Matrix3 *transform,
Ector_Buffer *mask, int mask_op) Ector_Buffer *comp, Ector_Renderer_Composite_Method comp_method)
{ {
if (!child) return NULL; if (!child) return NULL;
Efl_Canvas_Vg_Node_Data *nd = efl_data_scope_get(child, EFL_CANVAS_VG_NODE_CLASS); 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, if (nd) nd->render_pre(vg_pd, child, nd,
engine, output, context, surface, engine, output, context, surface,
transform, mask, mask_op, nd->data); transform, comp, comp_method, nd->data);
return nd; return nd;
} }

39
src/static_libs/vg_common/vg_common_json.c
View File

@ -9,21 +9,6 @@
#include <rlottie_capi.h> #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* static char*
_get_key_val(void *key) _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); efl_key_data_set(mtarget, key, msource);
} }
//FIXME : EFL_CANVAS_VG_NODE_BLEND_TYPE_ALPHA option is temporary //FIXME : ECTOR_RENDERER_COMPOSITE_METHOD_ALPHA option is temporary
//Currently matte alpha implemtnes is same the mask intersect impletment. //Currently matte alpha implements is same the mask intersect implement.
//It has been implemented as a multiplication calculation. //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; mtarget = msource;
@ -330,24 +315,24 @@ _construct_masks(Efl_Canvas_Vg_Container *mtarget, LOTMask *masks, unsigned int
} }
_construct_mask_nodes(msource, mask, depth + 1); _construct_mask_nodes(msource, mask, depth + 1);
EFL_CANVAS_VG_NODE_BLEND_TYPE mask_mode; Ector_Renderer_Composite_Method mask_mode;
switch (mask->mMode) switch (mask->mMode)
{ {
case MaskSubstract: case MaskSubstract:
mask_mode = EFL_CANVAS_VG_NODE_BLEND_TYPE_MASK_SUBSTRACT; mask_mode = ECTOR_RENDERER_COMPOSITE_METHOD_MASK_SUBSTRACT;
break; break;
case MaskIntersect: case MaskIntersect:
mask_mode = EFL_CANVAS_VG_NODE_BLEND_TYPE_MASK_INTERSECT; mask_mode = ECTOR_RENDERER_COMPOSITE_METHOD_MASK_INTERSECT;
break; break;
case MaskDifference: case MaskDifference:
mask_mode = EFL_CANVAS_VG_NODE_BLEND_TYPE_MASK_DIFFERENCE; mask_mode = ECTOR_RENDERER_COMPOSITE_METHOD_MASK_DIFFERENCE;
break; break;
case MaskAdd: case MaskAdd:
default: default:
mask_mode = EFL_CANVAS_VG_NODE_BLEND_TYPE_MASK_ADD; mask_mode = ECTOR_RENDERER_COMPOSITE_METHOD_MASK_ADD;
break; break;
} }
efl_canvas_vg_node_mask_set(mtarget, msource, mask_mode); efl_canvas_vg_node_comp_method_set(mtarget, msource, mask_mode);
mtarget = msource; mtarget = msource;
} }
} }
@ -395,7 +380,7 @@ _update_vg_tree(Efl_Canvas_Vg_Container *root, const LOTLayerNode *layer, int de
if (matte_mode != 0) 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; mtarget = ctree;
} }
matte_mode = (int) clayer->mMatte; 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; matte_mode = 0;
break; break;
case MatteAlpha: case MatteAlpha:
matte_mode = EFL_CANVAS_VG_NODE_BLEND_TYPE_ALPHA; matte_mode = ECTOR_RENDERER_COMPOSITE_METHOD_MATTE_ALPHA;
break; break;
case MatteAlphaInv: case MatteAlphaInv:
matte_mode = EFL_CANVAS_VG_NODE_BLEND_TYPE_ALPHA_INV; matte_mode = ECTOR_RENDERER_COMPOSITE_METHOD_MATTE_ALPHA_INVERSE;
break; break;
case MatteLuma: case MatteLuma:
matte_mode = 0; matte_mode = 0;