static void TraverseArc2D(GF_Node *node, void *rs, Bool is_destroy)
{
DrawableContext *ctx;
Drawable *stack = (Drawable *)gf_node_get_private(node);
GF_TraverseState *tr_state = (GF_TraverseState *)rs;
if (is_destroy) {
drawable_node_del(node);
return;
}
arc2d_check_changes(node, stack, tr_state);
switch (tr_state->traversing_mode) {
#ifndef GPAC_DISABLE_3D
case TRAVERSE_DRAW_3D:
if (!stack->mesh) {
stack->mesh = new_mesh();
if (gf_node_get_tag(node)==TAG_X3D_Arc2D) {
mesh_get_outline(stack->mesh, stack->path);
} else {
mesh_from_path(stack->mesh, stack->path);
}
}
visual_3d_draw_2d(stack, tr_state);
return;
#endif
case TRAVERSE_GET_BOUNDS:
gf_path_get_bounds(stack->path, &tr_state->bounds);
#ifndef GPAC_DISABLE_3D
gf_bbox_from_rect(&tr_state->bbox, &tr_state->bounds);
#endif
return;
case TRAVERSE_PICK:
vrml_drawable_pick(stack, tr_state);
return;
case TRAVERSE_SORT:
#ifndef GPAC_DISABLE_3D
if (tr_state->visual->type_3d) return;
#endif
ctx = drawable_init_context_mpeg4(stack, tr_state);
if (!ctx) return;
drawable_finalize_sort(ctx, tr_state, NULL);
return;
}
}
static void TraverseIndexedCurve2D(GF_Node *node, void *rs, Bool is_destroy)
{
DrawableContext *ctx;
IndexedCurve2D ic2d;
GF_TraverseState *tr_state = (GF_TraverseState *)rs;
Drawable *stack = (Drawable *)gf_node_get_private(node);
if (is_destroy) {
drawable_node_del(node);
return;
}
if (gf_node_dirty_get(node)) {
if (!IndexedCurve2D_GetNode(node, &ic2d)) return;
curve2d_check_changes((GF_Node*) &ic2d, stack, tr_state, &ic2d.index);
}
switch (tr_state->traversing_mode) {
#ifndef GPAC_DISABLE_3D
case TRAVERSE_DRAW_3D:
if (!stack->mesh) {
stack->mesh = new_mesh();
mesh_from_path(stack->mesh, stack->path);
}
visual_3d_draw_2d(stack, tr_state);
return;
#endif
case TRAVERSE_PICK:
vrml_drawable_pick(stack, tr_state);
return;
case TRAVERSE_GET_BOUNDS:
gf_path_get_bounds(stack->path, &tr_state->bounds);
return;
case TRAVERSE_SORT:
#ifndef GPAC_DISABLE_3D
if (tr_state->visual->type_3d) return;
#endif
ctx = drawable_init_context_mpeg4(stack, tr_state);
if (!ctx) return;
drawable_finalize_sort(ctx, tr_state, NULL);
return;
}
}
static void TraverseDisk2D(GF_Node *node, void *rs, Bool is_destroy)
{
DrawableContext *ctx;
Drawable *stack = (Drawable *)gf_node_get_private(node);
GF_TraverseState *tr_state = (GF_TraverseState *)rs;
if (is_destroy) {
drawable_node_del(node);
return;
}
disk2d_check_changes(node, stack, tr_state);
switch (tr_state->traversing_mode) {
#ifndef GPAC_DISABLE_3D
case TRAVERSE_DRAW_3D:
if (!stack->mesh) {
stack->mesh = new_mesh();
/*FIXME - enable it with OpenGL-ES*/
mesh_from_path(stack->mesh, stack->path);
}
visual_3d_draw_2d(stack, tr_state);
return;
#endif
case TRAVERSE_GET_BOUNDS:
gf_path_get_bounds(stack->path, &tr_state->bounds);
return;
case TRAVERSE_PICK:
vrml_drawable_pick(stack, tr_state);
return;
case TRAVERSE_SORT:
#ifndef GPAC_DISABLE_3D
if (tr_state->visual->type_3d) return;
#endif
ctx = drawable_init_context_mpeg4(stack, tr_state);
if (!ctx) return;
drawable_finalize_sort(ctx, tr_state, NULL);
return;
}
}
void group_cache_draw(GroupCache *cache, GF_TraverseState *tr_state)
{
GF_TextureHandler *old_txh = tr_state->ctx->aspect.fill_texture;
/*switch the texture to our offscreen cache*/
tr_state->ctx->aspect.fill_texture = &cache->txh;
#ifndef GPAC_DISABLE_3D
if (tr_state->traversing_mode == TRAVERSE_DRAW_3D) {
if (!cache->drawable->mesh) {
cache->drawable->mesh = new_mesh();
}
mesh_from_path(cache->drawable->mesh, cache->drawable->path);
visual_3d_draw_2d(cache->drawable, tr_state);
return;
}
#endif
if (! tr_state->visual->DrawBitmap(tr_state->visual, tr_state, tr_state->ctx, NULL)) {
visual_2d_texture_path(tr_state->visual, cache->drawable->path, tr_state->ctx, tr_state);
}
tr_state->ctx->aspect.fill_texture = old_txh;
}
static void fs_traverse(GF_Node *node, void *rs, Bool is_destroy)
{
u32 i;
DrawableContext *ctx;
FSStack *st = (FSStack *) gf_node_get_private(node);
GF_TraverseState *tr_state = (GF_TraverseState*)rs;
if (is_destroy) {
clean_paths(st);
drawable_del(st->drawable);
gf_list_del(st->items);
gf_free(st);
return;
}
/*check for geometry change*/
if (gf_node_dirty_get(node)) {
gf_node_dirty_clear(node, 0);
/*build*/
clean_paths(st);
build_shape(st, node);
}
switch (tr_state->traversing_mode) {
case TRAVERSE_DRAW_2D:
ctx = tr_state->ctx;
for (i=0; i<gf_list_count(st->items); i++) {
FSItem *item = gf_list_get(st->items, i);
ctx->flags &= ~(CTX_PATH_FILLED | CTX_PATH_STROKE);
memset(&ctx->aspect, 0, sizeof(DrawAspect2D));
if (item->fill_col) {
ctx->aspect.fill_color = item->fill_col;
}
if (item->width) {
ctx->aspect.line_color = item->line_col;
ctx->aspect.pen_props.width = item->width;
}
visual_2d_draw_path(tr_state->visual, item->path, ctx, NULL, NULL, tr_state);
}
return;
#ifndef GPAC_DISABLE_3D
case TRAVERSE_DRAW_3D:
ctx = tr_state->ctx;
for (i=0; i<gf_list_count(st->items); i++) {
FSItem *item = gf_list_get(st->items, i);
memset(&ctx->aspect, 0, sizeof(DrawAspect2D));
if (item->fill_col) {
ctx->aspect.fill_color = item->fill_col;
}
if (item->width) {
ctx->aspect.line_color = item->line_col;
ctx->aspect.pen_props.width = item->width;
}
if (!item->mesh) {
item->mesh = new_mesh();
mesh_from_path(item->mesh, item->path);
}
st->drawable->mesh = item->mesh;
visual_3d_draw_2d_with_aspect(st->drawable, tr_state, &ctx->aspect);
st->drawable->mesh = NULL;
}
return;
#endif
case TRAVERSE_PICK:
/*todo*/
return;
case TRAVERSE_GET_BOUNDS:
tr_state->bounds = st->bounds;
return;
case TRAVERSE_SORT:
#ifndef GPAC_DISABLE_3D
if (tr_state->visual->type_3d) return;
#endif
/*finalize*/
ctx = drawable_init_context_mpeg4(st->drawable, tr_state);
if (!ctx) return;
/*force width to max width used for clipper compute*/
if (st->max_width) {
ctx->aspect.pen_props.width = st->max_width;
}
drawable_finalize_sort(ctx, tr_state, &st->bounds);
break;
}
}
static void svg_drawable_traverse(GF_Node *node, void *rs, Bool is_destroy,
void (*rebuild_path)(GF_Node *, Drawable *, SVGAllAttributes *),
Bool is_svg_rect, Bool is_svg_path)
{
GF_Matrix2D backup_matrix;
GF_Matrix mx_3d;
DrawableContext *ctx;
SVGPropertiesPointers backup_props;
u32 backup_flags;
Drawable *drawable = (Drawable *)gf_node_get_private(node);
GF_TraverseState *tr_state = (GF_TraverseState *)rs;
SVGAllAttributes all_atts;
if (is_destroy) {
#if USE_GF_PATH
/* The path is the same as the one in the SVG node, don't delete it here */
if (is_svg_path) drawable->path = NULL;
#endif
drawable_node_del(node);
return;
}
assert(tr_state->traversing_mode!=TRAVERSE_DRAW_2D);
if (tr_state->traversing_mode==TRAVERSE_PICK) {
svg_drawable_pick(node, drawable, tr_state);
return;
}
/*flatten attributes and apply animations + inheritance*/
gf_svg_flatten_attributes((SVG_Element *)node, &all_atts);
if (!compositor_svg_traverse_base(node, &all_atts, (GF_TraverseState *)rs, &backup_props, &backup_flags))
return;
/* Recreates the path (i.e the shape) only if the node is dirty */
if (gf_node_dirty_get(node) & GF_SG_SVG_GEOMETRY_DIRTY) {
/*the rebuild function is responsible for cleaning the path*/
rebuild_path(node, drawable, &all_atts);
gf_node_dirty_clear(node, GF_SG_SVG_GEOMETRY_DIRTY);
drawable_mark_modified(drawable, tr_state);
}
if (drawable->path) {
if (*(tr_state->svg_props->fill_rule)==GF_PATH_FILL_ZERO_NONZERO) {
if (!(drawable->path->flags & GF_PATH_FILL_ZERO_NONZERO)) {
drawable->path->flags |= GF_PATH_FILL_ZERO_NONZERO;
drawable_mark_modified(drawable, tr_state);
}
} else {
if (drawable->path->flags & GF_PATH_FILL_ZERO_NONZERO) {
drawable->path->flags &= ~GF_PATH_FILL_ZERO_NONZERO;
drawable_mark_modified(drawable, tr_state);
}
}
}
if (tr_state->traversing_mode == TRAVERSE_GET_BOUNDS) {
if (! compositor_svg_is_display_off(tr_state->svg_props)) {
DrawAspect2D asp;
gf_path_get_bounds(drawable->path, &tr_state->bounds);
if (!tr_state->ignore_strike) {
memset(&asp, 0, sizeof(DrawAspect2D));
drawable_get_aspect_2d_svg(node, &asp, tr_state);
if (asp.pen_props.width) {
StrikeInfo2D *si = drawable_get_strikeinfo(tr_state->visual->compositor, drawable, &asp, NULL, drawable->path, 0, NULL);
if (si && si->outline) {
gf_path_get_bounds(si->outline, &tr_state->bounds);
}
}
}
compositor_svg_apply_local_transformation(tr_state, &all_atts, &backup_matrix, NULL);
if (!tr_state->abort_bounds_traverse)
gf_mx2d_apply_rect(&tr_state->transform, &tr_state->bounds);
gf_sc_get_nodes_bounds(node, NULL, tr_state, NULL);
compositor_svg_restore_parent_transformation(tr_state, &backup_matrix, NULL);
}
} else if (tr_state->traversing_mode == TRAVERSE_SORT) {
/*reset our flags - this may break reuse of nodes and change-detection in dirty-rect algo */
gf_node_dirty_clear(node, 0);
if (!compositor_svg_is_display_off(tr_state->svg_props) &&
( *(tr_state->svg_props->visibility) != SVG_VISIBILITY_HIDDEN) ) {
compositor_svg_apply_local_transformation(tr_state, &all_atts, &backup_matrix, &mx_3d);
ctx = drawable_init_context_svg(drawable, tr_state);
if (ctx) {
if (is_svg_rect) {
if (ctx->aspect.fill_texture && ctx->aspect.fill_texture->transparent) {}
else if (GF_COL_A(ctx->aspect.fill_color) != 0xFF) {}
else if (ctx->transform.m[1] || ctx->transform.m[3]) {}
else {
ctx->flags &= ~CTX_IS_TRANSPARENT;
if (!ctx->aspect.pen_props.width)
ctx->flags |= CTX_NO_ANTIALIAS;
}
}
if (all_atts.pathLength && all_atts.pathLength->type==SVG_NUMBER_VALUE)
ctx->aspect.pen_props.path_length = all_atts.pathLength->value;
#ifndef GPAC_DISABLE_3D
if (tr_state->visual->type_3d) {
if (!drawable->mesh) {
drawable->mesh = new_mesh();
if (drawable->path) mesh_from_path(drawable->mesh, drawable->path);
}
visual_3d_draw_from_context(ctx, tr_state);
ctx->drawable = NULL;
} else
#endif
{
drawable_finalize_sort(ctx, tr_state, NULL);
}
}
compositor_svg_restore_parent_transformation(tr_state, &backup_matrix, &mx_3d);
}
}
memcpy(tr_state->svg_props, &backup_props, sizeof(SVGPropertiesPointers));
tr_state->svg_flags = backup_flags;
}
/*
This is a crude draft implementation of filter. The main drawback is that we don't cache any data.
We should be able to check for changes in the sub-group or in the filter
*/
void svg_draw_filter(GF_Node *filter, GF_Node *node, GF_TraverseState *tr_state)
{
GF_IRect rc1, rc2;
#ifndef GPAC_DISABLE_3D
u32 type_3d;
#endif
u32 prev_flags;
GF_IRect txrc;
Fixed scale_x, scale_y, temp_x, temp_y;
DrawableContext *ctx, *child_ctx;
GF_SURFACE offscreen_surface, old_surf;
GF_Rect bounds, local_bounds, rc;
GF_Matrix2D backup;
SVGAllAttributes all_atts;
GF_FilterStack *st = gf_node_get_private(filter);
assert(tr_state->traversing_mode==TRAVERSE_SORT);
/*store the current transform matrix, create a new one for group_cache*/
gf_mx2d_copy(backup, tr_state->transform);
gf_mx2d_init(tr_state->transform);
gf_node_allow_cyclic_traverse(node);
tr_state->traversing_mode = TRAVERSE_GET_BOUNDS;
tr_state->bounds.width = tr_state->bounds.height = 0;
gf_node_traverse(node, tr_state);
local_bounds = bounds = tr_state->bounds;
/*compute bounds in final coordinate system - this ensures that the cache has the correct anti aliasing*/
gf_mx2d_apply_rect(&backup, &bounds);
txrc = gf_rect_pixelize(&bounds);
if (txrc.width%2) txrc.width++;
if (txrc.height%2) txrc.height++;
bounds = gf_rect_ft(&txrc);
tr_state->traversing_mode = TRAVERSE_SORT;
gf_mx2d_copy(tr_state->transform, backup);
if (!bounds.width || !bounds.height) {
return;
}
/*create a context */
ctx = drawable_init_context_svg(st->drawable, tr_state);
if (!ctx) return;
/*setup texture */
st->txh.height = txrc.height;
st->txh.width = txrc.width;
st->txh.stride = txrc.width * 4;
st->txh.pixelformat = GF_PIXEL_ARGB;
#ifndef GPAC_DISABLE_3D
if (tr_state->visual->type_3d) st->txh.pixelformat = GF_PIXEL_RGBA;
#endif
st->txh.transparent = 1;
if (st->txh.stride * st->txh.height > st->alloc_size) {
st->alloc_size = st->txh.stride * st->txh.height;
st->data = (u8*)gf_realloc(st->data, sizeof(u8) * st->alloc_size);
}
memset(st->data, 0x0, sizeof(char) * st->txh.stride * st->txh.height);
st->txh.data = (char *) st->data;
/*setup geometry (rectangle matching the bounds of the object)
Warning, we want to center the cached bitmap at the center of the screen (main visual)*/
gf_path_reset(st->drawable->path);
gf_path_add_rect_center(st->drawable->path,
bounds.x + bounds.width/2,
bounds.y - bounds.height/2,
bounds.width,
bounds.height);
old_surf = tr_state->visual->raster_surface;
offscreen_surface = tr_state->visual->compositor->rasterizer->surface_new(tr_state->visual->compositor->rasterizer, tr_state->visual->center_coords);
tr_state->visual->raster_surface = offscreen_surface;
gf_mx2d_copy(backup, tr_state->transform);
gf_mx2d_init(tr_state->transform);
/*attach the buffer to visual*/
tr_state->visual->compositor->rasterizer->surface_attach_to_buffer(offscreen_surface, st->txh.data,
st->txh.width,
st->txh.height,
0,
st->txh.stride,
st->txh.pixelformat);
prev_flags = tr_state->immediate_draw;
tr_state->immediate_draw = 1;
tr_state->traversing_mode = TRAVERSE_SORT;
tr_state->in_svg_filter = 1;
/*recompute the bounds with the final scaling used*/
scale_x = gf_divfix(bounds.width, local_bounds.width);
scale_y = gf_divfix(bounds.height, local_bounds.height);
gf_mx2d_init(tr_state->transform);
gf_mx2d_add_scale(&tr_state->transform, scale_x, scale_y);
rc = local_bounds;
gf_mx2d_apply_rect(&tr_state->transform, &rc);
/*centered the bitmap on the visual*/
if (tr_state->visual->center_coords) {
temp_x = -rc.x - rc.width/2;
temp_y = rc.height/2 - rc.y;
} else {
temp_x = -rc.x;
temp_y = rc.height - rc.y;
}
gf_mx2d_add_translation(&tr_state->transform, temp_x, temp_y);
rc1 = tr_state->visual->surf_rect;
rc2 = tr_state->visual->top_clipper;
tr_state->visual->surf_rect.width = st->txh.width;
tr_state->visual->surf_rect.height = st->txh.height;
if (tr_state->visual->center_coords) {
tr_state->visual->surf_rect.y = st->txh.height/2;
tr_state->visual->surf_rect.x = -1 * (s32) st->txh.width/2;
} else {
tr_state->visual->surf_rect.y = st->txh.height;
tr_state->visual->surf_rect.x = 0;
}
tr_state->visual->top_clipper = tr_state->visual->surf_rect;
#ifndef GPAC_DISABLE_3D
type_3d = tr_state->visual->type_3d;
tr_state->visual->type_3d=0;
#endif
if (prev_flags) gf_node_allow_cyclic_traverse(node);
gf_node_traverse(node, tr_state);
child_ctx = ctx->next;
while (child_ctx && child_ctx->drawable) {
drawable_reset_bounds(child_ctx->drawable, tr_state->visual);
child_ctx->drawable = NULL;
child_ctx = child_ctx->next;
}
tr_state->visual->cur_context = ctx;
/*restore state and destroy whatever needs to be cleaned*/
tr_state->in_svg_filter = 0;
tr_state->immediate_draw = prev_flags;
tr_state->visual->compositor->rasterizer->surface_delete(offscreen_surface);
tr_state->visual->raster_surface = old_surf;
tr_state->traversing_mode = TRAVERSE_SORT;
tr_state->visual->surf_rect = rc1;
tr_state->visual->top_clipper = rc2;
#ifndef GPAC_DISABLE_3D
tr_state->visual->type_3d = type_3d ;
#endif
/*update texture*/
st->txh.transparent = 1;
st->txh.flags |= GF_SR_TEXTURE_NO_GL_FLIP;
gf_sc_texture_set_data(&st->txh);
#ifndef GPAC_DISABLE_3D
if (tr_state->visual->type_3d)
gf_sc_texture_push_image(&st->txh, 0, 0);
else
#endif
gf_sc_texture_push_image(&st->txh, 0, 1);
ctx->flags |= CTX_NO_ANTIALIAS;
ctx->aspect.fill_color = 0;
ctx->aspect.line_color = 0xFF000000;
ctx->aspect.fill_texture = &st->txh;
ctx->flags |= CTX_TEXTURE_DIRTY;
/*get the filter region*/
bounds = local_bounds;
gf_svg_flatten_attributes((SVG_Element *)filter, &all_atts);
if (!all_atts.filterUnits || (*all_atts.filterUnits==SVG_GRADIENTUNITS_OBJECT)) {
Fixed v;
v = all_atts.x ? all_atts.x->value : INT2FIX(-10);
bounds.x += gf_mulfix(v, bounds.width);
v = all_atts.y ? all_atts.y->value : INT2FIX(-10);
bounds.y += gf_mulfix(v, bounds.height);
v = all_atts.width ? all_atts.width->value : INT2FIX(120);
bounds.width = gf_mulfix(v, bounds.width);
v = all_atts.height ? all_atts.height->value : INT2FIX(120);
bounds.height = gf_mulfix(v, bounds.height);
} else {
bounds.x = all_atts.x ? all_atts.x->value : 0;
bounds.y = all_atts.y ? all_atts.y->value : 0;
bounds.width = all_atts.width ? all_atts.x->value : bounds.width;
bounds.height = all_atts.x ? all_atts.x->value : 120;
}
gf_mx2d_apply_rect(&backup, &bounds);
svg_filter_apply(filter, &st->txh, &bounds);
#ifndef GPAC_DISABLE_3D
if (tr_state->visual->type_3d) {
if (!st->drawable->mesh) {
st->drawable->mesh = new_mesh();
mesh_from_path(st->drawable->mesh, st->drawable->path);
}
visual_3d_draw_from_context(tr_state->ctx, tr_state);
ctx->drawable = NULL;
return;
}
#endif
/*we computed the texture in final screen coordinate, so use the identity matrix for the context*/
gf_mx2d_init(tr_state->transform);
drawable_finalize_sort(ctx, tr_state, NULL);
gf_mx2d_copy(tr_state->transform, backup);
}
Bool group_cache_traverse(GF_Node *node, GroupCache *cache, GF_TraverseState *tr_state, Bool force_recompute, Bool is_mpeg4, Bool auto_fit_vp)
{
GF_Matrix2D backup;
DrawableContext *group_ctx = NULL;
GF_ChildNodeItem *l;
if (!cache) return 0;
/*do we need to recompute the cache*/
if (cache->force_recompute) {
force_recompute = 1;
cache->force_recompute = 0;
}
else if (gf_node_dirty_get(node) & GF_SG_CHILD_DIRTY) {
force_recompute = 1;
}
/*we need to redraw the group in an offscreen visual*/
if (force_recompute) {
GF_Matrix2D backup;
GF_IRect rc1, rc2;
u32 type_3d;
u32 prev_flags;
GF_Rect cache_bounds;
GF_SURFACE offscreen_surface, old_surf;
GF_Raster2D *r2d = tr_state->visual->compositor->rasterizer;
DrawableContext *child_ctx;
Fixed temp_x, temp_y, scale_x, scale_y;
GF_LOG(GF_LOG_INFO, GF_LOG_COMPOSE, ("[Compositor] Recomputing cache for subtree %s\n", gf_node_get_log_name(node)));
/*step 1 : store current state and indicate children should not be cached*/
tr_state->in_group_cache = 1;
prev_flags = tr_state->immediate_draw;
/*store the current transform matrix, create a new one for group_cache*/
gf_mx2d_copy(backup, tr_state->transform);
gf_mx2d_init(tr_state->transform);
type_3d = 0;
#ifndef GPAC_DISABLE_3D
/*force 2D rendering*/
type_3d = tr_state->visual->type_3d;
tr_state->visual->type_3d = 0;
#endif
/*step 2: collect the bounds of all children*/
tr_state->traversing_mode = TRAVERSE_GET_BOUNDS;
cache_bounds.width = cache_bounds.height = 0;
l = ((GF_ParentNode*)node)->children;
while (l) {
tr_state->bounds.width = tr_state->bounds.height = 0;
gf_node_traverse(l->node, tr_state);
l = l->next;
gf_rect_union(&cache_bounds, &tr_state->bounds);
}
tr_state->traversing_mode = TRAVERSE_SORT;
if (!cache_bounds.width || !cache_bounds.height) {
tr_state->in_group_cache = 0;
tr_state->immediate_draw = prev_flags;
gf_mx2d_copy(tr_state->transform, backup);
#ifndef GPAC_DISABLE_3D
tr_state->visual->type_3d = type_3d;
#endif
return 0;
}
/*step 3: insert a DrawableContext for this group in the display list*/
if (is_mpeg4) {
#ifndef GPAC_DISABLE_VRML
group_ctx = drawable_init_context_mpeg4(cache->drawable, tr_state);
#endif
} else {
#ifndef GPAC_DISABLE_SVG
group_ctx = drawable_init_context_svg(cache->drawable, tr_state);
#endif
}
if (!group_ctx) return 0;
/*step 4: now we have the bounds:
allocate the offscreen memory
create temp raster visual & attach to buffer
override the tr_state->visual->the_surface with the temp raster
add translation (shape is not always centered)
setup top clipers
*/
old_surf = tr_state->visual->raster_surface;
offscreen_surface = r2d->surface_new(r2d, tr_state->visual->center_coords); /*a new temp raster visual*/
tr_state->visual->raster_surface = offscreen_surface;
/*use current surface coordinate scaling to compute the cache*/
#ifdef GF_SR_USE_VIDEO_CACHE
scale_x = tr_state->visual->compositor->cache_scale * backup.m[0] / 100;
scale_y = tr_state->visual->compositor->cache_scale * backup.m[4] / 100;
#else
scale_x = backup.m[0];
scale_y = backup.m[4];
#endif
if (scale_x<0) scale_x = -scale_x;
if (scale_y<0) scale_y = -scale_y;
cache->scale = MAX(scale_x, scale_y);
tr_state->bounds = cache_bounds;
gf_mx2d_add_scale(&tr_state->transform, scale_x, scale_y);
gf_mx2d_apply_rect(&tr_state->transform, &cache_bounds);
rc1 = gf_rect_pixelize(&cache_bounds);
if (rc1.width % 2) rc1.width++;
if (rc1.height%2) rc1.height++;
/* Initialize the group cache with the scaled pixelized bounds for texture but the original bounds for path*/
group_cache_setup(cache, &tr_state->bounds, &rc1, tr_state->visual->compositor, type_3d);
/*attach the buffer to visual*/
r2d->surface_attach_to_buffer(offscreen_surface, cache->txh.data,
cache->txh.width,
cache->txh.height,
0,
cache->txh.stride,
cache->txh.pixelformat);
/*recompute the bounds with the final scaling used*/
scale_x = gf_divfix(INT2FIX(rc1.width), tr_state->bounds.width);
scale_y = gf_divfix(INT2FIX(rc1.height), tr_state->bounds.height);
gf_mx2d_init(tr_state->transform);
gf_mx2d_add_scale(&tr_state->transform, scale_x, scale_y);
cache_bounds = tr_state->bounds;
gf_mx2d_apply_rect(&tr_state->transform, &cache_bounds);
/*centered the bitmap on the visual*/
temp_x = -cache_bounds.x;
temp_y = -cache_bounds.y;
if (tr_state->visual->center_coords) {
temp_x -= cache_bounds.width/2;
temp_y += cache_bounds.height/2;
} else {
temp_y += cache_bounds.height;
}
gf_mx2d_add_translation(&tr_state->transform, temp_x, temp_y);
/*override top clippers*/
rc1 = tr_state->visual->surf_rect;
rc2 = tr_state->visual->top_clipper;
tr_state->visual->surf_rect.width = cache->txh.width;
tr_state->visual->surf_rect.height = cache->txh.height;
if (tr_state->visual->center_coords) {
tr_state->visual->surf_rect.y = cache->txh.height/2;
tr_state->visual->surf_rect.x = -1 * (s32) cache->txh.width/2;
} else {
tr_state->visual->surf_rect.y = cache->txh.height;
tr_state->visual->surf_rect.x = 0;
}
tr_state->visual->top_clipper = tr_state->visual->surf_rect;
/*step 5: traverse subtree in direct draw mode*/
tr_state->immediate_draw = 1;
group_ctx->flags &= ~CTX_NO_ANTIALIAS;
l = ((GF_ParentNode*)node)->children;
while (l) {
gf_node_traverse(l->node, tr_state);
l = l->next;
}
/*step 6: reset all contexts after the current group one*/
child_ctx = group_ctx->next;
while (child_ctx && child_ctx->drawable) {
drawable_reset_bounds(child_ctx->drawable, tr_state->visual);
child_ctx->drawable = NULL;
child_ctx = child_ctx->next;
}
/*and set ourselves as the last context on the main visual*/
tr_state->visual->cur_context = group_ctx;
/*restore state and destroy whatever needs to be cleaned*/
gf_mx2d_copy(tr_state->transform, backup);
tr_state->in_group_cache = 0;
tr_state->immediate_draw = prev_flags;
r2d->surface_delete(offscreen_surface);
tr_state->visual->raster_surface = old_surf;
tr_state->traversing_mode = TRAVERSE_SORT;
#ifndef GPAC_DISABLE_3D
tr_state->visual->type_3d = type_3d;
#endif
tr_state->visual->surf_rect = rc1;
tr_state->visual->top_clipper = rc2;
/*update texture*/
cache->txh.transparent = 1;
cache->txh.flags |= GF_SR_TEXTURE_NO_GL_FLIP;
gf_sc_texture_set_data(&cache->txh);
gf_sc_texture_push_image(&cache->txh, 0, type_3d ? 0 : 1);
cache->orig_vp = tr_state->vp_size;
}
/*just setup the context*/
else {
if (is_mpeg4) {
#ifndef GPAC_DISABLE_VRML
group_ctx = drawable_init_context_mpeg4(cache->drawable, tr_state);
#endif
} else {
#ifndef GPAC_DISABLE_SVG
group_ctx = drawable_init_context_svg(cache->drawable, tr_state);
#endif
}
}
if (!group_ctx) return 0;
group_ctx->flags |= CTX_NO_ANTIALIAS;
if (cache->opacity != FIX_ONE)
group_ctx->aspect.fill_color = GF_COL_ARGB_FIXED(cache->opacity, FIX_ONE, FIX_ONE, FIX_ONE);
else
group_ctx->aspect.fill_color = 0;
group_ctx->aspect.fill_texture = &cache->txh;
if (!cache->opacity) {
group_ctx->drawable = NULL;
return 0;
}
if (gf_node_dirty_get(node)) group_ctx->flags |= CTX_TEXTURE_DIRTY;
#ifdef CACHE_DEBUG_CENTER
gf_mx2d_copy(backup, tr_state->transform);
gf_mx2d_init(tr_state->transform);
#else
gf_mx2d_copy(backup, tr_state->transform);
if (auto_fit_vp) {
if ((tr_state->vp_size.x != cache->orig_vp.x) || (tr_state->vp_size.y != cache->orig_vp.y)) {
GF_Matrix2D m;
gf_mx2d_init(m);
gf_mx2d_copy(backup, tr_state->transform);
gf_mx2d_add_scale(&m, gf_divfix(tr_state->vp_size.x, cache->orig_vp.x), gf_divfix(tr_state->vp_size.y, cache->orig_vp.y) );
gf_mx2d_pre_multiply(&tr_state->transform, &m);
} else {
auto_fit_vp = 0;
}
}
#endif
#ifndef GPAC_DISABLE_3D
if (tr_state->visual->type_3d) {
if (!cache->drawable->mesh) {
cache->drawable->mesh = new_mesh();
mesh_from_path(cache->drawable->mesh, cache->drawable->path);
}
visual_3d_draw_from_context(group_ctx, tr_state);
group_ctx->drawable = NULL;
} else
#endif
drawable_finalize_sort(group_ctx, tr_state, NULL);
#ifndef CACHE_DEBUG_CENTER
if (auto_fit_vp)
#endif
{
gf_mx2d_copy(tr_state->transform, backup);
}
return (force_recompute==1);
}
static void svg_traverse_bitmap(GF_Node *node, void *rs, Bool is_destroy)
{
Fixed cx, cy, angle;
/*video stack is just an extension of image stack, type-casting is OK*/
SVG_video_stack *stack = (SVG_video_stack*)gf_node_get_private(node);
GF_TraverseState *tr_state = (GF_TraverseState *)rs;
SVGPropertiesPointers backup_props;
u32 backup_flags;
GF_Matrix2D backup_matrix;
GF_Matrix mx_3d;
DrawableContext *ctx;
SVGAllAttributes all_atts;
if (is_destroy) {
gf_sc_texture_destroy(&stack->txh);
gf_sg_mfurl_del(stack->txurl);
drawable_del(stack->graph);
if (stack->audio) {
gf_node_unregister(stack->audio, NULL);
}
gf_free(stack);
return;
}
/*TRAVERSE_DRAW is NEVER called in 3D mode*/
if (tr_state->traversing_mode==TRAVERSE_DRAW_2D) {
SVG_Draw_bitmap(tr_state);
return;
}
else if (tr_state->traversing_mode==TRAVERSE_PICK) {
svg_drawable_pick(node, stack->graph, tr_state);
return;
}
/*flatten attributes and apply animations + inheritance*/
gf_svg_flatten_attributes((SVG_Element *)node, &all_atts);
if (!compositor_svg_traverse_base(node, &all_atts, (GF_TraverseState *)rs, &backup_props, &backup_flags))
return;
if (gf_node_dirty_get(node) & GF_SG_SVG_XLINK_HREF_DIRTY) {
gf_term_get_mfurl_from_xlink(node, &stack->txurl);
stack->txh.width = stack->txh.height = 0;
/*remove associated audio if any*/
if (stack->audio) {
svg_audio_smil_evaluate_ex(NULL, 0, SMIL_TIMING_EVAL_REMOVE, stack->audio, stack->txh.owner);
gf_node_unregister(stack->audio, NULL);
stack->audio = NULL;
}
stack->audio_dirty = GF_TRUE;
if (stack->txurl.count) svg_play_texture(stack, &all_atts);
gf_node_dirty_clear(node, GF_SG_SVG_XLINK_HREF_DIRTY);
}
if (gf_node_dirty_get(node)) {
/*do not clear dirty state until the image is loaded*/
if (stack->txh.width) {
gf_node_dirty_clear(node, 0);
SVG_Build_Bitmap_Graph((SVG_video_stack*)gf_node_get_private(node), tr_state);
}
}
if (tr_state->traversing_mode == TRAVERSE_GET_BOUNDS) {
if (!compositor_svg_is_display_off(tr_state->svg_props)) {
gf_path_get_bounds(stack->graph->path, &tr_state->bounds);
compositor_svg_apply_local_transformation(tr_state, &all_atts, &backup_matrix, &mx_3d);
if (svg_video_get_transform_behavior(tr_state, &all_atts, &cx, &cy, &angle)) {
GF_Matrix2D mx;
tr_state->bounds.width = INT2FIX(stack->txh.width);
tr_state->bounds.height = INT2FIX(stack->txh.height);
tr_state->bounds.x = cx - tr_state->bounds.width/2;
tr_state->bounds.y = cy + tr_state->bounds.height/2;
gf_mx2d_init(mx);
gf_mx2d_add_rotation(&mx, 0, 0, angle);
gf_mx2d_apply_rect(&mx, &tr_state->bounds);
} else {
gf_mx2d_apply_rect(&tr_state->transform, &tr_state->bounds);
}
compositor_svg_restore_parent_transformation(tr_state, &backup_matrix, &mx_3d);
}
} else if (tr_state->traversing_mode == TRAVERSE_SORT) {
if (!compositor_svg_is_display_off(tr_state->svg_props) && ( *(tr_state->svg_props->visibility) != SVG_VISIBILITY_HIDDEN) ) {
GF_Matrix mx_bck;
Bool restore_mx = GF_FALSE;
compositor_svg_apply_local_transformation(tr_state, &all_atts, &backup_matrix, &mx_3d);
ctx = drawable_init_context_svg(stack->graph, tr_state);
if (!ctx || !ctx->aspect.fill_texture ) return;
if (svg_video_get_transform_behavior(tr_state, &all_atts, &cx, &cy, &angle)) {
drawable_reset_path(stack->graph);
gf_path_add_rect_center(stack->graph->path, cx, cy, INT2FIX(stack->txh.width), INT2FIX(stack->txh.height));
gf_mx2d_copy(mx_bck, tr_state->transform);
restore_mx = GF_TRUE;
gf_mx2d_init(tr_state->transform);
gf_mx2d_add_rotation(&tr_state->transform, cx, cy, angle);
}
/*even if set this is not true*/
ctx->aspect.pen_props.width = 0;
ctx->flags |= CTX_NO_ANTIALIAS;
/*if rotation, transparent*/
ctx->flags &= ~CTX_IS_TRANSPARENT;
if (ctx->transform.m[1] || ctx->transform.m[3]) {
ctx->flags |= CTX_IS_TRANSPARENT;
ctx->flags &= ~CTX_NO_ANTIALIAS;
}
else if (ctx->aspect.fill_texture->transparent)
ctx->flags |= CTX_IS_TRANSPARENT;
else if (tr_state->svg_props->opacity && (tr_state->svg_props->opacity->type==SVG_NUMBER_VALUE) && (tr_state->svg_props->opacity->value!=FIX_ONE)) {
ctx->flags = CTX_IS_TRANSPARENT;
ctx->aspect.fill_color = GF_COL_ARGB(FIX2INT(0xFF * tr_state->svg_props->opacity->value), 0, 0, 0);
}
#ifndef GPAC_DISABLE_3D
if (tr_state->visual->type_3d) {
if (!stack->graph->mesh) {
stack->graph->mesh = new_mesh();
mesh_from_path(stack->graph->mesh, stack->graph->path);
}
compositor_3d_draw_bitmap(stack->graph, &ctx->aspect, tr_state, 0, 0, FIX_ONE, FIX_ONE);
ctx->drawable = NULL;
} else
#endif
{
drawable_finalize_sort(ctx, tr_state, NULL);
}
if (restore_mx) gf_mx2d_copy(tr_state->transform, mx_bck);
compositor_svg_restore_parent_transformation(tr_state, &backup_matrix, &mx_3d);
}
}
if (stack->audio) svg_traverse_audio_ex(stack->audio, rs, GF_FALSE, tr_state->svg_props);
memcpy(tr_state->svg_props, &backup_props, sizeof(SVGPropertiesPointers));
tr_state->svg_flags = backup_flags;
}
