static void svg_sani_render_path(GF_Node *node, void *rs, Bool is_destroy)
{
SVG_SANI_pathElement *path = (SVG_SANI_pathElement *)node;
Drawable *cs = (Drawable *)gf_node_get_private(node);
RenderEffect2D *eff = (RenderEffect2D *)rs;
if (is_destroy) {
svg_sani_destroy_path(node);
return;
}
if (eff->traversing_mode==TRAVERSE_DRAW) {
drawable_draw(eff);
return;
}
else if (eff->traversing_mode==TRAVERSE_PICK) {
drawable_pick(eff);
return;
}
svg_sani_render_base(node, eff);
if (gf_node_dirty_get(node) & GF_SG_SVG_GEOMETRY_DIRTY) {
#if USE_GF_PATH
cs->path = &path->d;
#else
drawable_reset_path(cs);
gf_svg_path_build(cs->path, path->d.commands, path->d.points);
#endif
if (path->fill_rule==GF_PATH_FILL_ZERO_NONZERO) cs->path->flags |= GF_PATH_FILL_ZERO_NONZERO;
gf_node_dirty_clear(node, GF_SG_SVG_GEOMETRY_DIRTY);
cs->flags |= DRAWABLE_HAS_CHANGED;
}
svg_sani_DrawablePostRender(cs, (SVG_SANI_TransformableElement *)path, eff, 0, (path->pathLength.type==SVG_NUMBER_VALUE) ? path->pathLength.value : 0);
}
static void svg_sani_render_line(GF_Node *node, void *rs, Bool is_destroy)
{
SVG_SANI_lineElement *line = (SVG_SANI_lineElement *)node;
Drawable *cs = (Drawable *)gf_node_get_private(node);
RenderEffect2D *eff = (RenderEffect2D *)rs;
if (is_destroy) {
DestroyDrawableNode(node);
return;
}
if (eff->traversing_mode==TRAVERSE_DRAW) {
drawable_draw(eff);
return;
}
else if (eff->traversing_mode==TRAVERSE_PICK) {
drawable_pick(eff);
return;
}
svg_sani_render_base(node, (RenderEffect2D *)rs);
if (gf_node_dirty_get(node) & GF_SG_SVG_GEOMETRY_DIRTY) {
drawable_reset_path(cs);
gf_path_add_move_to(cs->path, line->x1.value, line->y1.value);
gf_path_add_line_to(cs->path, line->x2.value, line->y2.value);
gf_node_dirty_clear(node, GF_SG_SVG_GEOMETRY_DIRTY);
cs->flags |= DRAWABLE_HAS_CHANGED;
}
svg_sani_DrawablePostRender(cs, (SVG_SANI_TransformableElement *)line, (RenderEffect2D *)rs, 0, 0);
}
static void svg_sani_render_polygon(GF_Node *node, void *rs, Bool is_destroy)
{
SVG_SANI_polygonElement *polygon = (SVG_SANI_polygonElement *)node;
Drawable *cs = (Drawable *)gf_node_get_private(node);
RenderEffect2D *eff = (RenderEffect2D *)rs;
if (is_destroy) {
DestroyDrawableNode(node);
return;
}
if (eff->traversing_mode==TRAVERSE_DRAW) {
drawable_draw(eff);
return;
}
else if (eff->traversing_mode==TRAVERSE_PICK) {
drawable_pick(eff);
return;
}
svg_sani_render_base(node, (RenderEffect2D *)rs);
if (gf_node_dirty_get(node) & GF_SG_SVG_GEOMETRY_DIRTY) {
u32 i;
u32 nbPoints = gf_list_count(polygon->points);
drawable_reset_path(cs);
if (nbPoints) {
SVG_Point *p = (SVG_Point *)gf_list_get(polygon->points, 0);
gf_path_add_move_to(cs->path, p->x, p->y);
for (i = 1; i < nbPoints; i++) {
p = (SVG_Point *)gf_list_get(polygon->points, i);
gf_path_add_line_to(cs->path, p->x, p->y);
}
gf_path_close(cs->path);
} else {
gf_path_add_move_to(cs->path, 0, 0);
}
gf_node_dirty_clear(node, GF_SG_SVG_GEOMETRY_DIRTY);
cs->flags |= DRAWABLE_HAS_CHANGED;
}
svg_sani_DrawablePostRender(cs, (SVG_SANI_TransformableElement *)polygon, (RenderEffect2D *)rs, 0, 0);
}
Bool visual_2d_terminate_draw(GF_VisualManager *visual, GF_TraverseState *tr_state)
{
u32 k, i, count, num_nodes, num_changed;
GF_IRect refreshRect;
Bool redraw_all;
Bool hyb_force_redraw=GF_FALSE;
#ifndef GPAC_DISABLE_VRML
M_Background2D *bck = NULL;
DrawableContext *bck_ctx = NULL;
#endif
DrawableContext *ctx;
struct _drawable_store *it, *prev;
DrawableContext *first_opaque = NULL;
Bool has_clear = 0;
Bool has_changed = 0;
Bool redraw_all_on_background_change = GF_TRUE;
/*in direct mode the visual is always redrawn*/
if (tr_state->immediate_draw) {
/*flush pending contexts due to overlays*/
visual_2d_flush_overlay_areas(visual, tr_state);
visual_2d_release_raster(visual);
visual_clean_contexts(visual);
visual->num_nodes_prev_frame = visual->num_nodes_current_frame;
return 1;
}
num_changed = 0;
/*if the aspect ratio has changed redraw everything*/
redraw_all = tr_state->invalidate_all;
#ifndef GPAC_DISABLE_3D
if (visual->compositor->hybrid_opengl && !visual->offscreen) redraw_all_on_background_change = GF_FALSE;
#endif
/*check for background changes for transparent nodes*/
#ifndef GPAC_DISABLE_VRML
bck = (M_Background2D*)gf_list_get(visual->back_stack, 0);
if (bck) {
if (!bck->isBound) {
if (visual->last_had_back) {
if (redraw_all_on_background_change) redraw_all = 1;
else hyb_force_redraw = 1;
}
visual->last_had_back = 0;
} else {
bck_ctx = b2d_get_context(bck, visual->back_stack);
if (!visual->last_had_back || (bck_ctx->flags & CTX_REDRAW_MASK) ) {
if (redraw_all_on_background_change) redraw_all = 1;
else hyb_force_redraw = 1;
}
visual->last_had_back = (bck_ctx->aspect.fill_texture && !bck_ctx->aspect.fill_texture->transparent) ? 2 : 1;
}
} else
#endif
if (visual->last_had_back) {
visual->last_had_back = 0;
if (redraw_all_on_background_change) redraw_all = 1;
else hyb_force_redraw = 1;
}
num_nodes = 0;
ctx = visual->context;
while (ctx && ctx->drawable) {
num_nodes++;
drawctx_update_info(ctx, visual);
if (!redraw_all) {
u32 res;
assert( gf_irect_inside(&visual->top_clipper, &ctx->bi->clip) );
res = register_context_rect(&visual->to_redraw, ctx, num_nodes, &first_opaque);
if (res) {
num_changed ++;
if (res==2)
hyb_force_redraw=GF_TRUE;
}
}
ctx = ctx->next;
}
/*garbage collection*/
/*clear all remaining bounds since last frames (the ones that moved or that are not drawn this frame)*/
prev = NULL;
it = visual->prev_nodes;
while (it) {
while (drawable_get_previous_bound(it->drawable, &refreshRect, visual)) {
if (!redraw_all) {
//assert( gf_irect_inside(&visual->top_clipper, &refreshRect) );
gf_irect_intersect(&refreshRect, &visual->top_clipper);
register_dirty_rect(&visual->to_redraw, &refreshRect);
has_clear=1;
}
}
/*if node is marked as undrawn, remove from visual*/
if (!(it->drawable->flags & DRAWABLE_DRAWN_ON_VISUAL)) {
GF_LOG(GF_LOG_DEBUG, GF_LOG_COMPOSE, ("[Visual2D] Node %s no longer on visual - unregistering it\n", gf_node_get_class_name(it->drawable->node)));
/*remove all bounds info related to this visual and unreg node */
drawable_reset_bounds(it->drawable, visual);
it->drawable->flags &= ~DRAWABLE_REGISTERED_WITH_VISUAL;
if (it->drawable->flags & DRAWABLE_IS_OVERLAY) {
visual->compositor->video_out->Blit(visual->compositor->video_out, NULL, NULL, NULL, 1);
}
if (prev) prev->next = it->next;
else visual->prev_nodes = it->next;
if (!it->next) visual->last_prev_entry = prev;
gf_free(it);
it = prev ? prev->next : visual->prev_nodes;
} else {
prev = it;
it = it->next;
}
}
if (redraw_all) {
ra_clear(&visual->to_redraw);
ra_add(&visual->to_redraw, &visual->surf_rect);
#ifdef TRACK_OPAQUE_REGIONS
visual->to_redraw.list[0].opaque_node_index=0;
#endif
} else {
ra_refresh(&visual->to_redraw);
if (visual->compositor->debug_defer) {
visual->ClearSurface(visual, &visual->top_clipper, 0);
}
}
/*nothing to redraw*/
if (!hyb_force_redraw && ra_is_empty(&visual->to_redraw) ) {
#ifndef GPAC_DISABLE_3D
//force canvas draw
visual->nb_objects_on_canvas_since_last_ogl_flush = 1;
#endif
GF_LOG(GF_LOG_DEBUG, GF_LOG_COMPOSE, ("[Visual2D] No changes found since last frame - skipping redraw\n"));
goto exit;
}
has_changed = 1;
tr_state->traversing_mode = TRAVERSE_DRAW_2D;
if (first_opaque && (visual->to_redraw.count==1) && gf_rect_equal(first_opaque->bi->clip, visual->to_redraw.list[0].rect)) {
visual->has_modif=0;
goto skip_background;
}
/*redraw everything*/
#ifndef GPAC_DISABLE_VRML
if (bck_ctx) {
drawable_check_bounds(bck_ctx, visual);
tr_state->ctx = bck_ctx;
visual->draw_node_index = 0;
/*force clearing entire zone, not just viewport, when using color. If texture, we MUST
use the VP clipper in order to compute offsets when blitting bitmaps*/
if (bck_ctx->aspect.fill_texture && bck_ctx->aspect.fill_texture->stream) {
bck_ctx->bi->clip = visual->top_clipper;
} else {
bck_ctx->bi->clip = visual->surf_rect;
}
bck_ctx->bi->unclip = gf_rect_ft(&bck_ctx->bi->clip);
bck_ctx->next = visual->context;
bck_ctx->flags |= CTX_BACKROUND_NOT_LAYER;
gf_node_traverse(bck_ctx->drawable->node, tr_state);
bck_ctx->flags &= ~CTX_BACKROUND_NOT_LAYER;
} else
#endif /*GPAC_DISABLE_VRML*/
{
count = visual->to_redraw.count;
for (k=0; k<count; k++) {
GF_IRect rc;
/*opaque area, skip*/
#ifdef TRACK_OPAQUE_REGIONS
if (visual->to_redraw.list[k].opaque_node_index > 0) continue;
#endif
rc = visual->to_redraw.list[k].rect;
visual->ClearSurface(visual, &rc, 0);
}
#ifndef GPAC_DISABLE_3D
if (!count && hyb_force_redraw) {
compositor_2d_hybgl_clear_surface_ex(tr_state->visual, NULL, 0, GF_FALSE);
}
#endif
}
if (!redraw_all && !has_clear) visual->has_modif=0;
skip_background:
#ifndef GPAC_DISABLE_LOG
if (gf_log_tool_level_on(GF_LOG_COMPOSE, GF_LOG_INFO)) {
GF_LOG(GF_LOG_INFO, GF_LOG_COMPOSE, ("[Visual2D] Redraw %d / %d nodes (all: %s - %d dirty rects\n)", num_changed, num_nodes, redraw_all ? "yes" : "no", visual->to_redraw.count));
if (visual->to_redraw.count>1) GF_LOG(GF_LOG_DEBUG, GF_LOG_COMPOSE, ("\n"));
for (i=0; i<visual->to_redraw.count; i++) {
GF_LOG(GF_LOG_INFO, GF_LOG_COMPOSE, ("\tDirtyRect #%d: %d:%d@%dx%d\n", i+1, visual->to_redraw.list[i].rect.x, visual->to_redraw.list[i].rect.y, visual->to_redraw.list[i].rect.width, visual->to_redraw.list[i].rect.height));
assert(visual->to_redraw.list[i].rect.width);
}
}
#endif
visual->draw_node_index = 0;
ctx = visual->context;
while (ctx && ctx->drawable) {
visual->draw_node_index ++;
tr_state->ctx = ctx;
/*if overlay we cannot remove the context and cannot draw directly*/
if (! visual_2d_overlaps_overlay(tr_state->visual, ctx, tr_state)) {
if (ctx->drawable->flags & DRAWABLE_USE_TRAVERSE_DRAW) {
gf_node_traverse(ctx->drawable->node, tr_state);
} else {
drawable_draw(ctx->drawable, tr_state);
}
}
ctx = ctx->next;
}
/*flush pending contexts due to overlays*/
visual_2d_flush_overlay_areas(visual, tr_state);
#ifndef GPAC_DISABLE_VRML
if (bck_ctx) bck_ctx->next = NULL;
#endif
if (visual->direct_flush) {
GF_DirtyRectangles dr;
u32 i;
dr.count = visual->to_redraw.count;
dr.list = gf_malloc(sizeof(GF_IRect)*dr.count);
for (i=0; i<dr.count; i++) {
dr.list[i] = visual->to_redraw.list[i].rect;
}
visual->compositor->video_out->FlushRectangles(visual->compositor->video_out, &dr);
visual->compositor->skip_flush=1;
gf_free(dr.list);
}
exit:
/*clear dirty rects*/
ra_clear(&visual->to_redraw);
visual_2d_release_raster(visual);
visual_clean_contexts(visual);
visual->num_nodes_prev_frame = visual->num_nodes_current_frame;
return has_changed;
}
static void svg_sani_render_rect(GF_Node *node, void *rs, Bool is_destroy)
{
Drawable *cs = (Drawable *)gf_node_get_private(node);
SVG_SANI_rectElement *rect = (SVG_SANI_rectElement *)node;
RenderEffect2D *eff = (RenderEffect2D *)rs;
if (is_destroy) {
DestroyDrawableNode(node);
return;
}
if (eff->traversing_mode==TRAVERSE_DRAW) {
drawable_draw(eff);
return;
}
else if (eff->traversing_mode==TRAVERSE_PICK) {
drawable_pick(eff);
return;
}
svg_sani_render_base(node, (RenderEffect2D *)rs);
/* 3) for a leaf node
Recreates the path (i.e the shape) only if the node is dirty
(has changed compared to the previous rendering phase) */
if (gf_node_dirty_get(node) & GF_SG_SVG_GEOMETRY_DIRTY) {
Fixed rx = rect->rx.value;
Fixed ry = rect->ry.value;
Fixed x = rect->x.value;
Fixed y = rect->y.value;
Fixed width = rect->width.value;
Fixed height = rect->height.value;
//fprintf(stdout, "Rebuilding rect %8x\n",rect);
drawable_reset_path(cs);
if (rx || ry) {
if (rx >= width/2) rx = width/2;
if (ry >= height/2) ry = height/2;
if (rx == 0) rx = ry;
if (ry == 0) ry = rx;
gf_path_add_move_to(cs->path, x+rx, y);
gf_path_add_line_to(cs->path, x+width-rx, y);
gf_path_add_quadratic_to(cs->path, x+width, y, x+width, y+ry);
gf_path_add_line_to(cs->path, x+width, y+height-ry);
gf_path_add_quadratic_to(cs->path, x+width, y+height, x+width-rx, y+height);
gf_path_add_line_to(cs->path, x+rx, y+height);
gf_path_add_quadratic_to(cs->path, x, y+height, x, y+height-ry);
gf_path_add_line_to(cs->path, x, y+ry);
gf_path_add_quadratic_to(cs->path, x, y, x+rx, y);
gf_path_close(cs->path);
} else {
gf_path_add_move_to(cs->path, x, y);
gf_path_add_line_to(cs->path, x+width, y);
gf_path_add_line_to(cs->path, x+width, y+height);
gf_path_add_line_to(cs->path, x, y+height);
gf_path_close(cs->path);
}
gf_node_dirty_clear(node, GF_SG_SVG_GEOMETRY_DIRTY);
cs->flags |= DRAWABLE_HAS_CHANGED;
}
svg_sani_DrawablePostRender(cs, (SVG_SANI_TransformableElement *)rect, (RenderEffect2D *)rs, 1, 0);
}
