static void traverse_transform(GF_Node *node, Transform2DStack *stack, GF_TraverseState *tr_state)
{
if (stack->is_null) return;
/*note we don't clear dirty flag, this is done in traversing*/
if (stack->is_identity) {
group_2d_traverse(node, (GroupingNode2D *)stack, tr_state);
}
#ifndef GPAC_DISABLE_3D
else if (tr_state->visual->type_3d) {
GF_Matrix mx_bckup;
gf_mx_copy(mx_bckup, tr_state->model_matrix);
gf_mx_add_matrix_2d(&tr_state->model_matrix, &stack->mat);
group_2d_traverse(node, (GroupingNode2D *)stack, tr_state);
gf_mx_copy(tr_state->model_matrix, mx_bckup);
}
#endif
else {
GF_Matrix2D bckup;
gf_mx2d_copy(bckup, tr_state->transform);
gf_mx2d_pre_multiply(&tr_state->transform, &stack->mat);
group_2d_traverse(node, (GroupingNode2D *)stack, tr_state);
gf_mx2d_copy(tr_state->transform, bckup);
}
if (tr_state->traversing_mode == TRAVERSE_GET_BOUNDS) {
gf_mx2d_apply_rect(&stack->mat, &tr_state->bounds);
}
}
GF_Node *CT2D_PickNode(GF_TextureHandler *txh, DrawableContext *ctx, Fixed x, Fixed y)
{
GF_Rect orig;
GF_Matrix2D mat, tx_trans;
Fixed width, height;
Composite2DStack *st = (Composite2DStack *) gf_node_get_private(txh->owner);
assert(st->surf);
orig = ctx->bi->unclip;
gf_mx2d_copy(mat, ctx->transform);
gf_mx2d_inverse(&mat);
gf_mx2d_apply_rect(&mat, &orig);
gf_mx2d_init(mat);
gf_mx2d_add_scale(&mat, orig.width / st->width, orig.height / st->height);
get_gf_sr_texture_transform(ctx->appear, &st->txh, &tx_trans, (ctx->h_texture==&st->txh) ? 0 : 1, INT2FIX(orig.width), INT2FIX(orig.height));
gf_mx2d_add_matrix(&mat, &tx_trans);
gf_mx2d_add_translation(&mat, (orig.x), (orig.y - orig.height));
gf_mx2d_add_matrix(&mat, &ctx->transform);
gf_mx2d_inverse(&mat);
gf_mx2d_apply_coords(&mat, &x, &y);
width = INT2FIX(st->width);
height = INT2FIX(st->height);
while (x>width) x -= width;
while (x < 0) x += width;
while (y>height) y -= height;
while (y < 0) y += height;
x -= width / 2;
y -= height / 2;
return VS2D_PickNode(st->surf, x, y);
}
Bool visual_2d_node_cull(GF_TraverseState *tr_state, GF_Rect *bounds)
{
GF_Rect rc;
GF_IRect i_rc;
rc = *bounds;
gf_mx2d_apply_rect(&tr_state->transform, &rc);
i_rc = gf_rect_pixelize(&rc);
if (gf_irect_overlaps(&tr_state->visual->top_clipper, &i_rc)) return 1;
return 0;
}
static void compositor_2d_draw_rectangle(GF_TraverseState *tr_state)
{
DrawableContext *ctx = tr_state->ctx;
if (ctx->aspect.fill_texture && ctx->aspect.fill_texture->data
#ifndef GPAC_DISABLE_3D
&& !tr_state->visual->compositor->hybrid_opengl
#endif
) {
Bool res;
/*get image size WITHOUT line size or antialias margin*/
if ( !(ctx->flags & CTX_NO_ANTIALIAS) ) {
GF_Rect orig_unclip;
GF_IRect orig_clip;
orig_unclip = ctx->bi->unclip;
orig_clip = ctx->bi->clip;
gf_path_get_bounds(ctx->drawable->path, &ctx->bi->unclip);
gf_mx2d_apply_rect(&ctx->transform, &ctx->bi->unclip);
ctx->bi->clip = gf_rect_pixelize(&ctx->bi->unclip);
gf_irect_intersect(&ctx->bi->clip, &orig_clip);
res = tr_state->visual->DrawBitmap(tr_state->visual, tr_state, ctx, NULL);
/*strike path*/
ctx->bi->unclip = orig_unclip;
ctx->bi->clip = orig_clip;
if (res) {
ctx->flags |= CTX_PATH_FILLED;
visual_2d_draw_path(tr_state->visual, ctx->drawable->path, ctx, NULL, NULL, tr_state);
}
} else {
res = tr_state->visual->DrawBitmap(tr_state->visual, tr_state, ctx, NULL);
}
/*if failure retry with raster*/
if (res) return;
}
visual_2d_texture_path(tr_state->visual, ctx->drawable->path, ctx, tr_state);
visual_2d_draw_path(tr_state->visual, ctx->drawable->path, ctx, NULL, NULL, tr_state);
}
void r2d_render_svg_sani_use(GF_Node *node, GF_Node *sub_root, void *rs)
{
GF_Matrix2D backup_matrix;
GF_Matrix2D translate;
GF_Node *prev_use;
SVG_SANI_useElement *use = (SVG_SANI_useElement *)node;
RenderEffect2D *eff = (RenderEffect2D *)rs;
svg_sani_render_base(node, eff);
gf_mx2d_init(translate);
translate.m[2] = use->x.value;
translate.m[5] = use->y.value;
if (eff->traversing_mode == TRAVERSE_GET_BOUNDS) {
gf_svg_sani_apply_local_transformation(eff, node, &backup_matrix);
if (use->display != SVG_DISPLAY_NONE) {
gf_node_render((GF_Node*)use->xlink->href.target, eff);
gf_mx2d_apply_rect(&translate, &eff->bounds);
}
gf_svg_sani_restore_parent_transformation(eff, &backup_matrix);
return;
}
if (use->display == SVG_DISPLAY_NONE ||
use->visibility == SVG_VISIBILITY_HIDDEN) {
return;
}
gf_svg_sani_apply_local_transformation(eff, node, &backup_matrix);
gf_mx2d_pre_multiply(&eff->transform, &translate);
prev_use = eff->parent_use;
eff->parent_use = use->xlink->href.target;
gf_node_render(use->xlink->href.target, eff);
eff->parent_use = prev_use;
gf_svg_sani_restore_parent_transformation(eff, &backup_matrix);
}
GF_Err evg_surface_fill(GF_SURFACE _this, GF_STENCIL stencil)
{
GF_Rect rc;
GF_Matrix2D mat, st_mat;
Bool restore_filter;
EVGSurface *surf = (EVGSurface *)_this;
EVGStencil *sten = (EVGStencil *)stencil;
if (!surf || !stencil) return GF_BAD_PARAM;
if (!surf->ftoutline.n_points) return GF_OK;
surf->sten = sten;
/*setup ft raster calllbacks*/
if (!setup_grey_callback(surf)) return GF_OK;
/* surf->ftparams.gray_spans = gray_spans_stub; */
get_surface_world_matrix(surf, &mat);
restore_filter = 0;
/*get path frame for texture convertion */
if (sten->type != GF_STENCIL_SOLID) {
rc = surf->path_bounds;
gf_mx2d_apply_rect(&mat, &rc);
rc.x = rc.y = 0;
/*assign target frame and matrix*/
sten->frame = rc;
gf_mx2d_copy(sten->pmat, surf->mat);
gf_mx2d_inverse(&sten->pmat);
gf_mx2d_copy(st_mat, sten->smat);
gf_mx2d_init(sten->smat);
switch (sten->type) {
case GF_STENCIL_TEXTURE:
if (! ((EVG_Texture *)sten)->pixels) return GF_BAD_PARAM;
if (((EVG_Texture *)sten)->mod & GF_TEXTURE_FLIP) {
if (!surf->center_coords) gf_mx2d_add_scale(&sten->smat, FIX_ONE, -FIX_ONE);
} else {
if (surf->center_coords) gf_mx2d_add_scale(&sten->smat, FIX_ONE, -FIX_ONE);
}
evg_set_texture_active(sten);
gf_mx2d_add_matrix(&sten->smat, &st_mat);
gf_mx2d_add_matrix(&sten->smat, &mat);
gf_mx2d_inverse(&sten->smat);
evg_bmp_init(sten);
if (((EVG_Texture *)sten)->filter == GF_TEXTURE_FILTER_DEFAULT) {
restore_filter = 1;
((EVG_Texture *)sten)->filter = surf->texture_filter;
}
break;
case GF_STENCIL_LINEAR_GRADIENT:
{
EVG_LinearGradient *lin = (EVG_LinearGradient *)sten;
gf_mx2d_add_matrix(&sten->smat, &st_mat);
gf_mx2d_add_matrix(&sten->smat, &mat);
gf_mx2d_inverse(&sten->smat);
/*and finalize matrix in gradient coord system*/
gf_mx2d_add_matrix(&sten->smat, &lin->vecmat);
gf_mx2d_add_scale(&sten->smat, INT2FIX(1<<EVGGRADIENTBITS), INT2FIX(1<<EVGGRADIENTBITS));
}
break;
case GF_STENCIL_RADIAL_GRADIENT:
{
EVG_RadialGradient *rad = (EVG_RadialGradient*)sten;
gf_mx2d_copy(sten->smat, st_mat);
gf_mx2d_add_matrix(&sten->smat, &mat);
gf_mx2d_inverse(&sten->smat);
gf_mx2d_add_translation(&sten->smat, -rad->center.x, -rad->center.y);
gf_mx2d_add_scale(&sten->smat, gf_invfix(rad->radius.x), gf_invfix(rad->radius.y));
rad->d_f.x = gf_divfix(rad->focus.x - rad->center.x, rad->radius.x);
rad->d_f.y = gf_divfix(rad->focus.y - rad->center.y, rad->radius.y);
/*init*/
evg_radial_init(rad);
}
break;
}
}
if (surf->useClipper) {
surf->ftparams.clip_xMin = surf->clipper.x;
surf->ftparams.clip_yMin = surf->clipper.y;
surf->ftparams.clip_xMax = (surf->clipper.x + surf->clipper.width);
surf->ftparams.clip_yMax = (surf->clipper.y + surf->clipper.height);
} else {
surf->ftparams.clip_xMin = 0;
surf->ftparams.clip_yMin = 0;
surf->ftparams.clip_xMax = (surf->width);
surf->ftparams.clip_yMax = (surf->height);
}
/*and call the raster*/
evg_raster_render(surf->raster, &surf->ftparams);
/*restore stencil matrix*/
if (sten->type != GF_STENCIL_SOLID) {
gf_mx2d_copy(sten->smat, st_mat);
if (restore_filter) ((EVG_Texture *)sten)->filter = GF_TEXTURE_FILTER_DEFAULT;
}
surf->sten = 0L;
return GF_OK;
}
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;
}
static void TraverseLayer3D(GF_Node *node, void *rs, Bool is_destroy)
{
Bool prev_layer, changed = 0;
GF_List *oldb, *oldv, *oldf, *oldn;
GF_Rect rc;
u32 cur_lights;
GF_List *node_list_backup;
GF_BBox bbox_backup;
GF_Matrix model_backup;
GF_Matrix2D mx2d_backup;
GF_Camera *prev_cam;
GF_VisualManager *old_visual;
M_Layer3D *l = (M_Layer3D *)node;
Layer3DStack *st = (Layer3DStack *) gf_node_get_private(node);
GF_TraverseState *tr_state = (GF_TraverseState *) rs;
if (is_destroy) {
DestroyLayer3D(node);
return;
}
if (st->unsupported) return;
if (gf_node_dirty_get(node)) {
/*main visual in pixel metrics, use output width*/
if (tr_state->pixel_metrics && (tr_state->visual->compositor->visual==tr_state->visual)) {
st->clip.width = INT2FIX(tr_state->visual->compositor->vp_width);
st->clip.height = INT2FIX(tr_state->visual->compositor->vp_height);
} else {
visual_get_size_info(tr_state, &st->clip.width, &st->clip.height);
}
/*setup bounds in local coord system*/
if (l->size.x>=0) st->clip.width = l->size.x;
if (l->size.y>=0) st->clip.height = l->size.y;
st->clip = gf_rect_center(st->clip.width, st->clip.height);
changed = 1;
}
switch (tr_state->traversing_mode) {
case TRAVERSE_GET_BOUNDS:
if (!tr_state->for_node) {
tr_state->bounds = st->clip;
gf_bbox_from_rect(&tr_state->bbox, &st->clip);
return;
}
case TRAVERSE_PICK:
case TRAVERSE_SORT:
/*layers can only be used in a 2D context*/
if (tr_state->camera && tr_state->camera->is_3D) return;
break;
case TRAVERSE_DRAW_2D:
layer3d_draw_2d(node, tr_state);
return;
case TRAVERSE_DRAW_3D:
default:
return;
}
/*layer3D maintains its own stacks*/
oldb = tr_state->backgrounds;
oldv = tr_state->viewpoints;
oldf = tr_state->fogs;
oldn = tr_state->navigations;
tr_state->backgrounds = st->visual->back_stack;
tr_state->viewpoints = st->visual->view_stack;
tr_state->navigations = st->visual->navigation_stack;
tr_state->fogs = st->visual->fog_stack;
prev_layer = tr_state->is_layer;
tr_state->is_layer = 1;
prev_cam = tr_state->camera;
tr_state->camera = &st->visual->camera;
old_visual = tr_state->visual;
bbox_backup = tr_state->bbox;
gf_mx_copy(model_backup, tr_state->model_matrix);
gf_mx2d_copy(mx2d_backup, tr_state->transform);
/*compute viewport in visual coordinate*/
rc = st->clip;
if (prev_cam) {
gf_mx_apply_rect(&tr_state->model_matrix, &rc);
gf_mx_apply_rect(&prev_cam->modelview, &rc);
if (tr_state->camera->flags & CAM_HAS_VIEWPORT)
gf_mx_apply_rect(&prev_cam->viewport, &rc);
#if 0
if (tr_state->visual->compositor->visual==tr_state->visual) {
GF_Matrix mx;
gf_mx_init(mx);
gf_mx_add_scale(&mx, tr_state->visual->compositor->scale_x, tr_state->visual->compositor->scale_y, FIX_ONE);
gf_mx_apply_rect(&mx, &rc);
}
#endif
} else {
gf_mx2d_apply_rect(&tr_state->transform, &rc);
/* if (tr_state->visual->compositor->visual==tr_state->visual) {
gf_mx2d_init(mx2d_backup);
gf_mx2d_add_scale(&mx2d_backup, tr_state->visual->compositor->scale_x, tr_state->visual->compositor->scale_y);
gf_mx2d_apply_rect(&mx2d_backup, &rc);
}
*/
/*switch visual*/
tr_state->visual = st->visual;
}
/*check bindables*/
gf_mx_init(tr_state->model_matrix);
l3d_CheckBindables(node, tr_state, st->first);
if (prev_cam) gf_mx_copy(tr_state->model_matrix, model_backup);
/*drawing a layer means drawing all subelements as a whole (no depth sorting with parents)*/
if (tr_state->traversing_mode==TRAVERSE_SORT) {
if (gf_node_dirty_get(node)) changed = 1;
gf_node_dirty_clear(node, GF_SG_NODE_DIRTY|GF_SG_VRML_BINDABLE_DIRTY);
/*!! we were in a 2D mode, setup associated texture !!*/
if (!prev_cam) {
switch (layer3d_setup_offscreen(node, st, tr_state, rc.width, rc.height)) {
case 0:
goto l3d_exit;
case 2:
if (!changed && !(st->visual->camera.flags & CAM_IS_DIRTY) && !st->visual->camera.anim_len) {
GF_LOG(GF_LOG_DEBUG, GF_LOG_COMPOSE, ("[Layer3D] No changes found , skipping 3D draw\n"));
goto layer3d_unchanged_2d;
}
default:
break;
}
#ifdef GPAC_USE_TINYGL
if (st->tgl_ctx) ostgl_make_current(st->tgl_ctx, 0);
#endif
/*note that we don't backup the state as a layer3D cannot be declared in a layer3D*/
tr_state->layer3d = node;
rc = st->vp;
/*setup GL*/
visual_3d_setup(tr_state->visual);
visual_3d_set_matrix_mode(tr_state->visual, V3D_MATRIX_PROJECTION);
visual_3d_matrix_reset(tr_state->visual);
visual_3d_set_matrix_mode(tr_state->visual, V3D_MATRIX_TEXTURE);
visual_3d_matrix_reset(tr_state->visual);
visual_3d_set_matrix_mode(tr_state->visual, V3D_MATRIX_MODELVIEW);
visual_3d_matrix_reset(tr_state->visual);
} else {
visual_3d_set_matrix_mode(tr_state->visual, V3D_MATRIX_PROJECTION);
visual_3d_matrix_push(tr_state->visual);
visual_3d_set_matrix_mode(tr_state->visual, V3D_MATRIX_TEXTURE);
visual_3d_matrix_push(tr_state->visual);
visual_3d_set_matrix_mode(tr_state->visual, V3D_MATRIX_MODELVIEW);
visual_3d_matrix_push(tr_state->visual);
}
GF_LOG(GF_LOG_DEBUG, GF_LOG_COMPOSE, ("[Layer3D] Redrawing\n"));
layer3d_setup_clip(st, tr_state, prev_cam ? 1 : 0, rc);
cur_lights = tr_state->visual->num_lights;
/*this will init projection. Note that we're binding the viewpoint in the current pixelMetrics context
even if the viewpoint was declared in an inline below
if no previous camera, we're using offscreen rendering, force clear */
visual_3d_init_draw(tr_state, prev_cam ? 1 : 2);
visual_3d_check_collisions(tr_state, l->children);
tr_state->traversing_mode = TRAVERSE_SORT;
/*shortcut node list*/
node_list_backup = tr_state->visual->alpha_nodes_to_draw;
tr_state->visual->alpha_nodes_to_draw = gf_list_new();
/*reset cull flag*/
tr_state->cull_flag = 0;
group_3d_traverse(node, (GroupingNode *)st, tr_state);
visual_3d_flush_contexts(tr_state->visual, tr_state);
gf_list_del(tr_state->visual->alpha_nodes_to_draw);
tr_state->visual->alpha_nodes_to_draw = node_list_backup;
while (cur_lights < tr_state->visual->num_lights) {
visual_3d_remove_last_light(tr_state->visual);
}
tr_state->traversing_mode = TRAVERSE_SORT;
if (prev_cam) {
visual_3d_set_matrix_mode(tr_state->visual, V3D_MATRIX_PROJECTION);
visual_3d_matrix_pop(tr_state->visual);
visual_3d_set_matrix_mode(tr_state->visual, V3D_MATRIX_TEXTURE);
visual_3d_matrix_pop(tr_state->visual);
visual_3d_set_matrix_mode(tr_state->visual, V3D_MATRIX_MODELVIEW);
visual_3d_matrix_pop(tr_state->visual);
}
/*!! we were in a 2D mode, create drawable context!!*/
if (!prev_cam) {
DrawableContext *ctx;
/*with TinyGL we draw directly to the offscreen buffer*/
#ifndef GPAC_USE_TINYGL
gf_sc_copy_to_stencil(&st->txh);
#else
if (st->txh.pixelformat==GF_PIXEL_RGBDS)
gf_get_tinygl_depth(&st->txh);
#endif
if (tr_state->visual->compositor->rasterizer->stencil_texture_modified)
tr_state->visual->compositor->rasterizer->stencil_texture_modified(gf_sc_texture_get_stencil(&st->txh) );
gf_sc_texture_set_stencil(&st->txh, gf_sc_texture_get_stencil(&st->txh) );
changed = 1;
layer3d_unchanged_2d:
/*restore visual*/
tr_state->visual = old_visual;
tr_state->layer3d = NULL;
tr_state->appear = NULL;
// tr_state->camera = prev_cam;
ctx = drawable_init_context_mpeg4(st->drawable, tr_state);
if (!ctx) return;
ctx->aspect.fill_texture = &st->txh;
ctx->flags |= CTX_NO_ANTIALIAS;
if (changed) ctx->flags |= CTX_APP_DIRTY;
if (st->txh.transparent) ctx->flags |= CTX_IS_TRANSPARENT;
drawable_finalize_sort(ctx, tr_state, NULL);
}
}
/*check picking - we must fall in our 2D clipper except when mvt is grabbed on layer*/
else if (!gf_node_dirty_get(node) && (tr_state->traversing_mode==TRAVERSE_PICK)) {
GF_Ray prev_r;
SFVec3f start, end;
SFVec4f res;
Fixed in_x, in_y;
Bool do_pick = 0;
if (!prev_cam) rc = st->vp;
layer3d_setup_clip(st, tr_state, prev_cam ? 1 : 0, rc);
if (tr_state->visual->compositor->active_layer==node) {
do_pick = (tr_state->visual->compositor->grabbed_sensor || tr_state->visual->compositor->navigation_state) ? 1 : 0;
}
if (!prev_cam) gf_mx_from_mx2d(&tr_state->model_matrix, &tr_state->transform);
if (!do_pick && !gf_list_count(tr_state->visual->compositor->sensors))
do_pick = gf_sc_pick_in_clipper(tr_state, &st->clip);
if (!do_pick) goto l3d_exit;
prev_r = tr_state->ray;
compositor_get_2d_plane_intersection(&tr_state->ray, &start);
gf_mx_inverse(&tr_state->model_matrix);
gf_mx_apply_vec(&tr_state->model_matrix, &start);
if (tr_state->visual->compositor->visual==tr_state->visual) {
start.x = gf_mulfix(start.x, tr_state->visual->compositor->scale_x);
start.y = gf_mulfix(start.y, tr_state->visual->compositor->scale_y);
} else if (!prev_cam) {
start.x = gf_muldiv(start.x, st->visual->camera.width, st->clip.width);
start.y = gf_muldiv(start.y, st->visual->camera.height, st->clip.height);
}
visual_3d_setup_projection(tr_state, 1);
in_x = 2 * gf_divfix(start.x, st->visual->camera.width);
in_y = 2 * gf_divfix(start.y, st->visual->camera.height);
res.x = in_x; res.y = in_y; res.z = -FIX_ONE; res.q = FIX_ONE;
gf_mx_apply_vec_4x4(&st->visual->camera.unprojection, &res);
if (!res.q) goto l3d_exit;
start.x = gf_divfix(res.x, res.q);
start.y = gf_divfix(res.y, res.q);
start.z = gf_divfix(res.z, res.q);
res.x = in_x; res.y = in_y; res.z = FIX_ONE; res.q = FIX_ONE;
gf_mx_apply_vec_4x4(&st->visual->camera.unprojection, &res);
if (!res.q) goto l3d_exit;
end.x = gf_divfix(res.x, res.q);
end.y = gf_divfix(res.y, res.q);
end.z = gf_divfix(res.z, res.q);
tr_state->ray = gf_ray(start, end);
GF_LOG(GF_LOG_DEBUG, GF_LOG_COMPOSE, ("[Layer3D] Picking: cast ray\n\tOrigin %.4f %.4f %.4f - End %.4f %.4f %.4f\n\tDir %.4f %.4f %.4f\n",
FIX2FLT(tr_state->ray.orig.x), FIX2FLT(tr_state->ray.orig.y), FIX2FLT(tr_state->ray.orig.z),
FIX2FLT(end.x), FIX2FLT(end.y), FIX2FLT(end.z),
FIX2FLT(tr_state->ray.dir.x), FIX2FLT(tr_state->ray.dir.y), FIX2FLT(tr_state->ray.dir.z)));
group_3d_traverse(node, (GroupingNode *)st, tr_state);
tr_state->ray = prev_r;
/*store info if navigation allowed - we just override any layer3D picked first since we are picking 2D
objects*/
if (tr_state->camera->navigate_mode || (tr_state->camera->navigation_flags & NAV_ANY))
tr_state->layer3d = node;
tr_state->traversing_mode = TRAVERSE_PICK;
}
l3d_exit:
/*restore camera*/
tr_state->camera = prev_cam;
if (prev_cam) visual_3d_set_viewport(tr_state->visual, tr_state->camera->vp);
tr_state->visual = old_visual;
/*restore traversing state*/
tr_state->backgrounds = oldb;
tr_state->viewpoints = oldv;
tr_state->fogs = oldf;
tr_state->navigations = oldn;
tr_state->bbox = bbox_backup;
tr_state->is_layer = prev_layer;
gf_mx_copy(tr_state->model_matrix, model_backup);
gf_mx2d_copy(tr_state->transform, mx2d_backup);
/*in case we missed bindables*/
if (st->first) {
st->first = 0;
gf_node_dirty_set(node, 0, 0);
gf_sc_invalidate(tr_state->visual->compositor, NULL);
}
}
static void TraverseLayer2D(GF_Node *node, void *rs, Bool is_destroy)
{
GF_List *oldb, *oldv;
GF_Node *viewport;
GF_Node *back;
Bool prev_layer;
GF_Matrix2D backup;
SFVec2f prev_vp;
#ifndef GPAC_DISABLE_3D
GF_Matrix mx3d;
GF_List *oldf, *oldn;
GF_List *node_list_backup;
GF_Rect prev_clipper;
Bool had_clip;
#endif
M_Layer2D *l = (M_Layer2D *)node;
Layer2DStack *st = (Layer2DStack *) gf_node_get_private(node);
GF_TraverseState *tr_state = (GF_TraverseState *) rs;
if (is_destroy) {
gf_list_del(st->backs);
gf_list_del(st->views);
group_2d_destroy(node, (GroupingNode2D*)st);
gf_free(st);
return;
}
/*layers can only be used in a 2D context*/
#ifndef GPAC_DISABLE_3D
if (tr_state->visual->type_3d && tr_state->camera->is_3D) return;
#endif
/*layer2D maintains its own stacks*/
oldb = tr_state->backgrounds;
oldv = tr_state->viewpoints;
tr_state->backgrounds = st->backs;
tr_state->viewpoints = st->views;
prev_layer = tr_state->is_layer;
tr_state->is_layer = 1;
#ifndef GPAC_DISABLE_3D
oldf = tr_state->fogs;
oldn = tr_state->navigations;
tr_state->fogs = tr_state->navigations = NULL;
#endif
l2d_CheckBindables(node, tr_state, st->first);
back = (GF_Node*)gf_list_get(st->backs, 0);
viewport = (GF_Node*)gf_list_get(st->views, 0);
if ((tr_state->traversing_mode == TRAVERSE_SORT) || (tr_state->traversing_mode == TRAVERSE_GET_BOUNDS)) {
/*override group bounds*/
visual_get_size_info(tr_state, &st->clip.width, &st->clip.height);
/*setup bounds in local coord system*/
if (l->size.x>=0) st->clip.width = l->size.x;
if (l->size.y>=0) st->clip.height = l->size.y;
st->clip = gf_rect_center(st->clip.width, st->clip.height);
st->bounds = st->clip;
}
prev_vp = tr_state->vp_size;
tr_state->vp_size.x = st->clip.width;
tr_state->vp_size.y = st->clip.height;
switch (tr_state->traversing_mode) {
case TRAVERSE_SORT:
#ifndef GPAC_DISABLE_3D
if (tr_state->visual->type_3d) {
tr_state->layer_clipper = compositor_2d_update_clipper(tr_state, st->clip, &had_clip, &prev_clipper, 1);
visual_3d_matrix_push(tr_state->visual);
gf_mx_copy(mx3d, tr_state->model_matrix);
/*setup clipping*/
visual_3d_set_clipper_2d(tr_state->visual, tr_state->layer_clipper);
/*apply background BEFORE viewport*/
if (back) {
tr_state->traversing_mode = TRAVERSE_BINDABLE;
gf_bbox_from_rect(&tr_state->bbox, &st->clip);
gf_node_traverse(back, tr_state);
}
/*sort all children without transform, and use current transform when flushing contexts*/
gf_mx_init(tr_state->model_matrix);
/*apply viewport*/
if (viewport) {
tr_state->traversing_mode = TRAVERSE_BINDABLE;
tr_state->bounds = st->clip;
gf_node_traverse(viewport, tr_state);
visual_3d_matrix_add(tr_state->visual, tr_state->model_matrix.m);
}
node_list_backup = tr_state->visual->alpha_nodes_to_draw;
tr_state->visual->alpha_nodes_to_draw = gf_list_new();
tr_state->traversing_mode = TRAVERSE_SORT;
/*reset cull flag*/
tr_state->cull_flag = 0;
group_2d_traverse(node, (GroupingNode2D *)st, tr_state);
visual_3d_flush_contexts(tr_state->visual, tr_state);
tr_state->traversing_mode = TRAVERSE_SORT;
assert(!gf_list_count(tr_state->visual->alpha_nodes_to_draw));
gf_list_del(tr_state->visual->alpha_nodes_to_draw);
tr_state->visual->alpha_nodes_to_draw = node_list_backup;
visual_3d_matrix_pop(tr_state->visual);
gf_mx_copy(tr_state->model_matrix, mx3d);
visual_3d_reset_clipper_2d(tr_state->visual);
tr_state->has_layer_clip = had_clip;
if (had_clip) {
tr_state->layer_clipper = prev_clipper;
visual_3d_set_clipper_2d(tr_state->visual, tr_state->layer_clipper);
}
} else
#endif
{
GF_IRect prev_clip;
GF_Rect rc;
gf_mx2d_copy(backup, tr_state->transform);
prev_clip = tr_state->visual->top_clipper;
rc = st->clip;
/*get clipper in world coordinate*/
gf_mx2d_apply_rect(&tr_state->transform, &rc);
if (viewport) {
tr_state->traversing_mode = TRAVERSE_BINDABLE;
tr_state->bounds = st->clip;
gf_node_traverse(viewport, tr_state);
#if VIEWPORT_CLIPS
/*move viewport box in world coordinate*/
gf_mx2d_apply_rect(&backup, &tr_state->bounds);
/*and intersect with layer clipper*/
rect_intersect(&rc, &tr_state->bounds);
#endif
}
tr_state->visual->top_clipper = gf_rect_pixelize(&rc);
gf_irect_intersect(&tr_state->visual->top_clipper, &prev_clip);
tr_state->traversing_mode = TRAVERSE_SORT;
if (tr_state->visual->top_clipper.width && tr_state->visual->top_clipper.height) {
if (back && Bindable_GetIsBound(back) ) {
DrawableContext *ctx;
ctx = b2d_get_context((M_Background2D*) back, st->backs);
gf_mx2d_init(ctx->transform);
ctx->bi->clip = tr_state->visual->top_clipper;
ctx->bi->unclip = rc;
if (tr_state->immediate_draw) {
tr_state->ctx = ctx;
tr_state->traversing_mode = TRAVERSE_DRAW_2D;
gf_node_traverse(back, tr_state);
tr_state->traversing_mode = TRAVERSE_SORT;
tr_state->ctx = NULL;
} else {
DrawableContext *back_ctx = visual_2d_get_drawable_context(tr_state->visual);
gf_node_traverse(back, tr_state);
back_ctx->flags = ctx->flags;
back_ctx->flags &= ~CTX_IS_TRANSPARENT;
back_ctx->flags |= CTX_IS_BACKGROUND;
back_ctx->aspect = ctx->aspect;
back_ctx->drawable = ctx->drawable;
drawable_check_bounds(back_ctx, tr_state->visual);
back_ctx->bi->clip = ctx->bi->clip;
back_ctx->bi->unclip = ctx->bi->unclip;
}
/*keep track of node drawn*/
if (!(ctx->drawable->flags & DRAWABLE_REGISTERED_WITH_VISUAL) ) {
struct _drawable_store *it;
GF_SAFEALLOC(it, struct _drawable_store);
it->drawable = ctx->drawable;
if (tr_state->visual->last_prev_entry) {
tr_state->visual->last_prev_entry->next = it;
tr_state->visual->last_prev_entry = it;
} else {
tr_state->visual->prev_nodes = tr_state->visual->last_prev_entry = it;
}
GF_LOG(GF_LOG_DEBUG, GF_LOG_COMPOSE, ("[Layer2D] Registering new drawn node %s on visual\n", gf_node_get_class_name(it->drawable->node)));
ctx->drawable->flags |= DRAWABLE_REGISTERED_WITH_VISUAL;
}
}
group_2d_traverse(node, (GroupingNode2D *)st, tr_state);
}
tr_state->visual->top_clipper = prev_clip;
gf_mx2d_copy(tr_state->transform, backup);
}
break;
/*check picking - we must fall in our 2D clipper*/
case TRAVERSE_PICK:
if (gf_sc_pick_in_clipper(tr_state, &st->clip)) {
#ifndef GPAC_DISABLE_3D
if (tr_state->visual->type_3d) {
/*apply viewport*/
if (viewport) {
gf_mx_copy(mx3d, tr_state->model_matrix);
tr_state->traversing_mode = TRAVERSE_BINDABLE;
tr_state->bounds = st->clip;
gf_node_traverse(viewport, tr_state);
tr_state->traversing_mode = TRAVERSE_PICK;
group_2d_traverse(node, (GroupingNode2D *)st, tr_state);
gf_mx_copy(tr_state->model_matrix, mx3d);
} else {
group_2d_traverse(node, (GroupingNode2D *)st, tr_state);
}
} else
#endif
{
if (viewport) {
gf_mx2d_copy(backup, tr_state->transform);
tr_state->traversing_mode = TRAVERSE_BINDABLE;
tr_state->bounds = st->clip;
gf_node_traverse(viewport, tr_state);
tr_state->traversing_mode = TRAVERSE_PICK;
group_2d_traverse(node, (GroupingNode2D *)st, tr_state);
gf_mx2d_copy(tr_state->transform, backup);
} else {
group_2d_traverse(node, (GroupingNode2D *)st, tr_state);
}
}
}
break;
case TRAVERSE_GET_BOUNDS:
if (tr_state->for_node) {
group_2d_traverse(node, (GroupingNode2D *)st, tr_state);
} else {
tr_state->bounds = st->clip;
#ifndef GPAC_DISABLE_3D
gf_bbox_from_rect(&tr_state->bbox, &st->clip);
#endif
}
break;
case TRAVERSE_DRAW_2D:
group_2d_traverse(node, (GroupingNode2D *)st, tr_state);
break;
#ifndef GPAC_DISABLE_3D
/*drawing a layer means drawing all sub-elements as a whole (no depth sorting with parents)*/
case TRAVERSE_DRAW_3D:
assert(0);
break;
#endif
}
/*restore traversing state*/
tr_state->vp_size = prev_vp;
tr_state->backgrounds = oldb;
tr_state->viewpoints = oldv;
tr_state->is_layer = prev_layer;
#ifndef GPAC_DISABLE_3D
tr_state->fogs = oldf;
tr_state->navigations = oldn;
#endif
/*in case we missed bindables*/
if (st->first) {
st->first = 0;
gf_sc_invalidate(tr_state->visual->compositor, NULL);
}
}
/*
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);
}
static void svg_recompute_viewport_transformation(GF_Node *node, SVGsvgStack *stack, GF_TraverseState *tr_state, SVGAllAttributes *atts)
{
GF_Matrix2D mx;
SVG_ViewBox ext_vb, *vb;
SVG_PreserveAspectRatio par;
Fixed scale, vp_w, vp_h;
Fixed parent_width, parent_height, doc_width, doc_height;
/*canvas size negociation has already been done when attaching the scene to the compositor*/
if (atts->width && (atts->width->type==SVG_NUMBER_PERCENTAGE) ) {
parent_width = gf_mulfix(tr_state->vp_size.x, atts->width->value/100);
doc_width = 0;
} else if (!stack->root_svg) {
doc_width = parent_width = atts->width ? atts->width->value : 0;
} else {
parent_width = tr_state->vp_size.x;
doc_width = atts->width ? atts->width->value : 0;
}
if (atts->height && (atts->height->type==SVG_NUMBER_PERCENTAGE) ) {
parent_height = gf_mulfix(tr_state->vp_size.y, atts->height->value/100);
doc_height = 0;
} else if (!stack->root_svg) {
doc_height = parent_height = atts->height ? atts->height->value : 0;
} else {
parent_height = tr_state->vp_size.y;
doc_height = atts->height ? atts->height->value : 0;
}
stack->vp = stack->parent_vp = tr_state->vp_size;
vb = atts->viewBox;
gf_mx2d_init(mx);
if (stack->root_svg) {
const char *frag_uri = gf_scene_get_fragment_uri(node);
if (frag_uri) {
/*SVGView*/
if (!strncmp(frag_uri, "svgView", 7)) {
if (!strncmp(frag_uri, "svgView(viewBox(", 16)) {
Float x, y, w, h;
sscanf(frag_uri, "svgView(viewBox(%f,%f,%f,%f))", &x, &y, &w, &h);
ext_vb.x = FLT2FIX(x);
ext_vb.y = FLT2FIX(y);
ext_vb.width = FLT2FIX(w);
ext_vb.height = FLT2FIX(h);
ext_vb.is_set = 1;
vb = &ext_vb;
}
else if (!strncmp(frag_uri, "svgView(transform(", 18)) {
Bool ret = gf_svg_parse_transformlist(&mx, (char *) frag_uri+18);
if (!ret) {
GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("[SVG Parsing] Error parsing SVG View transform component: %s\n", frag_uri+18));
}
}
}
/*fragID*/
else {
GF_Node *target = gf_sg_find_node_by_name(gf_node_get_graph(node), (char *) frag_uri);
if (target) {
GF_Matrix2D mx;
GF_TraverseState bounds_state;
memset(&bounds_state, 0, sizeof(bounds_state));
bounds_state.traversing_mode = TRAVERSE_GET_BOUNDS;
bounds_state.visual = tr_state->visual;
bounds_state.for_node = target;
bounds_state.svg_props = tr_state->svg_props;
gf_mx2d_init(bounds_state.transform);
gf_mx2d_init(bounds_state.mx_at_node);
gf_mx_init(tr_state->visual->compositor->hit_world_to_local);
gf_sc_get_nodes_bounds(node, ((GF_ParentNode *)node)->children, &bounds_state, NULL);
gf_mx2d_from_mx(&mx, &tr_state->visual->compositor->hit_world_to_local);
gf_mx2d_apply_rect(&mx, &bounds_state.bounds);
ext_vb.x = bounds_state.bounds.x;
ext_vb.y = bounds_state.bounds.y-bounds_state.bounds.height;
ext_vb.width = bounds_state.bounds.width;
ext_vb.height = bounds_state.bounds.height;
ext_vb.is_set = 1;
vb = &ext_vb;
}
}
}
}
gf_mx2d_init(stack->viewbox_mx);
if (!vb) {
if (!doc_width || !doc_height) {
gf_mx2d_copy(stack->viewbox_mx, mx);
return;
}
/*width/height were specified in the doc, use them to compute a dummy viewbox*/
ext_vb.x = 0;
ext_vb.y = 0;
ext_vb.width = doc_width;
ext_vb.height = doc_height;
ext_vb.is_set = 1;
vb = &ext_vb;
}
if ((vb->width<=0) || (vb->height<=0) ) {
gf_mx2d_copy(stack->viewbox_mx, mx);
return;
}
stack->vp.x = vb->width;
stack->vp.y = vb->height;
/*setup default*/
par.defer = 0;
par.meetOrSlice = SVG_MEETORSLICE_MEET;
par.align = SVG_PRESERVEASPECTRATIO_XMIDYMID;
/*use parent (animation, image) viewport settings*/
if (tr_state->parent_anim_atts) {
if (tr_state->parent_anim_atts->preserveAspectRatio) {
if (tr_state->parent_anim_atts->preserveAspectRatio->defer) {
if (atts->preserveAspectRatio)
par = *atts->preserveAspectRatio;
} else {
par = *tr_state->parent_anim_atts->preserveAspectRatio;
}
}
}
/*use current viewport settings*/
else if (atts->preserveAspectRatio) {
par = *atts->preserveAspectRatio;
}
if (par.meetOrSlice==SVG_MEETORSLICE_MEET) {
if (gf_divfix(parent_width, vb->width) > gf_divfix(parent_height, vb->height)) {
scale = gf_divfix(parent_height, vb->height);
vp_w = gf_mulfix(vb->width, scale);
vp_h = parent_height;
} else {
scale = gf_divfix(parent_width, vb->width);
vp_w = parent_width;
vp_h = gf_mulfix(vb->height, scale);
}
} else {
if (gf_divfix(parent_width, vb->width) < gf_divfix(parent_height, vb->height)) {
scale = gf_divfix(parent_height, vb->height);
vp_w = gf_mulfix(vb->width, scale);
vp_h = parent_height;
} else {
scale = gf_divfix(parent_width, vb->width);
vp_w = parent_width;
vp_h = gf_mulfix(vb->height, scale);
}
}
if (par.align==SVG_PRESERVEASPECTRATIO_NONE) {
stack->viewbox_mx.m[0] = gf_divfix(parent_width, vb->width);
stack->viewbox_mx.m[4] = gf_divfix(parent_height, vb->height);
stack->viewbox_mx.m[2] = - gf_muldiv(vb->x, parent_width, vb->width);
stack->viewbox_mx.m[5] = - gf_muldiv(vb->y, parent_height, vb->height);
} else {
Fixed dx, dy;
stack->viewbox_mx.m[0] = stack->viewbox_mx.m[4] = scale;
stack->viewbox_mx.m[2] = - gf_mulfix(vb->x, scale);
stack->viewbox_mx.m[5] = - gf_mulfix(vb->y, scale);
dx = dy = 0;
switch (par.align) {
case SVG_PRESERVEASPECTRATIO_XMINYMIN:
break;
case SVG_PRESERVEASPECTRATIO_XMIDYMIN:
dx = ( parent_width - vp_w) / 2;
break;
case SVG_PRESERVEASPECTRATIO_XMAXYMIN:
dx = parent_width - vp_w;
break;
case SVG_PRESERVEASPECTRATIO_XMINYMID:
dy = ( parent_height - vp_h) / 2;
break;
case SVG_PRESERVEASPECTRATIO_XMIDYMID:
dx = ( parent_width - vp_w) / 2;
dy = ( parent_height - vp_h) / 2;
break;
case SVG_PRESERVEASPECTRATIO_XMAXYMID:
dx = parent_width - vp_w;
dy = ( parent_height - vp_h) / 2;
break;
case SVG_PRESERVEASPECTRATIO_XMINYMAX:
dy = parent_height - vp_h;
break;
case SVG_PRESERVEASPECTRATIO_XMIDYMAX:
dx = (parent_width - vp_w) / 2;
dy = parent_height - vp_h;
break;
case SVG_PRESERVEASPECTRATIO_XMAXYMAX:
dx = parent_width - vp_w;
dy = parent_height - vp_h;
break;
}
gf_mx2d_add_translation(&stack->viewbox_mx, dx, dy);
stack->dx = dx;
stack->dy = dy;
stack->vpw = vp_w;
stack->vph = vp_h;
/*we need a clipper*/
if (stack->root_svg && !tr_state->parent_anim_atts && (par.meetOrSlice==SVG_MEETORSLICE_SLICE)) {
GF_Rect rc;
rc.width = parent_width;
rc.height = parent_height;
if (!stack->root_svg) {
rc.x = 0;
rc.y = parent_height;
gf_mx2d_apply_rect(&stack->viewbox_mx, &rc);
} else {
rc.x = dx;
rc.y = dy + parent_height;
}
// tr_state->visual->top_clipper = gf_rect_pixelize(&rc);
}
}
gf_mx2d_add_matrix(&stack->viewbox_mx, &mx);
}
void gf_sc_get_nodes_bounds(GF_Node *self, GF_ChildNodeItem *children, GF_TraverseState *tr_state, s32 *child_idx)
{
u32 i;
SFVec2f size;
GF_Rect rc;
GF_Matrix2D cur_mx;
if (tr_state->abort_bounds_traverse) {
if (self == tr_state->for_node) {
gf_mx2d_pre_multiply(&tr_state->mx_at_node, &tr_state->transform);
}
tr_state->abort_bounds_traverse=0;
gf_sc_get_nodes_bounds(self, children, tr_state, child_idx);
tr_state->abort_bounds_traverse=1;
return;
}
if (!children) return;
size.x = size.y = -FIX_ONE;
#ifndef GPAC_DISABLE_VRML
switch (gf_node_get_tag(self)) {
case TAG_MPEG4_Layer2D: size = ((M_Layer2D *)self)->size; break;
case TAG_MPEG4_Layer3D: size = ((M_Layer3D *)self)->size; break;
case TAG_MPEG4_Form: size = ((M_Form *)self)->size; break;
}
#endif
if ((size.x>=0) && (size.y>=0)) {
tr_state->bounds = gf_rect_center(size.x, size.y);
return;
}
gf_mx2d_copy(cur_mx, tr_state->transform);
rc = gf_rect_center(0,0);
i = 0;
while (children) {
if (child_idx && (i != (u32) *child_idx)) {
children = children->next;
continue;
}
gf_mx2d_init(tr_state->transform);
tr_state->bounds = gf_rect_center(0,0);
/*we hit the target node*/
if (children->node == tr_state->for_node)
tr_state->abort_bounds_traverse = 1;
gf_node_traverse(children->node, tr_state);
if (tr_state->abort_bounds_traverse) {
gf_mx2d_add_matrix(&tr_state->mx_at_node, &cur_mx);
return;
}
gf_mx2d_apply_rect(&tr_state->transform, &tr_state->bounds);
gf_rect_union(&rc, &tr_state->bounds);
children = children->next;
if (child_idx)
break;
}
#ifndef GPAC_DISABLE_SVG
if (gf_node_get_tag(self)==TAG_SVG_use) {
GF_FieldInfo info;
if (gf_node_get_attribute_by_tag(self, TAG_XLINK_ATT_href, 0, 0, &info)==GF_OK) {
GF_Node *iri = ((XMLRI*)info.far_ptr)->target;
if (iri) {
gf_mx2d_init(tr_state->transform);
tr_state->bounds = gf_rect_center(0,0);
/*we hit the target node*/
if (iri == tr_state->for_node)
tr_state->abort_bounds_traverse = 1;
gf_node_traverse(iri, tr_state);
if (tr_state->abort_bounds_traverse) {
gf_mx2d_pre_multiply(&tr_state->mx_at_node, &cur_mx);
return;
}
gf_mx2d_apply_rect(&tr_state->transform, &tr_state->bounds);
gf_rect_union(&rc, &tr_state->bounds);
}
}
}
#endif
gf_mx2d_copy(tr_state->transform, cur_mx);
if (self != tr_state->for_node) {
gf_mx2d_apply_rect(&tr_state->transform, &rc);
}
tr_state->bounds = rc;
}
/* Set the viewport of the renderer based on the element that contains a viewport
TODO: change the SVG_SANI_svgElement into an element that has a viewport (more generic)
*/
static void gf_svg_sani_set_viewport_transformation(RenderEffect2D *eff, SVG_SANI_svgElement *svg, Bool is_root)
{
GF_Matrix2D mat;
Fixed real_width, real_height;
gf_mx2d_init(mat);
if (is_root) {
u32 scene_width = eff->surface->render->compositor->scene_width;
u32 scene_height = eff->surface->render->compositor->scene_height;
u32 dpi = 90; /* Should retrieve the dpi from the system */
switch (svg->width.type) {
case SVG_NUMBER_VALUE:
case SVG_NUMBER_PX:
real_width = INT2FIX(scene_width);
break;
case SVG_NUMBER_PERCENTAGE:
/*u32 * fixed / u32*/
real_width = scene_width*svg->width.value/100;
break;
case SVG_NUMBER_IN:
real_width = dpi * svg->width.value;
break;
case SVG_NUMBER_CM:
real_width = gf_mulfix(dpi*FLT2FIX(0.39), svg->width.value);
break;
case SVG_NUMBER_MM:
real_width = gf_mulfix(dpi*FLT2FIX(0.039), svg->width.value);
break;
case SVG_NUMBER_PT:
real_width = dpi/12 * svg->width.value;
break;
case SVG_NUMBER_PC:
real_width = dpi/6 * svg->width.value;
break;
default:
real_width = INT2FIX(scene_width);
break;
}
switch (svg->height.type) {
case SVG_NUMBER_VALUE:
case SVG_NUMBER_PX:
real_height = INT2FIX(scene_height);
break;
case SVG_NUMBER_PERCENTAGE:
real_height = scene_height*svg->height.value/100;
break;
case SVG_NUMBER_IN:
real_height = dpi * svg->height.value;
break;
case SVG_NUMBER_CM:
real_height = gf_mulfix(dpi*FLT2FIX(0.39), svg->height.value);
break;
case SVG_NUMBER_MM:
real_height = gf_mulfix(dpi*FLT2FIX(0.039), svg->height.value);
break;
case SVG_NUMBER_PT:
real_height = dpi/12 * svg->height.value;
break;
case SVG_NUMBER_PC:
real_height = dpi/6 * svg->height.value;
break;
default:
real_height = INT2FIX(scene_height);
break;
}
} else {
real_width = real_height = 0;
switch (svg->width.type) {
case SVG_NUMBER_VALUE:
case SVG_NUMBER_PX:
real_width = svg->width.value;
break;
default:
break;
}
switch (svg->height.type) {
case SVG_NUMBER_VALUE:
case SVG_NUMBER_PX:
real_height = svg->height.value;
break;
default:
break;
}
}
if (!real_width || !real_height) return;
if (svg->viewBox.is_set && svg->viewBox.width != 0 && svg->viewBox.height != 0) {
Fixed scale, vp_w, vp_h;
if (svg->preserveAspectRatio.meetOrSlice==SVG_MEETORSLICE_MEET) {
if (gf_divfix(real_width, svg->viewBox.width) > gf_divfix(real_height, svg->viewBox.height)) {
scale = gf_divfix(real_height, svg->viewBox.height);
vp_w = gf_mulfix(svg->viewBox.width, scale);
vp_h = real_height;
} else {
scale = gf_divfix(real_width, svg->viewBox.width);
vp_w = real_width;
vp_h = gf_mulfix(svg->viewBox.height, scale);
}
} else {
if (gf_divfix(real_width, svg->viewBox.width) < gf_divfix(real_height, svg->viewBox.height)) {
scale = gf_divfix(real_height, svg->viewBox.height);
vp_w = gf_mulfix(svg->viewBox.width, scale);
vp_h = real_height;
} else {
scale = gf_divfix(real_width, svg->viewBox.width);
vp_w = real_width;
vp_h = gf_mulfix(svg->viewBox.height, scale);
}
}
if (svg->preserveAspectRatio.align==SVG_PRESERVEASPECTRATIO_NONE) {
mat.m[0] = gf_divfix(real_width, svg->viewBox.width);
mat.m[4] = gf_divfix(real_height, svg->viewBox.height);
mat.m[2] = - gf_muldiv(svg->viewBox.x, real_width, svg->viewBox.width);
mat.m[5] = - gf_muldiv(svg->viewBox.y, real_height, svg->viewBox.height);
} else {
Fixed dx, dy;
mat.m[0] = mat.m[4] = scale;
mat.m[2] = - gf_mulfix(svg->viewBox.x, scale);
mat.m[5] = - gf_mulfix(svg->viewBox.y, scale);
dx = dy = 0;
switch (svg->preserveAspectRatio.align) {
case SVG_PRESERVEASPECTRATIO_XMINYMIN:
break;
case SVG_PRESERVEASPECTRATIO_XMIDYMIN:
dx = ( real_width - vp_w) / 2;
break;
case SVG_PRESERVEASPECTRATIO_XMAXYMIN:
dx = real_width - vp_w;
break;
case SVG_PRESERVEASPECTRATIO_XMINYMID:
dy = ( real_height - vp_h) / 2;
break;
case SVG_PRESERVEASPECTRATIO_XMIDYMID:
dx = ( real_width - vp_w) / 2;
dy = ( real_height - vp_h) / 2;
break;
case SVG_PRESERVEASPECTRATIO_XMAXYMID:
dx = real_width - vp_w;
dy = ( real_height - vp_h) / 2;
break;
case SVG_PRESERVEASPECTRATIO_XMINYMAX:
dy = real_height - vp_h;
break;
case SVG_PRESERVEASPECTRATIO_XMIDYMAX:
dx = (real_width - vp_w) / 2;
dy = real_height - vp_h;
break;
case SVG_PRESERVEASPECTRATIO_XMAXYMAX:
dx = real_width - vp_w;
dy = real_height - vp_h;
break;
}
mat.m[2] += dx;
mat.m[5] += dy;
/*we need a clipper*/
if (svg->preserveAspectRatio.meetOrSlice==SVG_MEETORSLICE_SLICE) {
GF_Rect rc;
rc.width = real_width;
rc.height = real_height;
if (!is_root) {
rc.x = 0;
rc.y = real_height;
gf_mx2d_apply_rect(&eff->vb_transform, &rc);
} else {
rc.x = dx;
rc.y = dy + real_height;
}
eff->surface->top_clipper = gf_rect_pixelize(&rc);
}
}
}
gf_mx2d_pre_multiply(&eff->vb_transform, &mat);
}
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;
}
static void svg_traverse_resource(GF_Node *node, void *rs, Bool is_destroy, Bool is_foreign_object)
{
GF_Matrix2D backup_matrix;
GF_Matrix mx_3d;
GF_Matrix2D translate;
SVGPropertiesPointers backup_props;
u32 backup_flags, dirty;
Bool is_fragment;
GF_Node *used_node;
GF_TraverseState *tr_state = (GF_TraverseState *)rs;
SVGAllAttributes all_atts;
SVGlinkStack *stack = gf_node_get_private(node);
SFVec2f prev_vp;
SVG_Number *prev_opacity;
if (is_destroy) {
if (stack->resource) gf_mo_unload_xlink_resource(node, stack->resource);
gf_free(stack);
return;
}
gf_svg_flatten_attributes((SVG_Element *)node, &all_atts);
if (!all_atts.xlink_href) return;
if (!compositor_svg_traverse_base(node, &all_atts, tr_state, &backup_props, &backup_flags))
return;
dirty = gf_node_dirty_get(node);
if (dirty & GF_SG_CHILD_DIRTY) drawable_reset_group_highlight(tr_state, node);
if (dirty & GF_SG_SVG_XLINK_HREF_DIRTY) {
stack->fragment_id = NULL;
stack->inline_sg = NULL;
if (all_atts.xlink_href->string && (all_atts.xlink_href->string[0]=='#')) {
stack->fragment_id = all_atts.xlink_href->string;
stack->inline_sg = gf_node_get_graph(node);
} else {
GF_MediaObject *new_res = gf_mo_load_xlink_resource(node, is_foreign_object, 0, -1);
if (new_res != stack->resource) {
if (stack->resource) gf_mo_unload_xlink_resource(node, stack->resource);
stack->resource = new_res;
}
}
}
gf_node_dirty_clear(node, 0);
/*locate the used node - this is done at each step to handle progressive loading*/
is_fragment = 0;
used_node = NULL;
if (!stack->inline_sg && !stack->fragment_id && all_atts.xlink_href) {
if (all_atts.xlink_href->type == XMLRI_ELEMENTID) {
used_node = all_atts.xlink_href->target;
is_fragment = 1;
} else if (stack->resource) {
stack->inline_sg = gf_mo_get_scenegraph(stack->resource);
if (!is_foreign_object) {
stack->fragment_id = strchr(all_atts.xlink_href->string, '#');
}
}
}
if (!used_node && stack->inline_sg) {
if (stack->fragment_id) {
used_node = gf_sg_find_node_by_name(stack->inline_sg, (char *) stack->fragment_id+1);
is_fragment = 1;
} else if (is_foreign_object) {
used_node = gf_sg_get_root_node(stack->inline_sg);
}
}
if (!used_node) goto end;
/*stack use nodes for picking*/
gf_list_add(tr_state->use_stack, used_node);
gf_list_add(tr_state->use_stack, node);
gf_mx2d_init(translate);
translate.m[2] = (all_atts.x ? all_atts.x->value : 0);
translate.m[5] = (all_atts.y ? all_atts.y->value : 0);
/*update VP size (SVG 1.1)*/
prev_vp = tr_state->vp_size;
if (all_atts.width && all_atts.height) {
tr_state->vp_size.x = gf_sc_svg_convert_length_to_display(tr_state->visual->compositor, all_atts.width);
tr_state->vp_size.y = gf_sc_svg_convert_length_to_display(tr_state->visual->compositor, all_atts.height);
}
prev_opacity = tr_state->parent_use_opacity;
tr_state->parent_use_opacity = all_atts.opacity;
if (tr_state->traversing_mode == TRAVERSE_GET_BOUNDS) {
compositor_svg_apply_local_transformation(tr_state, &all_atts, &backup_matrix, &mx_3d);
if (!compositor_svg_is_display_off(tr_state->svg_props)) {
gf_node_traverse(used_node, tr_state);
gf_mx2d_apply_rect(&translate, &tr_state->bounds);
}
compositor_svg_restore_parent_transformation(tr_state, &backup_matrix, &mx_3d);
}
/*SORT mode and visible, traverse*/
else 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);
#ifndef GPAC_DISABLE_3D
if (tr_state->visual->type_3d) {
gf_mx_add_matrix_2d(&tr_state->model_matrix, &translate);
if (tr_state->traversing_mode==TRAVERSE_SORT) {
GF_Matrix tmp;
gf_mx_from_mx2d(&tmp, &translate);
visual_3d_matrix_add(tr_state->visual, tmp.m);
}
} else
#endif
gf_mx2d_pre_multiply(&tr_state->transform, &translate);
drawable_check_focus_highlight(node, tr_state, NULL);
if (is_fragment) {
gf_node_traverse(used_node, tr_state);
} else {
gf_sc_traverse_subscene(tr_state->visual->compositor, node, stack->inline_sg, tr_state);
}
compositor_svg_restore_parent_transformation(tr_state, &backup_matrix, &mx_3d);
}
gf_list_rem_last(tr_state->use_stack);
gf_list_rem_last(tr_state->use_stack);
tr_state->vp_size = prev_vp;
tr_state->parent_use_opacity = prev_opacity;
end:
memcpy(tr_state->svg_props, &backup_props, sizeof(SVGPropertiesPointers));
tr_state->svg_flags = backup_flags;
}
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_animation(GF_Node *node, void *rs, Bool is_destroy)
{
SVGAllAttributes all_atts;
GF_Matrix2D backup_matrix;
GF_Matrix backup_matrix3d;
SVGPropertiesPointers backup_props;
u32 backup_flags;
SFVec2f prev_vp;
GF_Rect rc;
GF_IRect clip, prev_clip;
SVGAllAttributes *prev_vp_atts;
GF_TraverseState *tr_state = (GF_TraverseState*)rs;
GF_Matrix2D translate;
SVGPropertiesPointers *old_props;
SVGlinkStack *stack = gf_node_get_private(node);
if (is_destroy) {
if (stack->resource) gf_mo_unload_xlink_resource(node, stack->resource);
gf_free(stack);
return;
}
gf_svg_flatten_attributes((SVG_Element *)node, &all_atts);
if (!stack->inline_sg && !stack->resource) {
if (!stack->init_vis_state) {
if (all_atts.initialVisibility && (*all_atts.initialVisibility==SVG_INITIALVISIBILTY_ALWAYS)) {
stack->init_vis_state = 2;
svg_animation_smil_update(node, stack, 0);
} else {
stack->init_vis_state = 1;
}
}
if (!stack->inline_sg && !stack->resource)
return;
}
if (!all_atts.width || !all_atts.height) return;
if (!all_atts.width->value || !all_atts.height->value) return;
if (!compositor_svg_traverse_base(node, &all_atts, tr_state, &backup_props, &backup_flags))
return;
if (compositor_svg_is_display_off(tr_state->svg_props) ||
*(tr_state->svg_props->visibility) == SVG_VISIBILITY_HIDDEN) {
goto end;
}
compositor_svg_apply_local_transformation(tr_state, &all_atts, &backup_matrix, &backup_matrix3d);
/*add x/y translation*/
gf_mx2d_init(translate);
translate.m[2] = (all_atts.x ? all_atts.x->value : 0);
translate.m[5] = (all_atts.y ? all_atts.y->value : 0);
#ifndef GPAC_DISABLE_3D
if (tr_state->visual->type_3d) {
gf_mx_add_matrix_2d(&tr_state->model_matrix, &translate);
if (tr_state->traversing_mode==TRAVERSE_SORT) {
GF_Matrix tmp;
gf_mx_from_mx2d(&tmp, &translate);
visual_3d_matrix_add(tr_state->visual, tmp.m);
}
} else
#endif
gf_mx2d_pre_multiply(&tr_state->transform, &translate);
/*reset SVG props to reload a new inheritance context*/
old_props = tr_state->svg_props;
tr_state->svg_props = NULL;
/*store this node's attribute to compute PAR/ViewBox of the child <svg>*/
prev_vp_atts = tr_state->parent_anim_atts;
tr_state->parent_anim_atts = &all_atts;
/*update VP size*/
prev_vp = tr_state->vp_size;
tr_state->vp_size.x = gf_sc_svg_convert_length_to_display(tr_state->visual->compositor, all_atts.width);
tr_state->vp_size.y = gf_sc_svg_convert_length_to_display(tr_state->visual->compositor, all_atts.height);
/*setup new clipper*/
rc.width = tr_state->vp_size.x;
rc.height = tr_state->vp_size.y;
rc.x = 0;
rc.y = tr_state->vp_size.y;
gf_mx2d_apply_rect(&tr_state->transform, &rc);
prev_clip = tr_state->visual->top_clipper;
clip = gf_rect_pixelize(&rc);
// gf_irect_intersect(&tr_state->visual->top_clipper, &clip);
if (!stack->inline_sg && stack->resource) {
stack->inline_sg = gf_mo_get_scenegraph(stack->resource);
}
if (stack->inline_sg) {
gf_sc_traverse_subscene(tr_state->visual->compositor, node, stack->inline_sg, tr_state);
}
if (stack->init_vis_state == 2) {
stack->init_vis_state = 3;
gf_mo_pause(stack->resource);
}
tr_state->svg_props = old_props;
tr_state->visual->top_clipper = prev_clip;
tr_state->parent_anim_atts = prev_vp_atts;
tr_state->vp_size = prev_vp;
compositor_svg_restore_parent_transformation(tr_state, &backup_matrix, &backup_matrix3d);
end:
memcpy(tr_state->svg_props, &backup_props, sizeof(SVGPropertiesPointers));
tr_state->svg_flags = backup_flags;
}
