static void TraverseTransform2D(GF_Node *node, void *rs, Bool is_destroy)
{
M_Transform2D *tr = (M_Transform2D *)node;
Transform2DStack *ptr = (Transform2DStack *)gf_node_get_private(node);
GF_TraverseState *tr_state;
if (is_destroy) {
gf_sc_check_focus_upon_destroy(node);
group_2d_destroy(node, (GroupingNode2D*)ptr);
gf_free(ptr);
return;
}
tr_state = (GF_TraverseState *) rs;
if (gf_node_dirty_get(node) & GF_SG_NODE_DIRTY) {
gf_mx2d_init(ptr->mat);
ptr->is_identity = 1;
if ((tr->scale.x != FIX_ONE) || (tr->scale.y != FIX_ONE)) {
gf_mx2d_add_scale_at(&ptr->mat, tr->scale.x, tr->scale.y, 0, 0, tr->scaleOrientation);
ptr->is_identity = 0;
}
if (tr->rotationAngle) {
gf_mx2d_add_rotation(&ptr->mat, tr->center.x, tr->center.y, tr->rotationAngle);
ptr->is_identity = 0;
}
if (tr->translation.x || tr->translation.y) {
ptr->is_identity = 0;
gf_mx2d_add_translation(&ptr->mat, tr->translation.x, tr->translation.y);
}
gf_node_dirty_clear(node, GF_SG_NODE_DIRTY);
ptr->is_null = (!tr->scale.x || !tr->scale.y) ? 1 : 0;
}
traverse_transform(node, ptr, tr_state);
}
GF_EXPORT
GF_Err gf_path_add_arc_to(GF_Path *gp, Fixed end_x, Fixed end_y, Fixed fa_x, Fixed fa_y, Fixed fb_x, Fixed fb_y, Bool cw)
{
GF_Matrix2D mat, inv;
Fixed angle, start_angle, end_angle, sweep, axis_w, axis_h, tmp, cx, cy, _vx, _vy, start_x, start_y;
s32 i, num_steps;
if (!gp->n_points) return GF_BAD_PARAM;
start_x = gp->points[gp->n_points-1].x;
start_y = gp->points[gp->n_points-1].y;
cx = (fb_x + fa_x)/2;
cy = (fb_y + fa_y)/2;
angle = gf_atan2(fb_y-fa_y, fb_x-fa_x);
gf_mx2d_init(mat);
gf_mx2d_add_rotation(&mat, 0, 0, angle);
gf_mx2d_add_translation(&mat, cx, cy);
gf_mx2d_copy(inv, mat);
gf_mx2d_inverse(&inv);
gf_mx2d_apply_coords(&inv, &start_x, &start_y);
gf_mx2d_apply_coords(&inv, &end_x, &end_y);
gf_mx2d_apply_coords(&inv, &fa_x, &fa_y);
gf_mx2d_apply_coords(&inv, &fb_x, &fb_y);
//start angle and end angle
start_angle = gf_atan2(start_y, start_x);
end_angle = gf_atan2(end_y, end_x);
tmp = gf_mulfix((start_x - fa_x), (start_x - fa_x)) + gf_mulfix((start_y - fa_y), (start_y - fa_y));
axis_w = gf_sqrt(tmp);
tmp = gf_mulfix((start_x - fb_x) , (start_x - fb_x)) + gf_mulfix((start_y - fb_y), (start_y - fb_y));
axis_w += gf_sqrt(tmp);
axis_w /= 2;
axis_h = gf_sqrt(gf_mulfix(axis_w, axis_w) - gf_mulfix(fa_x,fa_x));
sweep = end_angle - start_angle;
if (cw) {
if (sweep>0) sweep -= 2*GF_PI;
} else {
if (sweep<0) sweep += 2*GF_PI;
}
num_steps = GF_2D_DEFAULT_RES/2;
for (i=1; i<=num_steps; i++) {
angle = start_angle + sweep*i/num_steps;
_vx = gf_mulfix(axis_w, gf_cos(angle));
_vy = gf_mulfix(axis_h, gf_sin(angle));
/*re-invert*/
gf_mx2d_apply_coords(&mat, &_vx, &_vy);
gf_path_add_line_to(gp, _vx, _vy);
}
return GF_OK;
}
void get_gf_sr_texture_transform(GF_Node *__appear, GF_TextureHandler *txh, GF_Matrix2D *mat, Bool line_texture, Fixed final_width, Fixed final_height)
{
u32 node_tag;
M_Appearance *appear;
GF_Node *txtrans = NULL;
gf_mx2d_init(*mat);
if (!__appear || !txh) return;
appear = (M_Appearance *)__appear;
if (!line_texture) {
if (!appear->textureTransform) return;
txtrans = appear->textureTransform;
} else {
if (gf_node_get_tag(appear->material) != TAG_MPEG4_Material2D) return;
if (gf_node_get_tag(((M_Material2D *)appear->material)->lineProps) != TAG_MPEG4_XLineProperties) return;
txtrans = ((M_XLineProperties *) ((M_Material2D *)appear->material)->lineProps)->textureTransform;
}
if (!txtrans) return;
/*gradient doesn't need bounds info in texture transform*/
if (txh->compute_gradient_matrix) {
final_width = final_height = FIX_ONE;
}
node_tag = gf_node_get_tag(txtrans);
if (node_tag==TAG_MPEG4_TextureTransform) {
/*VRML: Tc' = -C × S × R × C × T × Tc*/
M_TextureTransform *txt = (M_TextureTransform *) txtrans;
SFVec2f scale = txt->scale;
if (!scale.x) scale.x = FIX_ONE/100;
if (!scale.y) scale.y = FIX_ONE/100;
gf_mx2d_add_translation(mat, -txt->center.x * final_width, -txt->center.y * final_height);
gf_mx2d_add_scale(mat, scale.x, scale.y);
gf_mx2d_add_rotation(mat, 0, 0, txt->rotation);
gf_mx2d_add_translation(mat, txt->center.x * final_width, txt->center.y * final_height);
gf_mx2d_add_translation(mat, txt->translation.x * final_width, txt->translation.y * final_height);
/*and inverse the matrix (this is texture transform, cf VRML)*/
gf_mx2d_inverse(mat);
return;
}
if (node_tag==TAG_MPEG4_TransformMatrix2D) {
TM2D_GetMatrix((GF_Node *) txtrans, mat);
mat->m[2] *= final_width;
mat->m[5] *= final_height;
gf_mx2d_inverse(mat);
return;
}
}
static void RenderTransform2D(GF_Node *node, void *rs, Bool is_destroy)
{
GF_Matrix2D bckup;
M_Transform2D *tr = (M_Transform2D *)node;
Transform2DStack *ptr = (Transform2DStack *)gf_node_get_private(node);
RenderEffect2D *eff;
if (is_destroy) {
DeleteGroupingNode2D((GroupingNode2D *)ptr);
free(ptr);
return;
}
eff = (RenderEffect2D *) rs;
if (gf_node_dirty_get(node) & GF_SG_NODE_DIRTY) {
gf_mx2d_init(ptr->mat);
ptr->is_identity = 1;
if ((tr->scale.x != FIX_ONE) || (tr->scale.y != FIX_ONE)) {
gf_mx2d_add_scale_at(&ptr->mat, tr->scale.x, tr->scale.y, 0, 0, tr->scaleOrientation);
ptr->is_identity = 0;
}
if (tr->rotationAngle) {
gf_mx2d_add_rotation(&ptr->mat, tr->center.x, tr->center.y, tr->rotationAngle);
ptr->is_identity = 0;
}
if (tr->translation.x || tr->translation.y) {
ptr->is_identity = 0;
gf_mx2d_add_translation(&ptr->mat, tr->translation.x, tr->translation.y);
}
}
/*note we don't clear dirty flag, this is done in traversing*/
if (ptr->is_identity) {
group2d_traverse((GroupingNode2D *)ptr, tr->children, eff);
} else {
gf_mx2d_copy(bckup, eff->transform);
gf_mx2d_copy(eff->transform, ptr->mat);
gf_mx2d_add_matrix(&eff->transform, &bckup);
group2d_traverse((GroupingNode2D *)ptr, tr->children, eff);
gf_mx2d_copy(eff->transform, bckup);
}
}
static void GradientGetMatrix(GF_Node *transform, GF_Matrix2D *mat)
{
gf_mx2d_init(*mat);
if (transform) {
switch (gf_node_get_tag(transform) ) {
case TAG_MPEG4_Transform2D:
{
M_Transform2D *tr = (M_Transform2D *)transform;
gf_mx2d_add_scale_at(mat, 0, 0, tr->scale.x, tr->scale.y, tr->scaleOrientation);
gf_mx2d_add_rotation(mat, tr->center.x, tr->center.y, tr->rotationAngle);
gf_mx2d_add_translation(mat, tr->translation.x, tr->translation.y);
}
break;
case TAG_MPEG4_TransformMatrix2D:
TM2D_GetMatrix(transform, mat);
break;
default:
break;
}
}
}
static void TraverseViewport(GF_Node *node, void *rs, Bool is_destroy)
{
Fixed sx, sy, w, h, tx, ty;
#ifndef GPAC_DISABLE_3D
GF_Matrix mx;
#endif
GF_Matrix2D mat;
GF_Rect rc, rc_bckup;
ViewStack *st = (ViewStack *) gf_node_get_private(node);
M_Viewport *vp = (M_Viewport *) node;
GF_TraverseState *tr_state = (GF_TraverseState *)rs;
if (is_destroy) {
DestroyViewStack(node);
return;
}
#ifndef GPAC_DISABLE_3D
if (tr_state->visual->type_3d>1) return;
#endif
/*first traverse, bound if needed*/
if (gf_list_find(tr_state->viewpoints, node) < 0) {
gf_list_add(tr_state->viewpoints, node);
assert(gf_list_find(st->reg_stacks, tr_state->viewpoints)==-1);
gf_list_add(st->reg_stacks, tr_state->viewpoints);
if (gf_list_get(tr_state->viewpoints, 0) == vp) {
if (!vp->isBound) Bindable_SetIsBound(node, 1);
} else {
if (gf_inline_is_default_viewpoint(node)) Bindable_SetSetBindEx(node, 1, tr_state->viewpoints);
}
VPCHANGED(tr_state->visual->compositor);
/*in any case don't draw the first time (since the viewport could have been declared last)*/
gf_sc_invalidate(tr_state->visual->compositor, NULL);
return;
}
if (tr_state->traversing_mode != TRAVERSE_BINDABLE) return;
if (!vp->isBound) return;
if (gf_list_get(tr_state->viewpoints, 0) != vp)
return;
#ifndef GPAC_DISABLE_3D
if (tr_state->visual->type_3d) {
w = tr_state->bbox.max_edge.x - tr_state->bbox.min_edge.x;
h = tr_state->bbox.max_edge.y - tr_state->bbox.min_edge.y;
} else
#endif
{
w = tr_state->bounds.width;
h = tr_state->bounds.height;
}
if (!w || !h) return;
/*if no parent this is the main viewport, don't update if not changed*/
// if (!tr_state->is_layer && !gf_node_dirty_get(node)) return;
gf_node_dirty_clear(node, 0);
gf_mx2d_init(mat);
gf_mx2d_add_translation(&mat, vp->position.x, vp->position.y);
gf_mx2d_add_rotation(&mat, 0, 0, vp->orientation);
//compute scaling ratio
sx = (vp->size.x>=0) ? vp->size.x : w;
sy = (vp->size.y>=0) ? vp->size.y : h;
rc = gf_rect_center(sx, sy);
rc_bckup = rc;
switch (vp->fit) {
/*covers all area and respect aspect ratio*/
case 2:
if (gf_divfix(rc.width, w) > gf_divfix(rc.height, h)) {
rc.width = gf_muldiv(rc.width, h, rc.height);
rc.height = h;
} else {
rc.height = gf_muldiv(rc.height , w, rc.width);
rc.width = w;
}
break;
/*fits inside the area and respect AR*/
case 1:
if (gf_divfix(rc.width, w)> gf_divfix(rc.height, h)) {
rc.height = gf_muldiv(rc.height, w, rc.width);
rc.width = w;
} else {
rc.width = gf_muldiv(rc.width, h, rc.height);
rc.height = h;
}
break;
/*fit entirely: nothing to change*/
case 0:
rc.width = w;
rc.height = h;
break;
default:
return;
}
sx = gf_divfix(rc.width, rc_bckup.width);
sy = gf_divfix(rc.height, rc_bckup.height);
/*viewport on root visual, remove compositor scale*/
if (!tr_state->is_layer && (tr_state->visual->compositor->visual==tr_state->visual) ) {
sx = gf_divfix(sx, tr_state->visual->compositor->scale_x);
sy = gf_divfix(sy, tr_state->visual->compositor->scale_y);
}
rc.x = - rc.width/2;
rc.y = rc.height/2;
tx = ty = 0;
if (vp->fit && vp->alignment.count) {
/*left alignment*/
if (vp->alignment.vals[0] == -1) tx = rc.width/2 - w/2;
else if (vp->alignment.vals[0] == 1) tx = w/2 - rc.width/2;
if (vp->alignment.count>1) {
/*top-alignment*/
if (vp->alignment.vals[1]==-1) ty = rc.height/2 - h/2;
else if (vp->alignment.vals[1]==1) ty = h/2 - rc.height/2;
}
}
gf_mx2d_init(mat);
if (tr_state->pixel_metrics) {
gf_mx2d_add_scale(&mat, sx, sy);
} else {
/*if we are not in pixelMetrics, undo the meterMetrics->pixelMetrics transformation*/
gf_mx2d_add_scale(&mat, gf_divfix(sx, tr_state->min_hsize), gf_divfix(sy, tr_state->min_hsize) );
}
gf_mx2d_add_translation(&mat, tx, ty);
gf_mx2d_add_translation(&mat, -gf_mulfix(vp->position.x,sx), -gf_mulfix(vp->position.y,sy) );
gf_mx2d_add_rotation(&mat, 0, 0, vp->orientation);
tr_state->bounds = rc;
tr_state->bounds.x += tx;
tr_state->bounds.y += ty;
#ifndef GPAC_DISABLE_3D
if (tr_state->visual->type_3d) {
/*in layers directly modify the model matrix*/
if (tr_state->is_layer) {
gf_mx_from_mx2d(&mx, &mat);
gf_mx_add_matrix(&tr_state->model_matrix, &mx);
}
/*otherwise add to camera viewport matrix*/
else {
gf_mx_from_mx2d(&tr_state->camera->viewport, &mat);
tr_state->camera->flags = (CAM_HAS_VIEWPORT | CAM_IS_DIRTY);
}
} else
#endif
gf_mx2d_pre_multiply(&tr_state->transform, &mat);
}
GF_EXPORT
GF_Err gf_sg_command_apply(GF_SceneGraph *graph, GF_Command *com, Double time_offset)
{
GF_Err e;
GF_CommandField *inf;
GF_FieldInfo field;
GF_Node *def, *node;
void *slot_ptr;
if (!com || !graph) return GF_BAD_PARAM;
e = GF_OK;
switch (com->tag) {
case GF_SG_SCENE_REPLACE:
/*unregister root*/
gf_node_unregister(graph->RootNode, NULL);
/*remove all protos and routes*/
while (gf_list_count(graph->routes_to_activate))
gf_list_rem(graph->routes_to_activate, 0);
/*destroy all routes*/
while (gf_list_count(graph->Routes)) {
GF_Route *r = (GF_Route *)gf_list_get(graph->Routes, 0);
/*this will unregister the route from the graph, so don't delete the chain entry*/
gf_sg_route_del(r);
}
/*destroy all proto*/
while (gf_list_count(graph->protos)) {
GF_Proto *p = (GF_Proto*)gf_list_get(graph->protos, 0);
/*this will unregister the proto from the graph, so don't delete the chain entry*/
gf_sg_proto_del(p);
}
/*DO NOT TOUCH node registry*/
/*DO NOT TOUCH UNREGISTERED PROTOS*/
/*move all protos in graph*/
while (gf_list_count(com->new_proto_list)) {
GF_Proto *p = (GF_Proto*)gf_list_get(com->new_proto_list, 0);
gf_list_rem(com->new_proto_list, 0);
gf_list_del_item(graph->unregistered_protos, p);
gf_list_add(graph->protos, p);
}
/*assign new root (no need to register/unregister)*/
graph->RootNode = com->node;
com->node = NULL;
break;
case GF_SG_NODE_REPLACE:
if (!gf_list_count(com->command_fields)) return GF_OK;
inf = (GF_CommandField*)gf_list_get(com->command_fields, 0);
e = gf_node_replace(com->node, inf->new_node, 0);
if (inf->new_node) gf_node_register(inf->new_node, NULL);
break;
case GF_SG_MULTIPLE_REPLACE:
case GF_SG_FIELD_REPLACE:
{
u32 j;
GF_ChildNodeItem *list, *cur, *prev;
j=0;
while ((inf = (GF_CommandField*)gf_list_enum(com->command_fields, &j))) {
e = gf_node_get_field(com->node, inf->fieldIndex, &field);
if (e) return e;
switch (field.fieldType) {
case GF_SG_VRML_SFNODE:
{
node = *((GF_Node **) field.far_ptr);
e = gf_node_unregister(node, com->node);
*((GF_Node **) field.far_ptr) = inf->new_node;
if (!e) gf_node_register(inf->new_node, com->node);
break;
}
case GF_SG_VRML_MFNODE:
gf_node_unregister_children(com->node, * ((GF_ChildNodeItem **) field.far_ptr));
* ((GF_ChildNodeItem **) field.far_ptr) = NULL;
list = * ((GF_ChildNodeItem **) inf->field_ptr);
prev=NULL;
while (list) {
cur = malloc(sizeof(GF_ChildNodeItem));
cur->next = NULL;
cur->node = list->node;
if (prev) {
prev->next = cur;
} else {
* ((GF_ChildNodeItem **) field.far_ptr) = cur;
}
gf_node_register(list->node, com->node);
prev = cur;
list = list->next;
}
break;
default:
/*this is a regular field, reset it and clone - we cannot switch pointers since the
original fields are NOT pointers*/
if (!gf_sg_vrml_is_sf_field(field.fieldType)) {
e = gf_sg_vrml_mf_reset(field.far_ptr, field.fieldType);
}
if (e) return e;
gf_sg_vrml_field_copy(field.far_ptr, inf->field_ptr, field.fieldType);
if (field.fieldType==GF_SG_VRML_SFTIME) *(SFTime *)field.far_ptr = *(SFTime *)field.far_ptr + time_offset;
break;
}
SG_CheckFieldChange(com->node, &field);
}
break;
}
case GF_SG_MULTIPLE_INDEXED_REPLACE:
case GF_SG_INDEXED_REPLACE:
{
u32 sftype, i=0;
while ((inf = (GF_CommandField*)gf_list_enum(com->command_fields, &i))) {
e = gf_node_get_field(com->node, inf->fieldIndex, &field);
if (e) return e;
/*if MFNode remove the child and set new node*/
if (field.fieldType == GF_SG_VRML_MFNODE) {
/*we must remove the node before in case the new node uses the same ID (not forbidden) and this
command removes the last instance of the node with the same ID*/
gf_node_replace_child(com->node, (GF_ChildNodeItem**) field.far_ptr, inf->pos, inf->new_node);
if (inf->new_node) gf_node_register(inf->new_node, NULL);
}
/*erase the field item*/
else {
if ((inf->pos < 0) || ((u32) inf->pos >= ((GenMFField *) field.far_ptr)->count) ) {
inf->pos = ((GenMFField *)field.far_ptr)->count - 1;
/*may happen with text and default value*/
if (inf->pos < 0) {
inf->pos = 0;
gf_sg_vrml_mf_alloc(field.far_ptr, field.fieldType, 1);
}
}
e = gf_sg_vrml_mf_get_item(field.far_ptr, field.fieldType, & slot_ptr, inf->pos);
if (e) return e;
sftype = gf_sg_vrml_get_sf_type(field.fieldType);
gf_sg_vrml_field_copy(slot_ptr, inf->field_ptr, sftype);
/*note we don't add time offset, since there's no MFTime*/
}
SG_CheckFieldChange(com->node, &field);
}
break;
}
case GF_SG_ROUTE_REPLACE:
{
GF_Route *r;
char *name;
r = gf_sg_route_find(graph, com->RouteID);
def = gf_sg_find_node(graph, com->fromNodeID);
node = gf_sg_find_node(graph, com->toNodeID);
if (!node || !def) return GF_SG_UNKNOWN_NODE;
name = NULL;
if (r) {
name = r->name;
r->name = NULL;
gf_sg_route_del(r);
}
r = gf_sg_route_new(graph, def, com->fromFieldIndex, node, com->toFieldIndex);
gf_sg_route_set_id(r, com->RouteID);
if (name) {
gf_sg_route_set_name(r, name);
free(name);
}
break;
}
case GF_SG_NODE_DELETE_EX:
case GF_SG_NODE_DELETE:
{
if (com->node) gf_node_replace(com->node, NULL, (com->tag==GF_SG_NODE_DELETE_EX) ? 1 : 0);
break;
}
case GF_SG_ROUTE_DELETE:
{
return gf_sg_route_del_by_id(graph, com->RouteID);
}
case GF_SG_INDEXED_DELETE:
{
if (!gf_list_count(com->command_fields)) return GF_OK;
inf = (GF_CommandField*)gf_list_get(com->command_fields, 0);
e = gf_node_get_field(com->node, inf->fieldIndex, &field);
if (e) return e;
if (gf_sg_vrml_is_sf_field(field.fieldType)) return GF_NON_COMPLIANT_BITSTREAM;
/*then we need special handling in case of a node*/
if (gf_sg_vrml_get_sf_type(field.fieldType) == GF_SG_VRML_SFNODE) {
e = gf_node_replace_child(com->node, (GF_ChildNodeItem **) field.far_ptr, inf->pos, NULL);
} else {
if ((inf->pos < 0) || ((u32) inf->pos >= ((GenMFField *) field.far_ptr)->count) ) {
inf->pos = ((GenMFField *)field.far_ptr)->count - 1;
}
/*this is a regular MFField, just remove the item (realloc)*/
e = gf_sg_vrml_mf_remove(field.far_ptr, field.fieldType, inf->pos);
}
/*deletion -> node has changed*/
if (!e) SG_CheckFieldChange(com->node, &field);
break;
}
case GF_SG_NODE_INSERT:
{
if (!gf_list_count(com->command_fields)) return GF_OK;
inf = (GF_CommandField*)gf_list_get(com->command_fields, 0);
e = gf_node_insert_child(com->node, inf->new_node, inf->pos);
if (!e) gf_node_register(inf->new_node, com->node);
if (!e) gf_node_event_out(com->node, inf->fieldIndex);
if (!e) gf_node_changed(com->node, NULL);
break;
}
case GF_SG_ROUTE_INSERT:
{
GF_Route *r;
def = gf_sg_find_node(graph, com->fromNodeID);
node = gf_sg_find_node(graph, com->toNodeID);
if (!node || !def) return GF_SG_UNKNOWN_NODE;
r = gf_sg_route_new(graph, def, com->fromFieldIndex, node, com->toFieldIndex);
if (com->RouteID) gf_sg_route_set_id(r, com->RouteID);
if (com->def_name) {
gf_sg_route_set_name(r, com->def_name);
free(com->def_name);
com->def_name = NULL;
}
break;
}
case GF_SG_INDEXED_INSERT:
{
u32 sftype;
if (!gf_list_count(com->command_fields)) return GF_OK;
inf = (GF_CommandField*)gf_list_get(com->command_fields, 0);
e = gf_node_get_field(com->node, inf->fieldIndex, &field);
if (e) return e;
/*rescale the MFField and parse the SFField*/
if (field.fieldType != GF_SG_VRML_MFNODE) {
if (inf->pos == -1) {
e = gf_sg_vrml_mf_append(field.far_ptr, field.fieldType, & slot_ptr);
} else {
e = gf_sg_vrml_mf_insert(field.far_ptr, field.fieldType, & slot_ptr, inf->pos);
}
if (e) return e;
sftype = gf_sg_vrml_get_sf_type(field.fieldType);
gf_sg_vrml_field_copy(slot_ptr, inf->field_ptr, sftype);
} else {
if (inf->new_node) {
if (inf->pos == -1) {
gf_node_list_add_child( (GF_ChildNodeItem **) field.far_ptr, inf->new_node);
} else {
gf_node_list_insert_child((GF_ChildNodeItem **) field.far_ptr, inf->new_node, inf->pos);
}
gf_node_register(inf->new_node, com->node);
}
}
if (!e) SG_CheckFieldChange(com->node, &field);
break;
}
case GF_SG_PROTO_INSERT:
/*destroy all proto*/
while (gf_list_count(com->new_proto_list)) {
GF_Proto *p = (GF_Proto*)gf_list_get(com->new_proto_list, 0);
gf_list_rem(com->new_proto_list, 0);
gf_list_del_item(graph->unregistered_protos, p);
gf_list_add(graph->protos, p);
}
return GF_OK;
case GF_SG_PROTO_DELETE:
{
u32 i;
for (i=0; i<com->del_proto_list_size; i++) {
/*note this will check for unregistered protos, but since IDs are unique we are sure we will
not destroy an unregistered one*/
GF_Proto *proto = gf_sg_find_proto(graph, com->del_proto_list[i], NULL);
if (proto) gf_sg_proto_del(proto);
}
}
return GF_OK;
case GF_SG_PROTO_DELETE_ALL:
/*destroy all proto*/
while (gf_list_count(graph->protos)) {
GF_Proto *p = (GF_Proto*)gf_list_get(graph->protos, 0);
gf_list_rem(graph->protos, 0);
/*this will unregister the proto from the graph, so don't delete the chain entry*/
gf_sg_proto_del(p);
}
/*DO NOT TOUCH UNREGISTERED PROTOS*/
return GF_OK;
/*only used by BIFS*/
case GF_SG_GLOBAL_QUANTIZER:
return GF_OK;
#ifndef GPAC_DISABLE_SVG
/*laser commands*/
case GF_SG_LSR_NEW_SCENE:
/*DO NOT TOUCH node registry*/
/*assign new root (no need to register/unregister)*/
graph->RootNode = com->node;
com->node = NULL;
break;
case GF_SG_LSR_DELETE:
if (!com->node) return GF_NON_COMPLIANT_BITSTREAM;
if (!gf_list_count(com->command_fields)) {
gf_node_replace(com->node, NULL, 0);
gf_node_deactivate(com->node);
return GF_OK;
}
inf = (GF_CommandField*)gf_list_get(com->command_fields, 0);
node = gf_node_list_get_child(((SVG_Element *)com->node)->children, inf->pos);
if (node) {
e = gf_node_replace_child(com->node, &((SVG_Element *)com->node)->children, inf->pos, NULL);
gf_node_deactivate(node);
}
break;
case GF_SG_LSR_INSERT:
inf = (GF_CommandField*)gf_list_get(com->command_fields, 0);
if (!com->node || !inf) return GF_NON_COMPLIANT_BITSTREAM;
if (inf->new_node) {
if (inf->pos<0)
gf_node_list_add_child(& ((SVG_Element *)com->node)->children, inf->new_node);
else
gf_node_list_insert_child(& ((SVG_Element *)com->node)->children, inf->new_node, inf->pos);
gf_node_register(inf->new_node, com->node);
gf_node_activate(inf->new_node);
gf_node_changed(com->node, NULL);
} else {
/*NOT SUPPORTED*/
GF_LOG(GF_LOG_ERROR, GF_LOG_CODEC, ("[LASeR] VALUE INSERTION NOT SUPPORTED\n"));
}
break;
case GF_SG_LSR_ADD:
case GF_SG_LSR_REPLACE:
inf = (GF_CommandField*)gf_list_get(com->command_fields, 0);
if (!com->node || !inf) return GF_NON_COMPLIANT_BITSTREAM;
if (inf->new_node) {
if (inf->pos<0) {
/*if fieldIndex (eg attributeName) is set, this is children replacement*/
if (inf->fieldIndex>0) {
gf_node_unregister_children_deactivate(com->node, ((SVG_Element *)com->node)->children);
((SVG_Element *)com->node)->children = NULL;
gf_node_list_add_child(& ((SVG_Element *)com->node)->children, inf->new_node);
gf_node_register(inf->new_node, com->node);
gf_node_activate(inf->new_node);
} else {
e = gf_node_replace(com->node, inf->new_node, 0);
gf_node_activate(inf->new_node);
}
} else {
node = gf_node_list_get_child( ((SVG_Element *)com->node)->children, inf->pos);
gf_node_replace_child(com->node, & ((SVG_Element *)com->node)->children, inf->pos, inf->new_node);
gf_node_register(inf->new_node, com->node);
if (node) gf_node_deactivate(node);
gf_node_activate(inf->new_node);
}
/*signal node modif*/
gf_node_changed(com->node, NULL);
return e;
} else if (inf->node_list) {
GF_ChildNodeItem *child, *cur, *prev;
gf_node_unregister_children_deactivate(com->node, ((SVG_Element *)com->node)->children);
((SVG_Element *)com->node)->children = NULL;
prev = NULL;
child = inf->node_list;
while (child) {
cur = (GF_ChildNodeItem*)malloc(sizeof(GF_ChildNodeItem));
cur->next = NULL;
cur->node = child->node;
gf_node_register(child->node, com->node);
gf_node_activate(child->node);
if (prev) prev->next = cur;
else ((SVG_Element *)com->node)->children = cur;
prev = cur;
child = child->next;
}
/*signal node modif*/
gf_node_changed(com->node, NULL);
return GF_OK;
}
/*attribute modif*/
else if (inf->field_ptr) {
GF_FieldInfo a, b;
if (inf->fieldIndex==(u32) -2) {
GF_Point2D scale, translate;
Fixed rotate;
GF_Matrix2D *dest;
gf_node_get_field_by_name(com->node, "transform", &a);
dest = (GF_Matrix2D*)a.far_ptr;
if (com->tag==GF_SG_LSR_REPLACE) {
if (gf_mx2d_decompose(dest, &scale, &rotate, &translate)) {
gf_mx2d_init(*dest);
if (inf->fieldType==SVG_TRANSFORM_SCALE) scale = *(GF_Point2D *)inf->field_ptr;
else if (inf->fieldType==SVG_TRANSFORM_TRANSLATE) translate = *(GF_Point2D *)inf->field_ptr;
else if (inf->fieldType==SVG_TRANSFORM_ROTATE) rotate = ((SVG_Point_Angle*)inf->field_ptr)->angle;
gf_mx2d_add_scale(dest, scale.x, scale.y);
gf_mx2d_add_rotation(dest, 0, 0, rotate);
gf_mx2d_add_translation(dest, translate.x, translate.y);
}
} else {
GF_Point2D *pt = (GF_Point2D *)inf->field_ptr;
if (inf->fieldType==SVG_TRANSFORM_SCALE) gf_mx2d_add_scale(dest, pt->x, pt->y);
else if (inf->fieldType==SVG_TRANSFORM_TRANSLATE) gf_mx2d_add_translation(dest, pt->x, pt->y);
else if (inf->fieldType == SVG_TRANSFORM_ROTATE) gf_mx2d_add_rotation(dest, 0, 0, ((SVG_Point_Angle*)inf->field_ptr)->angle);
}
} else {
if ((inf->fieldIndex==(u32) -1) && (inf->fieldType==SVG_String_datatype)) {
char *str = *(SVG_String*)inf->field_ptr;
if (com->tag == GF_SG_LSR_REPLACE) {
GF_DOMText *t = ((SVG_Element*)com->node)->children ? (GF_DOMText*) ((SVG_Element*)com->node)->children->node :NULL;
if (t && (t->sgprivate->tag==TAG_DOMText)) {
if (t->textContent) free(t->textContent);
t->textContent = NULL;
if (str) t->textContent = strdup(str);
}
} else {
if (str) gf_dom_add_text_node(com->node, strdup(str));
}
}
else if ((inf->fieldIndex==TAG_LSR_ATT_scale)
|| (inf->fieldIndex==TAG_LSR_ATT_translation)
|| (inf->fieldIndex==TAG_LSR_ATT_rotation)
) {
SVG_Transform *mx;
gf_svg_get_attribute_by_tag(com->node, TAG_SVG_ATT_transform, 1, 0, &a);
mx = a.far_ptr;
if (com->tag == GF_SG_LSR_REPLACE) {
GF_Point2D scale, translate;
SVG_Point_Angle rotate;
if (gf_mx2d_decompose(&mx->mat, &scale, &rotate.angle, &translate)) {
gf_mx2d_init(mx->mat);
if (inf->fieldIndex==TAG_LSR_ATT_scale) scale = *(GF_Point2D *)inf->field_ptr;
else if (inf->fieldIndex==TAG_LSR_ATT_translation) translate = *(GF_Point2D *)inf->field_ptr;
else if (inf->fieldIndex==TAG_LSR_ATT_rotation) rotate = *(SVG_Point_Angle*)inf->field_ptr;
gf_mx2d_add_scale(&mx->mat, scale.x, scale.y);
gf_mx2d_add_rotation(&mx->mat, 0, 0, rotate.angle);
gf_mx2d_add_translation(&mx->mat, translate.x, translate.y);
}
} else {
if (inf->fieldIndex==TAG_LSR_ATT_scale) gf_mx2d_add_scale(&mx->mat, ((GF_Point2D*)inf->field_ptr)->x, ((GF_Point2D*)inf->field_ptr)->y);
if (inf->fieldIndex==TAG_LSR_ATT_translation) gf_mx2d_add_translation(&mx->mat, ((GF_Point2D*)inf->field_ptr)->x, ((GF_Point2D*)inf->field_ptr)->y);
if (inf->fieldIndex==TAG_LSR_ATT_rotation) gf_mx2d_add_rotation(&mx->mat, 0, 0, ((SVG_Point_Angle*)inf->field_ptr)->angle);
}
}
else if (gf_svg_get_attribute_by_tag(com->node, inf->fieldIndex, 1, 0, &a) == GF_OK) {
b = a;
b.far_ptr = inf->field_ptr;
if (com->tag == GF_SG_LSR_REPLACE) {
gf_svg_attributes_copy(&a, &b, 0);
} else {
gf_svg_attributes_add(&a, &b, &a, 0);
}
}
b = a;
b.far_ptr = inf->field_ptr;
}
/*signal node modif*/
gf_node_changed(com->node, &a);
} else if (com->fromNodeID) {
GF_FieldInfo a, b;
GF_Node *fromNode = gf_sg_find_node(graph, com->fromNodeID);
if (!fromNode) return GF_NON_COMPLIANT_BITSTREAM;
if (gf_node_get_field(fromNode, com->fromFieldIndex, &b) != GF_OK) return GF_NON_COMPLIANT_BITSTREAM;
if ((inf->fieldIndex==(u32) -1) && (inf->fieldType==SVG_String_datatype)) {
char *str = *(SVG_String*)inf->field_ptr;
if (com->tag == GF_SG_LSR_REPLACE) {
GF_DOMText *t = ((SVG_Element*)com->node)->children ? (GF_DOMText*) ((SVG_Element*)com->node)->children->node :NULL;
if (t && (t->sgprivate->tag==TAG_DOMText)) {
if (t->textContent) free(t->textContent);
t->textContent = NULL;
if (str) t->textContent = strdup(str);
}
} else {
if (str) gf_dom_add_text_node(com->node, strdup(str));
}
} else {
gf_node_get_field(com->node, inf->fieldIndex, &a);
if (com->tag == GF_SG_LSR_REPLACE) {
e = gf_svg_attributes_copy(&a, &b, 0);
} else {
e = gf_svg_attributes_add(&a, &b, &a, 0);
}
}
gf_node_changed(com->node, &a);
return e;
} else {
return GF_NON_COMPLIANT_BITSTREAM;
}
break;
case GF_SG_LSR_ACTIVATE:
gf_node_activate(com->node);
break;
case GF_SG_LSR_DEACTIVATE:
gf_node_deactivate(com->node);
gf_node_changed(com->node, NULL);
break;
#endif
default:
return GF_NOT_SUPPORTED;
}
if (e) return e;
if (com->scripts_to_load) {
while (gf_list_count(com->scripts_to_load)) {
GF_Node *script = (GF_Node *)gf_list_get(com->scripts_to_load, 0);
gf_list_rem(com->scripts_to_load, 0);
gf_sg_script_load(script);
}
gf_list_del(com->scripts_to_load);
com->scripts_to_load = NULL;
}
return GF_OK;
}
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;
}