void visual_2d_texture_path_opengl_auto(GF_VisualManager *visual, GF_Path *path, GF_TextureHandler *txh, struct _drawable_context *ctx, GF_Rect *orig_bounds, GF_Matrix2D *ext_mx, GF_TraverseState *tr_state)
{
GF_Rect clipper;
u32 prev_mode = tr_state->traversing_mode;
u32 prev_type_3d = tr_state->visual->type_3d;
visual_2d_flush_hybgl_canvas(visual, txh, ctx, tr_state);
tr_state->visual->type_3d = 4;
tr_state->appear = ctx->appear;
if (ctx->col_mat) gf_cmx_copy(&tr_state->color_mat, ctx->col_mat);//
tr_state->traversing_mode=TRAVERSE_DRAW_3D;
gf_mx_from_mx2d(&tr_state->model_matrix, &ctx->transform);
clipper.x = INT2FIX(ctx->bi->clip.x);
clipper.y = INT2FIX(ctx->bi->clip.y);
clipper.width = INT2FIX(ctx->bi->clip.width);
clipper.height = INT2FIX(ctx->bi->clip.height);
visual_3d_set_clipper_2d(tr_state->visual, clipper, NULL, 1);
gf_node_allow_cyclic_traverse(ctx->drawable->node);
gf_node_traverse(ctx->drawable->node, tr_state);
tr_state->visual->type_3d=prev_type_3d;
tr_state->traversing_mode=prev_mode;
if (ctx->col_mat) gf_cmx_init(&tr_state->color_mat);
ctx->flags |= CTX_PATH_FILLED;
visual_3d_reset_clipper_2d(tr_state->visual);
}
void R2D_InitColorTransform(Render2D *sr, GF_Node *node)
{
ColorTransformStack *stack = (ColorTransformStack *)malloc(sizeof(ColorTransformStack));
SetupGroupingNode2D((GroupingNode2D *)stack, sr, node);
gf_cmx_init(&stack->cmat);
gf_node_set_private(node, stack);
gf_node_set_callback_function(node, RenderColorTransform);
}
void compositor_init_colortransform(GF_Compositor *compositor, GF_Node *node)
{
ColorTransformStack *stack;
GF_SAFEALLOC(stack, ColorTransformStack);
gf_cmx_init(&stack->cmat);
gf_node_set_private(node, stack);
gf_node_set_callback_function(node, TraverseColorTransform);
}
static void composite_update(GF_TextureHandler *txh)
{
s32 w, h;
GF_STENCIL stencil;
M_Background2D *back;
GF_TraverseState *tr_state;
Bool invalidate_all;
u32 new_pixel_format;
GF_Compositor *compositor = (GF_Compositor *)txh->compositor;
CompositeTextureStack *st = (CompositeTextureStack *) gf_node_get_private(txh->owner);
GF_Raster2D *raster = st->visual->compositor->rasterizer;
if (st->unsupported) return;
/*
if (compositor->recompute_ar) {
gf_node_dirty_set(txh->owner, 0, 0);
return;
}
*/
if (!compositor->rebuild_offscreen_textures && (!compositor->text_edit_changed || !st->visual->has_text_edit ) && !gf_node_dirty_get(txh->owner)) {
txh->needs_refresh = 0;
return;
}
gf_node_dirty_clear(st->txh.owner, 0);
new_pixel_format = 0;
back = gf_list_get(st->visual->back_stack, 0);
if (back && back->isBound) new_pixel_format = GF_PIXEL_RGB_24;
else new_pixel_format = GF_PIXEL_RGBA;
#ifdef GPAC_USE_TINYGL
/*TinyGL pixel format is fixed at compile time, we cannot override it !*/
if (st->visual->type_3d) new_pixel_format = GF_PIXEL_RGBA;
#else
#ifndef GPAC_DISABLE_3D
/*no alpha support in offscreen rendering*/
if ( (st->visual->type_3d) && !(compositor->video_out->hw_caps & GF_VIDEO_HW_OPENGL_OFFSCREEN_ALPHA))
new_pixel_format = GF_PIXEL_RGB_24;
#endif
/*in OpenGL_ES, only RGBA can be safelly used with glReadPixels*/
#ifdef GPAC_USE_OGL_ES
new_pixel_format = GF_PIXEL_RGBA;
#endif
#endif
/*FIXME - we assume RGB+Depth+bitshape, we should check with the video out module*/
#if defined(GF_SR_USE_DEPTH) && !defined(GPAC_DISABLE_3D)
if (st->visual->type_3d && (compositor->video_out->hw_caps & GF_VIDEO_HW_HAS_DEPTH) ) new_pixel_format = GF_PIXEL_RGBDS;
#endif
#ifndef GPAC_DISABLE_3D
if (st->visual->type_3d>1) {
w = ((M_CompositeTexture3D*)txh->owner)->pixelWidth;
h = ((M_CompositeTexture3D*)txh->owner)->pixelHeight;
} else
#endif
{
w = ((M_CompositeTexture2D*)txh->owner)->pixelWidth;
h = ((M_CompositeTexture2D*)txh->owner)->pixelHeight;
}
/*internal GPAC hacks for testing color spaces*/
if (w<-1) {
w = -w;
if (h<0) {
h = -h;
if (new_pixel_format==GF_PIXEL_RGBA) {
new_pixel_format=GF_PIXEL_ARGB;
} else {
new_pixel_format=GF_PIXEL_BGR_24;
}
} else {
if (new_pixel_format==GF_PIXEL_RGB_24) {
new_pixel_format=GF_PIXEL_RGB_32;
}
}
}
else if (h<-1) {
h = -h;
if (new_pixel_format==GF_PIXEL_RGB_24) {
new_pixel_format=GF_PIXEL_RGB_32;
}
}
if (w<0) w = 0;
if (h<0) h = 0;
if (!w || !h) {
if (txh->tx_io) {
#ifdef GPAC_USE_TINYGL
if (st->tgl_ctx) ostgl_delete_context(st->tgl_ctx);
#endif
gf_sc_texture_release(txh);
if (txh->data) gf_free(txh->data);
txh->data = NULL;
txh->width = txh->height = txh->stride = 0;
}
return;
}
invalidate_all = compositor->rebuild_offscreen_textures;
/*rebuild stencil*/
if (!txh->tx_io
|| (w != (s32) txh->width) || ( h != (s32) txh->height)
|| (new_pixel_format != txh->pixelformat)
) {
Bool needs_stencil = 1;
if (txh->tx_io) {
#ifdef GPAC_USE_TINYGL
if (st->tgl_ctx) ostgl_delete_context(st->tgl_ctx);
#endif
gf_sc_texture_release(txh);
if (txh->data)
gf_free(txh->data);
txh->data = NULL;
}
/*we don't use rect ext because of no support for texture transforms*/
if (1
#ifndef GPAC_DISABLE_3D
|| compositor->gl_caps.npot_texture
#endif
) {
st->txh.width = w;
st->txh.height = h;
st->sx = st->sy = FIX_ONE;
} else {
st->txh.width = 2;
while (st->txh.width<(u32)w) st->txh.width*=2;
st->txh.height = 2;
while (st->txh.height<(u32)h) st->txh.height*=2;
st->sx = INT2FIX(st->txh.width) / w;
st->sy = INT2FIX(st->txh.height) / h;
}
gf_sc_texture_allocate(txh);
txh->pixelformat = new_pixel_format;
switch (new_pixel_format) {
case GF_PIXEL_RGBA:
case GF_PIXEL_ARGB:
txh->stride = txh->width * 4;
txh->transparent = 1;
break;
case GF_PIXEL_RGB_565:
txh->stride = txh->width * 2;
txh->transparent = 0;
break;
case GF_PIXEL_RGBDS:
txh->stride = txh->width * 4;
txh->transparent = 1;
break;
case GF_PIXEL_RGB_24:
txh->stride = txh->width * 3;
txh->transparent = 0;
break;
}
st->visual->width = txh->width;
st->visual->height = txh->height;
stencil = raster->stencil_new(raster, GF_STENCIL_TEXTURE);
/*TODO - add support for compositeTexture3D when root is 2D visual*/
#ifndef GPAC_DISABLE_3D
if (st->visual->type_3d) {
GF_Compositor *compositor = st->visual->compositor;
/*figure out what to do if main visual (eg video out) is not in OpenGL ...*/
if (!compositor->visual->type_3d) {
/*create an offscreen window for OpenGL rendering*/
if ((compositor->offscreen_width < st->txh.width) || (compositor->offscreen_height < st->txh.height)) {
#ifndef GPAC_USE_TINYGL
GF_Err e;
GF_Event evt;
compositor->offscreen_width = MAX(compositor->offscreen_width, st->txh.width);
compositor->offscreen_height = MAX(compositor->offscreen_height, st->txh.height);
evt.type = GF_EVENT_VIDEO_SETUP;
evt.setup.width = compositor->offscreen_width;
evt.setup.height = compositor->offscreen_height;
evt.setup.back_buffer = 0;
evt.setup.opengl_mode = 2;
e = compositor->video_out->ProcessEvent(compositor->video_out, &evt);
if (e) {
gf_sc_texture_release(txh);
st->unsupported = 1;
return;
}
/*reload openGL ext*/
gf_sc_load_opengl_extensions(compositor, 1);
#endif
}
} else {
needs_stencil = 0;
}
}
#endif
if (needs_stencil) {
txh->data = (char*)gf_malloc(sizeof(unsigned char) * txh->stride * txh->height);
memset(txh->data, 0, sizeof(unsigned char) * txh->stride * txh->height);
/*set stencil texture - we don't check error as an image could not be supported by the rasterizer
but still supported by the blitter (case of RGBD/RGBDS)*/
raster->stencil_set_texture(stencil, txh->data, txh->width, txh->height, txh->stride, txh->pixelformat, txh->pixelformat, 0);
#ifdef GPAC_USE_TINYGL
if (st->visual->type_3d && !compositor->visual->type_3d) {
st->tgl_ctx = ostgl_create_context(txh->width, txh->height, txh->transparent ? 32 : 24, &txh->data, 1);
GF_LOG(GF_LOG_DEBUG, GF_LOG_COMPOSE, ("[CompositeTexture] Creating TinyGL Offscreen context %p (%d %d - pf %s)\n", st->tgl_ctx, txh->width, txh->width, gf_4cc_to_str(txh->pixelformat)));
}
#endif
}
invalidate_all = 1;
gf_sc_texture_set_stencil(txh, stencil);
}
if (!txh->tx_io) return;
stencil = gf_sc_texture_get_stencil(txh);
if (!stencil) return;
#ifdef GPAC_USE_TINYGL
if (st->tgl_ctx) ostgl_make_current(st->tgl_ctx, 0);
#endif
GF_SAFEALLOC(tr_state, GF_TraverseState);
tr_state->vrml_sensors = gf_list_new();
tr_state->visual = st->visual;
tr_state->invalidate_all = invalidate_all;
tr_state->immediate_draw = st->visual->compositor->traverse_state->immediate_draw;
gf_mx2d_init(tr_state->transform);
gf_cmx_init(&tr_state->color_mat);
tr_state->backgrounds = st->visual->back_stack;
tr_state->viewpoints = st->visual->view_stack;
tr_state->pixel_metrics = gf_sg_use_pixel_metrics(gf_node_get_graph(st->txh.owner));
tr_state->min_hsize = INT2FIX( MIN(txh->width, txh->height) ) / 2;
tr_state->vp_size.x = INT2FIX(txh->width);
tr_state->vp_size.y = INT2FIX(txh->height);
composite_do_bindable(st->txh.owner, tr_state, st->first);
st->first = 0;
GF_LOG(GF_LOG_DEBUG, GF_LOG_COMPOSE, ("[CompositeTexture] Entering draw cycle\n"));
txh->needs_refresh = visual_draw_frame(st->visual, st->txh.owner, tr_state, 0);
txh->transparent = (st->visual->last_had_back==2) ? 0 : 1;
if (!compositor->edited_text && st->visual->has_text_edit)
st->visual->has_text_edit = 0;
/*set active viewport in image coordinates top-left=(0, 0), not in BIFS*/
if (0 && gf_list_count(st->visual->view_stack)) {
M_Viewport *vp = (M_Viewport *)gf_list_get(st->visual->view_stack, 0);
if (vp->isBound) {
SFVec2f size = vp->size;
if (size.x >=0 && size.y>=0) {
/*FIXME - we need tracking of VP changes*/
txh->needs_refresh = 1;
}
}
}
if (txh->needs_refresh) {
#ifndef GPAC_DISABLE_3D
if (st->visual->camera.is_3D) {
if (st->visual->compositor->visual->type_3d) {
#ifndef GPAC_USE_TINYGL
gf_sc_copy_to_texture(&st->txh);
#else
/*in TinyGL we only need to push associated bitmap to the texture*/
gf_sc_texture_push_image(&st->txh, 0, 0);
#endif
} else {
#ifndef GPAC_USE_TINYGL
gf_sc_copy_to_stencil(&st->txh);
#else
if (txh->pixelformat==GF_PIXEL_RGBDS) gf_get_tinygl_depth(&st->txh);
#endif
}
} else
#endif
{
if (raster->stencil_texture_modified) raster->stencil_texture_modified(stencil);
gf_sc_texture_set_stencil(txh, stencil);
}
gf_sc_invalidate(st->txh.compositor, NULL);
}
gf_list_del(tr_state->vrml_sensors);
gf_free(tr_state);
GF_LOG(GF_LOG_DEBUG, GF_LOG_COMPOSE, ("[CompositeTexture] Leaving draw cycle\n"));
}
static void UpdateComposite2D(GF_TextureHandler *txh)
{
GF_Err e;
u32 i;
SensorHandler *hsens;
RenderEffect2D *eff;
M_CompositeTexture2D *ct2D = (M_CompositeTexture2D *)txh->owner;
Composite2DStack *st = (Composite2DStack *) gf_node_get_private(txh->owner);
GF_Raster2D *r2d = st->surf->render->compositor->r2d;
if (!gf_node_dirty_get(txh->owner)) {
txh->needs_refresh = 0;
return;
}
/*rebuild stencil*/
if (!st->surf->the_surface || !txh->hwtx || ((s32) st->width != ct2D->pixelWidth) || ( (s32) st->height != ct2D->pixelHeight) ) {
if (txh->hwtx) r2d->stencil_delete(txh->hwtx);
txh->hwtx = NULL;
if (ct2D->pixelWidth<=0) return;
if (ct2D->pixelHeight<=0) return;
st->width = ct2D->pixelWidth;
st->height = ct2D->pixelHeight;
txh->hwtx = r2d->stencil_new(r2d, GF_STENCIL_TEXTURE);
e = r2d->stencil_create_texture(txh->hwtx, st->width, st->height, GF_PIXEL_ARGB);
if (e) {
if (txh->hwtx) r2d->stencil_delete(txh->hwtx);
txh->hwtx = NULL;
}
}
if (!txh->hwtx) return;
GF_SAFEALLOC(eff, RenderEffect2D);
eff->sensors = gf_list_new();
eff->surface = st->surf;
if (st->surf->render->top_effect->trav_flags & TF_RENDER_DIRECT) {
eff->trav_flags = TF_RENDER_DIRECT;
}
gf_mx2d_init(eff->transform);
gf_cmx_init(&eff->color_mat);
st->surf->width = st->width;
st->surf->height = st->height;
eff->back_stack = st->surf->back_stack;
eff->view_stack = st->surf->view_stack;
eff->is_pixel_metrics = gf_sg_use_pixel_metrics(gf_node_get_graph(st->txh.owner));
eff->min_hsize = INT2FIX( MIN(st->width, st->height) ) / 2;
Composite_CheckBindables(st->txh.owner, eff, st->first);
st->first = 0;
GF_LOG(GF_LOG_DEBUG, GF_LOG_RENDER, ("[Render 2D] Entering CompositeTexture2D Render Cycle\n"));
e = VS2D_InitDraw(st->surf, eff);
if (e) {
effect_delete(eff);
return;
}
/*render children*/
if (gf_node_dirty_get(st->txh.owner) & GF_SG_NODE_DIRTY) {
GF_ChildNodeItem *l = ct2D->children;
/*rebuild sensor list */
if (gf_list_count(st->sensors)) {
gf_list_del(st->sensors);
st->sensors = gf_list_new();
}
while (l) {
if (l->node && is_sensor_node(l->node) ) {
hsens = get_sensor_handler(l->node);
if (hsens) gf_list_add(st->sensors, hsens);
}
l = l->next;
}
/*if we have an active sensor at this level discard all sensors in current render context (cf VRML)*/
if (gf_list_count(st->sensors)) {
effect_reset_sensors(eff);
}
}
/*add sensor to effects*/
i=0;
while ((hsens = (SensorHandler*)gf_list_enum(st->sensors, &i))) {
effect_add_sensor(eff, hsens, &eff->transform);
}
gf_node_dirty_clear(st->txh.owner, 0);
/*render*/
gf_node_render_children(st->txh.owner, eff);
/*finalize draw*/
txh->needs_refresh = VS2D_TerminateDraw(st->surf, eff);
st->txh.transparent = st->surf->last_had_back ? 0 : 1;
/*
st->txh.active_window.x = 0;
st->txh.active_window.y = 0;
st->txh.active_window.width = st->width;
st->txh.active_window.height = st->height;
*/
st->txh.width = st->width;
st->txh.height = st->height;
/*set active viewport in image coordinates top-left=(0, 0), not in BIFS*/
if (gf_list_count(st->surf->view_stack)) {
M_Viewport *vp = (M_Viewport *)gf_list_get(st->surf->view_stack, 0);
if (vp->isBound) {
SFVec2f size = vp->size;
if (size.x >=0 && size.y>=0) {
/*
st->txh.active_window.width = size.x;
st->txh.active_window.height = size.y;
st->txh.active_window.x = (st->width - size.x) / 2;
st->txh.active_window.y = (st->height - size.y) / 2;
*/
/*FIXME - we need tracking of VP changes*/
txh->needs_refresh = 1;
}
}
}
if (txh->needs_refresh) {
if (r2d->stencil_texture_modified) r2d->stencil_texture_modified(st->txh.hwtx);
gf_sr_invalidate(st->txh.compositor, NULL);
}
effect_delete(eff);
GF_LOG(GF_LOG_DEBUG, GF_LOG_RENDER, ("[Render 2D] Leaving CompositeTexture2D Render Cycle\n"));
}
