static void TraverseILS2D(GF_Node *node, void *rs, Bool is_destroy) { DrawableContext *ctx; M_IndexedLineSet2D *ils2D = (M_IndexedLineSet2D *)node; Drawable *stack = (Drawable *)gf_node_get_private(node); GF_TraverseState *tr_state = (GF_TraverseState *)rs; if (is_destroy) { drawable_node_del(node); return; } if (!ils2D->coord) return; ils2d_check_changes(node, stack, tr_state); switch (tr_state->traversing_mode) { case TRAVERSE_DRAW_2D: ILS2D_Draw(node, tr_state); return; #ifndef GPAC_DISABLE_3D case TRAVERSE_DRAW_3D: if (!stack->mesh) { stack->mesh = new_mesh(); mesh_new_ils(stack->mesh, ils2D->coord, &ils2D->coordIndex, ils2D->color, &ils2D->colorIndex, ils2D->colorPerVertex, 0); } if (ils2D->color) { DrawAspect2D asp; memset(&asp, 0, sizeof(DrawAspect2D)); drawable_get_aspect_2d_mpeg4(node, &asp, tr_state); visual_3d_mesh_strike(tr_state, stack->mesh, asp.pen_props.width, asp.line_scale, asp.pen_props.dash); } else { 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; /*ILS2D are NEVER filled*/ ctx->aspect.fill_color &= 0x00FFFFFF; drawable_finalize_sort(ctx, tr_state, NULL); return; default: return; } }
static void TraversePointSet2D(GF_Node *node, void *rs, Bool is_destroy) { DrawableContext *ctx; M_PointSet2D *ps2D = (M_PointSet2D *)node; Drawable *stack = (Drawable *)gf_node_get_private(node); GF_TraverseState *tr_state = (GF_TraverseState *)rs; if (is_destroy) { drawable_node_del(node); return; } if (!ps2D->coord) return; pointset2d_check_changes(node, stack, tr_state); switch (tr_state->traversing_mode) { case TRAVERSE_DRAW_2D: PointSet2D_Draw(node, tr_state); return; #ifndef GPAC_DISABLE_3D case TRAVERSE_DRAW_3D: { DrawAspect2D asp; if (!stack->mesh) { stack->mesh = new_mesh(); mesh_new_ps(stack->mesh, ps2D->coord, ps2D->color); } memset(&asp, 0, sizeof(DrawAspect2D)); drawable_get_aspect_2d_mpeg4(node, &asp, tr_state); visual_3d_set_material_2d_argb(tr_state->visual, asp.fill_color); visual_3d_mesh_paint(tr_state, stack->mesh); return; } #endif case TRAVERSE_GET_BOUNDS: gf_path_get_bounds(stack->path, &tr_state->bounds); return; case TRAVERSE_PICK: 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); break; default: return; } }
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 TraverseCircle(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; } circle_check_changes(node, stack, tr_state); switch (tr_state->traversing_mode) { #ifndef GPAC_DISABLE_3D case TRAVERSE_DRAW_3D: if (!stack->mesh) { Fixed a = ((M_Circle *) node)->radius * 2; stack->mesh = new_mesh(); mesh_new_ellipse(stack->mesh, a, a, tr_state->visual->compositor->high_speed); } 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; } }
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; } }
static void TraverseRectangle(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; } rectangle_check_changes(node, stack, tr_state); switch (tr_state->traversing_mode) { case TRAVERSE_DRAW_2D: compositor_2d_draw_rectangle(tr_state); return; #ifndef GPAC_DISABLE_3D case TRAVERSE_DRAW_3D: if (!stack->mesh) { stack->mesh = new_mesh(); mesh_new_rectangle(stack->mesh, ((M_Rectangle *) node)->size, NULL, 0); } 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 break; default: return; } ctx = drawable_init_context_mpeg4(stack, tr_state); if (!ctx) return; /*if rotated, object is transparent (doesn't fill bounds) and antialias must be used*/ if (tr_state->transform.m[1] || tr_state->transform.m[3]) { } else { /*if alpha or not filled, transparent*/ if (ctx->aspect.fill_color && (GF_COL_A(ctx->aspect.fill_color) != 0xFF)) { } /*if texture transparent, transparent*/ else if (ctx->aspect.fill_texture && ctx->aspect.fill_texture->transparent) { } /*TODO check matrix for alpha*/ else if (!tr_state->color_mat.identity) { } /*otherwise, not transparent*/ else { ctx->flags &= ~CTX_IS_TRANSPARENT; } /*if no line width, we skip antialiasing*/ if (!ctx->aspect.pen_props.width) ctx->flags |= CTX_NO_ANTIALIAS; } drawable_finalize_sort(ctx, tr_state, NULL); }
static void Text_Traverse(GF_Node *n, void *rs, Bool is_destroy) { DrawableContext *ctx; M_Text *txt = (M_Text *) n; TextStack *st = (TextStack *) gf_node_get_private(n); GF_TraverseState *tr_state = (GF_TraverseState *)rs; if (is_destroy) { text_clean_paths(gf_sc_get_compositor(n), st); drawable_del(st->graph); gf_list_del(st->spans); gf_free(st); return; } if (!txt->string.count) return; if (tr_state->text_split_mode) { gf_node_dirty_clear(n, 0); text_clean_paths(tr_state->visual->compositor, st); build_text_split(st, txt, tr_state); return; } text_check_changes(n, st, tr_state); switch (tr_state->traversing_mode) { case TRAVERSE_DRAW_2D: text_draw_2d(n, tr_state); return; #ifndef GPAC_DISABLE_3D case TRAVERSE_DRAW_3D: text_draw_3d(tr_state, n, st); return; #endif case TRAVERSE_PICK: tr_state->text_parent = n; gf_font_spans_pick(n, st->spans, tr_state, &st->bounds, 0, NULL); tr_state->text_parent = NULL; return; case TRAVERSE_GET_BOUNDS: tr_state->bounds = st->bounds; return; case TRAVERSE_GET_TEXT: tr_state->text_parent = n; gf_font_spans_get_selection(n, st->spans, tr_state); tr_state->text_parent = NULL; return; case TRAVERSE_SORT: break; default: return; } #ifndef GPAC_DISABLE_3D if (tr_state->visual->type_3d) return; #endif ctx = drawable_init_context_mpeg4(st->graph, tr_state); if (!ctx) return; ctx->sub_path_index = tr_state->text_split_idx; ctx->flags |= CTX_IS_TEXT; if (!GF_COL_A(ctx->aspect.fill_color)) { /*override line join*/ ctx->aspect.pen_props.join = GF_LINE_JOIN_MITER; ctx->aspect.pen_props.cap = GF_LINE_CAP_FLAT; } /*if text selection mode, we must force redraw of the entire text span because we don't if glyphs have been (un)selected*/ if (!tr_state->immediate_draw && /*text selection on*/ (tr_state->visual->compositor->text_selection /*text sel release*/ || (tr_state->visual->compositor->store_text_state==GF_SC_TSEL_RELEASED)) ) { GF_TextSpan *span; u32 i = 0; Bool unselect = (tr_state->visual->compositor->store_text_state==GF_SC_TSEL_RELEASED) ? 1 : 0; while ((span = gf_list_enum(st->spans, &i))) { if (span->flags & GF_TEXT_SPAN_SELECTED) { if (unselect) span->flags &= ~GF_TEXT_SPAN_SELECTED; ctx->flags |= CTX_APP_DIRTY; } } } if (ctx->sub_path_index) { GF_TextSpan *span = (GF_TextSpan *)gf_list_get(st->spans, ctx->sub_path_index-1); if (span) drawable_finalize_sort(ctx, tr_state, &span->bounds); } else { drawable_finalize_sort(ctx, tr_state, &st->bounds); } }
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 TraverseTriangleSet2D(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; } triangleset2d_check_changes(node, stack, tr_state); switch (tr_state->traversing_mode) { #ifndef GPAC_DISABLE_3D case TRAVERSE_DRAW_3D: if (!stack->mesh) { SFColorRGBA col; u32 i, count, idx; GF_Vertex v1, v2, v3; X_TriangleSet2D *p = (X_TriangleSet2D *)node; stack->mesh = new_mesh(); stack->mesh->mesh_type = MESH_TRIANGLES; col.red = col.green = col.blue = 0; col.alpha = FIX_ONE; v1.color = MESH_MAKE_COL(col); v1.normal.x = v1.normal.y = 0; v1.normal.z = MESH_NORMAL_UNIT; v1.pos.z = 0; v3 = v2 = v1; count = p->vertices.count; while (count%3) count--; for (i=0; i<count; i+=3) { idx = stack->mesh->v_count; v1.pos.x = p->vertices.vals[i].x; v1.pos.y = p->vertices.vals[i].y; v2.pos.x = p->vertices.vals[i+1].x; v2.pos.y = p->vertices.vals[i+1].y; v3.pos.x = p->vertices.vals[i+2].x; v3.pos.y = p->vertices.vals[i+2].y; mesh_set_vertex_vx(stack->mesh, &v1); mesh_set_vertex_vx(stack->mesh, &v2); mesh_set_vertex_vx(stack->mesh, &v3); gf_vec_diff(v2.pos, v2.pos, v1.pos); gf_vec_diff(v3.pos, v3.pos, v1.pos); v1.pos = gf_vec_cross(v2.pos, v3.pos); if (v1.pos.z<0) { mesh_set_triangle(stack->mesh, idx, idx+2, idx+1); } else { mesh_set_triangle(stack->mesh, idx, idx+1, idx+2); } } stack->mesh->flags |= MESH_IS_2D; mesh_update_bounds(stack->mesh); } 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; } }
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); } }
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 TraverseIFS2D(GF_Node *node, void *rs, Bool is_destroy) { DrawableContext *ctx; M_IndexedFaceSet2D *ifs2D = (M_IndexedFaceSet2D *)node; Drawable *stack = (Drawable *)gf_node_get_private(node); GF_TraverseState *tr_state = (GF_TraverseState *)rs; if (is_destroy) { drawable_node_del(node); return; } if (!ifs2D->coord) return; ifs2d_check_changes(node, stack, tr_state); switch (tr_state->traversing_mode) { case TRAVERSE_DRAW_2D: IFS2D_Draw(node, tr_state); return; #ifndef GPAC_DISABLE_3D case TRAVERSE_DRAW_3D: { DrawAspect2D asp; if (!stack->mesh) { stack->mesh = new_mesh(); mesh_new_ifs2d(stack->mesh, node); } memset(&asp, 0, sizeof(DrawAspect2D)); drawable_get_aspect_2d_mpeg4(node, &asp, tr_state); if (ifs2D->color && !GF_COL_A(asp.fill_color) ) { /*use special func to disable outline recompute and handle recompute ourselves*/ StrikeInfo2D *si = drawable_get_strikeinfo(tr_state->visual->compositor, stack, &asp, tr_state->appear, NULL, 0, tr_state); if (!si->mesh_outline) { si->mesh_outline = new_mesh(); mesh_new_ils(si->mesh_outline, ifs2D->coord, &ifs2D->coordIndex, ifs2D->color, &ifs2D->colorIndex, ifs2D->colorPerVertex, 1); } visual_3d_mesh_strike(tr_state, si->mesh_outline, asp.pen_props.width, asp.line_scale, asp.pen_props.dash); } else { visual_3d_draw_2d_with_aspect(stack, tr_state, &asp); } 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; } }