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

Revert "ector: code refactoring." 

This reverts commit dad166f84a.

Ector is not public, this breaks enlightenment compilation,
This commit is contained in:
Hermet Park 2019-08-20 20:24:27 +09:00
parent dad166f84a
commit b0737c7434
24 changed files with 293 additions and 265 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -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.

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

@ -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)
{
}

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

@ -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 {

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

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

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

@ -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
}

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_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"

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 {
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;

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 *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"

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.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;

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

@ -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);

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

@ -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);

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

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

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

@ -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

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.interpolate;
Efl.Duplicate.duplicate;
Efl.Canvas.Vg.Node.comp_method { set; }
Efl.Canvas.Vg.Node.mask { 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,
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 *

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,
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 *

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,
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);
}

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
_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)
{
}

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

@ -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]]
}
}
}

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
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);
}

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;
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);

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,
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 *

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,
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;
}

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

@ -9,6 +9,21 @@
#include <rlottie_capi.h>
//FIXME: This enum add temporarily to help understanding of additional code
//related to masking in prepare_mask.
//This needs to be formally declared through the eo class.
typedef enum _EFL_CANVAS_VG_NODE_BLEND_TYPE
{
EFL_CANVAS_VG_NODE_BLEND_TYPE_NONE = 0,
EFL_CANVAS_VG_NODE_BLEND_TYPE_ALPHA,
EFL_CANVAS_VG_NODE_BLEND_TYPE_ALPHA_INV,
EFL_CANVAS_VG_NODE_BLEND_TYPE_MASK_ADD,
EFL_CANVAS_VG_NODE_BLEND_TYPE_MASK_SUBSTRACT,
EFL_CANVAS_VG_NODE_BLEND_TYPE_MASK_INTERSECT,
EFL_CANVAS_VG_NODE_BLEND_TYPE_MASK_DIFFERENCE
}EFL_CANVAS_VG_NODE_BLEND_TYPE;
//
static char*
_get_key_val(void *key)
{
@ -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;