{
int width;
int height;
+ int stride;
DATA32 *buffer;
} Raster_Buffer;
comp_func = ector_comp_func_solid_span_get(data->op, color);
// move to the offset location
- buffer = data->raster_buffer.buffer + ((data->raster_buffer.width * data->offy) + data->offx);
+ buffer = data->raster_buffer.buffer + ((data->raster_buffer.stride / 4) * data->offy + data->offx);
while (count--)
{
- target = buffer + ((data->raster_buffer.width * spans->y) + spans->x);
+ target = buffer + ((data->raster_buffer.stride / 4) * spans->y + spans->x);
comp_func(target, spans->len, color, spans->coverage);
++spans;
}
comp_func = ector_comp_func_span_get(data->op, data->mul_col, data->gradient->alpha);
// move to the offset location
- destbuffer = data->raster_buffer.buffer + ((data->raster_buffer.width * data->offy) + data->offx);
+ destbuffer = data->raster_buffer.buffer + ((data->raster_buffer.stride / 4) * data->offy + data->offx);
while (count--)
{
- target = destbuffer + ((data->raster_buffer.width * spans->y) + spans->x);
+ target = destbuffer + ((data->raster_buffer.stride / 4) * spans->y + spans->x);
length = spans->len;
while (length)
{
void
_ector_software_surface_surface_set(Eo *obj EINA_UNUSED,
Ector_Software_Surface_Data *pd,
- void *pixels, unsigned int width, unsigned int height)
+ void *pixels, unsigned int width,
+ unsigned int height, unsigned int stride)
{
pd->software->fill_data.raster_buffer.buffer = pixels;
pd->software->fill_data.raster_buffer.width = width;
pd->software->fill_data.raster_buffer.height = height;
+ pd->software->fill_data.raster_buffer.stride = stride;
}
void
_ector_software_surface_surface_get(Eo *obj EINA_UNUSED,
Ector_Software_Surface_Data *pd,
- void **pixels, unsigned int *width, unsigned int *height)
+ void **pixels, unsigned int *width,
+ unsigned int *height, unsigned int *stride)
{
- *pixels = pd->software->fill_data.raster_buffer.buffer;
- *width = pd->software->fill_data.raster_buffer.width;
- *height = pd->software->fill_data.raster_buffer.height;
+ if (pixels)
+ *pixels = pd->software->fill_data.raster_buffer.buffer;
+ if (width)
+ *width = pd->software->fill_data.raster_buffer.width;
+ if (height)
+ *height = pd->software->fill_data.raster_buffer.height;
+ if (stride)
+ *stride = pd->software->fill_data.raster_buffer.stride;
}
static Eo *
methods {
@property context {
set {
- }
- get {
- }
- values {
- ctx: Software_Rasterizer *;
- }
+ }
+ get {
+ }
+ values {
+ ctx: Software_Rasterizer *;
+ }
}
@property surface {
set {
- }
- get {
- }
- values {
- pixels: void *;
- width: uint;
- height: uint;
- }
+ }
+ get {
+ }
+ values {
+ pixels: void *;
+ width: uint;
+ height: uint;
+ stride: uint;
+ }
}
}
Eo.Base.constructor;
}
}
+
_evas_vg_render(obj, vd, output, context, vd->backing_store, vd->root, NULL,do_async);
obj->layer->evas->engine.func->image_dirty_region(obj->layer->evas->engine.data.output, vd->backing_store,
0, 0, 0, 0);
- obj->layer->evas->engine.func->ector_end(output, context, ector, surface, do_async);
+ obj->layer->evas->engine.func->ector_end(output, context, ector, vd->backing_store, do_async);
}
obj->layer->evas->engine.func->image_draw(output, context, surface,
vd->backing_store, 0, 0,
void evas_gl_common_line_draw(Evas_Engine_GL_Context *gc, int x1, int y1, int x2, int y2);
+void evas_gl_common_texture_shared_specific(Evas_Engine_GL_Context *gc, Evas_GL_Texture_Pool *pt, int i);
+void evas_gl_common_texture_shared_back(Evas_Engine_GL_Context *gc, Evas_GL_Texture_Pool *pt);
+
+
extern void (*glsym_glGenFramebuffers) (GLsizei a, GLuint *b);
extern void (*glsym_glBindFramebuffer) (GLenum a, GLuint b);
extern void (*glsym_glFramebufferTexture2D) (GLenum a, GLenum b, GLenum c, GLuint d, GLint e);
if (gc->state.current.prog != PRG_INVALID)
glUseProgram(gc->state.current.prog->prog);
- glActiveTexture(GL_TEXTURE0);
- glBindTexture(gc->pipe[0].shader.tex_target, gc->pipe[0].shader.cur_tex);
+ evas_gl_common_texture_shared_back(gc, NULL);
_evas_gl_common_viewport_set(gc,1);
}
}
#endif
glActiveTexture(GL_TEXTURE0);
- glBindTexture(gc->pipe[i].shader.tex_target, gc->pipe[i].shader.cur_tex);
+ evas_gl_common_texture_shared_specific(gc, NULL, i);
}
if (gc->pipe[i].array.im)
{
return -1;
}
+void
+evas_gl_common_texture_shared_specific(Evas_Engine_GL_Context *gc, Evas_GL_Texture_Pool *pt, int i)
+{
+ if (!pt || pt->texture != gc->pipe[i].shader.cur_tex)
+ {
+ if (gc->pipe[i].array.im)
+ {
+ if (gc->pipe[i].array.im->tex->pt->dyn.img)
+ gc->pipe[i].shader.tex_target = gc->pipe[i].array.im->tex->pt->dyn.target;
+ else
+ gc->pipe[i].shader.tex_target = gc->pipe[i].array.im->native.target;
+ }
+ else
+ gc->pipe[i].shader.tex_target = GL_TEXTURE_2D;
+
+ glBindTexture(gc->pipe[i].shader.tex_target, gc->pipe[i].shader.cur_tex);
+ GLERR(__FUNCTION__, __FILE__, __LINE__, "");
+ }
+}
+
+void
+evas_gl_common_texture_shared_back(Evas_Engine_GL_Context *gc, Evas_GL_Texture_Pool *pt)
+{
+ evas_gl_common_texture_shared_specific(gc, pt, 0);
+}
+
static void
_print_tex_count(void)
{
pt_unref(Evas_GL_Texture_Pool *pt)
{
if (!pt) return;
+ if (!pt->gc) return;
+
pt->references--;
if (pt->references != 0) return;
eng_ector_renderer_draw(void *data, void *context, void *surface, Ector_Renderer *renderer, Eina_Array *clips EINA_UNUSED, Eina_Bool do_async EINA_UNUSED)
{
Evas_GL_Image *glimg = surface;
- RGBA_Image *img = glimg->im;
Evas_Engine_GL_Context *gc;
Render_Engine_GL_Generic *re = data;
Eina_Array *c;
Eina_Rectangle *r;
+ int w, h;
+ eng_image_size_get(data, glimg, &w, &h);
//TODO handle, clips properly
c = eina_array_new(1);
- eina_array_push(c, eina_rectangle_new(0, 0, img->cache_entry.w, img->cache_entry.h));
+ eina_array_push(c, eina_rectangle_new(0, 0, w, h));
gc = re->window_gl_context_get(re->software.ob);
gc->dc = context;
if (!surface)
{
surface = eng_image_new_from_copied_data(data, width, height, NULL, EINA_TRUE, EVAS_COLORSPACE_ARGB8888);
+ //Use this hint for ZERO COPY texture upload.
+ eng_image_content_hint_set(data, surface, EVAS_IMAGE_CONTENT_HINT_DYNAMIC);
}
else
{
int cur_w , cur_h;
glim = surface;
- cur_w = glim->im->cache_entry.w;
- cur_h = glim->im->cache_entry.h;
+ eng_image_size_get(data, glim, &cur_w, &cur_h);
if (width != cur_w || height != cur_h)
{
eng_image_free(data, surface);
surface = eng_image_new_from_copied_data(data, width, height, NULL, EINA_TRUE, EVAS_COLORSPACE_ARGB8888);
+ //Use this hint for ZERO COPY texture upload.
+ eng_image_content_hint_set(data, surface, EVAS_IMAGE_CONTENT_HINT_DYNAMIC);
}
}
// clear the buffer
- glim = surface;
- void *pixels = evas_cache_image_pixels(&glim->im->cache_entry);
- memset(pixels, 0, width * height *4);
return surface;
}
static void
-eng_ector_begin(void *data EINA_UNUSED, void *context EINA_UNUSED, Ector_Surface *ector,
+eng_ector_begin(void *data, void *context EINA_UNUSED, Ector_Surface *ector,
void *surface, int x, int y, Eina_Bool do_async EINA_UNUSED)
{
- int w, h;
+ int w, h, stride;
Evas_GL_Image *glim = surface;
- RGBA_Image *dst = glim->im;
- w = dst->cache_entry.w;
- h = dst->cache_entry.h;
- void *pixels = evas_cache_image_pixels(&dst->cache_entry);
+
+ DATA32 *pixels;
+ int load_err;
+
+ glim = eng_image_data_get(data, glim, EINA_TRUE, &pixels, &load_err, EINA_TRUE);
+ eng_image_size_get(data, glim, &w, &h);
+ eng_image_stride_get(data, glim, &stride);
+ memset(pixels, 0, stride * h);
+
if (use_cairo)
{
eo_do(ector,
else
{
eo_do(ector,
- ector_software_surface_set(pixels, w, h),
+ ector_software_surface_set(pixels, w, h, stride),
ector_surface_reference_point_set(x, y));
}
}
static void
-eng_ector_end(void *data EINA_UNUSED, void *context EINA_UNUSED, Ector_Surface *ector, void *surface EINA_UNUSED, Eina_Bool do_async EINA_UNUSED)
+eng_ector_end(void *data, void *context EINA_UNUSED, Ector_Surface *ector, void *surface, Eina_Bool do_async EINA_UNUSED)
{
+ void *pixels = NULL;
+ if (use_cairo)
+ {
+ eo_do(ector,
+ ector_cairo_software_surface_get(&pixels, NULL, NULL));
+ }
+ else
+ {
+ eo_do(ector,
+ ector_software_surface_get(&pixels, NULL, NULL, NULL));
+ }
+
+ eng_image_data_put(data, surface, pixels);
+
if (use_cairo)
{
eo_do(ector,
else
{
eo_do(ector,
- ector_software_surface_set(NULL, 0, 0));
+ ector_software_surface_set(NULL, 0, 0, 0));
}
}
else
{
eo_do(ector_surface->ector,
- ector_software_surface_set(pixels, w, h),
+ ector_software_surface_set(pixels, w, h, w * 4),
ector_surface_reference_point_set(x, y));
}
else
{
eo_do(ector,
- ector_software_surface_set(pixels, w, h),
+ ector_software_surface_set(pixels, w, h, w * 4),
ector_surface_reference_point_set(x, y));
}
}
else
{
eo_do(ector,
- ector_software_surface_set(NULL, 0, 0));
+ ector_software_surface_set(NULL, 0, 0, 0));
}
evas_common_cpu_end_opt();