static void RenderSwitch(GF_Node *node, void *rs, Bool is_destroy)
{
GF_ChildNodeItem *l;
u32 i, count;
Bool prev_switch;
GF_ChildNodeItem *children;
s32 whichChoice;
GF_Node *child;
SwitchStack *st = (SwitchStack *)gf_node_get_private(node);
RenderEffect2D *eff;
eff = (RenderEffect2D *)rs;
if (is_destroy) {
free(st);
return;
}
if (gf_node_get_name(node)) {
node = node;
}
/*WARNING: X3D/MPEG4 NOT COMPATIBLE*/
if (gf_node_get_tag(node)==TAG_MPEG4_Switch) {
children = ((M_Switch *)node)->choice;
whichChoice = ((M_Switch *)node)->whichChoice;
} else {
children = ((X_Switch *)node)->children;
whichChoice = ((X_Switch *)node)->whichChoice;
}
count = gf_node_list_get_count(children);
prev_switch = eff->trav_flags;
/*check changes in choice field*/
if ((gf_node_dirty_get(node) & GF_SG_NODE_DIRTY) || (st->last_switch != whichChoice) ) {
eff->trav_flags |= GF_SR_TRAV_SWITCHED_OFF;
i=0;
l = children;
while (l) {
// if ((s32) i!=whichChoice) gf_node_render(l->node, eff);
if ((s32) i == st->last_switch) gf_node_render(l->node, eff);
l = l->next;
i++;
}
eff->trav_flags &= ~GF_SR_TRAV_SWITCHED_OFF;
st->last_switch = whichChoice;
}
gf_node_dirty_clear(node, 0);
/*no need to check for sensors since a sensor is active for the whole parent group, that is for switch itself
CSQ: switch cannot be used to switch sensors, too bad...*/
eff->trav_flags = prev_switch;
if (whichChoice>=0) {
child = (GF_Node*)gf_node_list_get_child(children, whichChoice);
gf_node_render(child, eff);
}
}
// AddRecursive -- recursively adds items with an ID to the dictionnary
void V4SceneManager::AddRecursive(GF_Node * node, bool parentAdded) {
// skips empty nodes
if (!node) return;
// skips the dictionnary
const char * c = gf_node_get_name(node);
if ( (c != NULL) && (!strcmp(c, DICTNAME)) ) return;
// if node as an id adds it to the dictionnary and the node pool
u32 id = gf_node_get_id(node);
if (id) {
pools.Add(node);
// children of added node are not added to the dictionnary
if (!parentAdded) AddEffective(node);
parentAdded = true;
}
GF_FieldInfo field;
GF_ChildNodeItem * list;
int count = gf_node_get_field_count(node);
// tests all fields, if a field is a node then adds it and process its children recursively
for (int i=0; i<count; i++) {
gf_node_get_field(node, i, &field);
// single value node field
if (field.fieldType == GF_SG_VRML_SFNODE)
AddRecursive( * ((GF_Node **) field.far_ptr), parentAdded );
// multiple value node field
if (field.fieldType == GF_SG_VRML_MFNODE) {
list = *( (GF_ChildNodeItem **) field.far_ptr);
for (u32 j=0; j<gf_node_list_get_count(list); j++)
AddRecursive( (GF_Node *) gf_node_list_get_child(list, j), parentAdded );
}
}
}
static void TraverseLOD(GF_Node *node, void *rs, Bool is_destroy)
{
GF_ChildNodeItem *children;
MFFloat *ranges;
SFVec3f pos, usr;
u32 which_child, nb_children;
Fixed dist;
Bool do_all;
GF_Matrix mx;
SFVec3f center;
GF_TraverseState *tr_state = (GF_TraverseState *)rs;
s32 *prev_child = (s32 *)gf_node_get_private(node);
if (is_destroy) {
gf_free(prev_child);
gf_sc_check_focus_upon_destroy(node);
return;
}
/*WARNING: X3D/MPEG4 NOT COMPATIBLE*/
if (gf_node_get_tag(node) == TAG_MPEG4_LOD) {
children = ((M_LOD *) node)->level;
ranges = &((M_LOD *) node)->range;
center = ((M_LOD *) node)->center;
#ifndef GPAC_DISABLE_X3D
} else {
children = ((X_LOD *) node)->children;
ranges = &((X_LOD *) node)->range;
center = ((X_LOD *) node)->center;
#endif
}
if (!children) return;
nb_children = gf_node_list_get_count(children);
if (!tr_state->camera) {
do_all = 1;
which_child = 0;
} else {
/*can't cache the matrix here*/
usr = tr_state->camera->position;
pos = center;
gf_mx_copy(mx, tr_state->model_matrix);
gf_mx_inverse(&mx);
gf_mx_apply_vec(&mx, &usr);
gf_vec_diff(pos, pos, usr);
dist = gf_vec_len(pos);
for (which_child=0; which_child<ranges->count; which_child++) {
if (dist<ranges->vals[which_child]) break;
}
if (which_child>=nb_children) which_child = nb_children-1;
/*check if we're traversing the same child or not for audio rendering*/
do_all = 0;
if (gf_node_dirty_get(node)) {
gf_node_dirty_clear(node, 0);
do_all = 1;
} else if ((s32) which_child != *prev_child) {
*prev_child = which_child;
do_all = 1;
}
}
if (do_all) {
u32 i;
Bool prev_switch = tr_state->switched_off;
GF_ChildNodeItem *l = children;
tr_state->switched_off = 1;
i=0;
while (l) {
if (i!=which_child) gf_node_traverse(l->node, rs);
l = l->next;
}
tr_state->switched_off = prev_switch;
}
gf_node_traverse(gf_node_list_get_child(children, which_child), rs);
}
static void TraverseSwitch(GF_Node *node, void *rs, Bool is_destroy)
{
GF_ChildNodeItem *l;
u32 i;
Bool prev_switch;
GF_ChildNodeItem *children;
s32 whichChoice;
GF_Node *child;
SwitchStack *st = (SwitchStack *)gf_node_get_private(node);
GF_TraverseState *tr_state;
tr_state = (GF_TraverseState *)rs;
children = NULL;
/* souchay : be sure to be initialized, -1 seems reasonable since we check if (whichChoice>=0) */
whichChoice = -1;
if (is_destroy) {
gf_sc_check_focus_upon_destroy(node);
gf_free(st);
return;
}
/*WARNING: X3D/MPEG4 NOT COMPATIBLE*/
switch (gf_node_get_tag(node)) {
case TAG_MPEG4_Switch:
children = ((M_Switch *)node)->choice;
whichChoice = ((M_Switch *)node)->whichChoice;
break;
#ifndef GPAC_DISABLE_X3D
case TAG_X3D_Switch:
children = ((X_Switch *)node)->children;
whichChoice = ((X_Switch *)node)->whichChoice;
break;
#endif
}
if (tr_state->traversing_mode!=TRAVERSE_GET_BOUNDS) {
prev_switch = tr_state->switched_off;
/*check changes in choice field*/
if ((gf_node_dirty_get(node) & GF_SG_NODE_DIRTY) || (st->last_switch != whichChoice) ) {
tr_state->switched_off = 1;
i=0;
l = children;
while (l) {
// if ((s32) i!=whichChoice) gf_node_traverse(l->node, tr_state);
if ((s32) i == st->last_switch) gf_node_traverse(l->node, tr_state);
l = l->next;
i++;
}
tr_state->switched_off = 0;
st->last_switch = whichChoice;
}
gf_node_dirty_clear(node, 0);
/*no need to check for sensors since a sensor is active for the whole parent group, that is for switch itself
CSQ: switch cannot be used to switch sensors, too bad...*/
tr_state->switched_off = prev_switch;
}
if (!children) return;
if (whichChoice==-2) {
#ifndef GPAC_DISABLE_3D
if (tr_state->visual->autostereo_type) {
u32 idx;
u32 count = gf_node_list_get_count(children);
/*this should be a bit more subtle (reusing views if missing, ...)...*/
idx = tr_state->visual->current_view % count;
child = (GF_Node*)gf_node_list_get_child(children, idx);
gf_node_traverse(child, tr_state);
return;
} else
#endif //GPAC_DISABLE_3D
{
/*fallback to first view*/
whichChoice=0;
}
}
if (whichChoice>=0) {
child = (GF_Node*)gf_node_list_get_child(children, whichChoice);
gf_node_traverse(child, tr_state);
}
}
static void RenderOrderedGroup(GF_Node *node, void *rs, Bool is_destroy)
{
u32 i, count;
GF_Node *child;
Bool split_text_backup, invalidate_backup;
M_OrderedGroup *og;
u32 count2;
GF_List *sensor_backup;
SensorHandler *hsens;
OrderedGroupStack *ogs = (OrderedGroupStack *) gf_node_get_private(node);
RenderEffect2D *eff = (RenderEffect2D *)rs;
if (is_destroy) {
DeleteGroupingNode2D((GroupingNode2D *)ogs);
if (ogs->priorities) free(ogs->priorities);
free(ogs);
return;
}
og = (M_OrderedGroup *) ogs->owner;
if (!og->order.count) {
group2d_traverse((GroupingNode2D*)ogs, og->children, eff);
return;
}
count = gf_node_list_get_count(og->children);
invalidate_backup = eff->invalidate_all;
/*check whether the OrderedGroup node has changed*/
if (gf_node_dirty_get(node) & GF_SG_NODE_DIRTY) {
if (ogs->priorities) free(ogs->priorities);
ogs->priorities = (struct og_pos*)malloc(sizeof(struct og_pos)*count);
for (i=0; i<count; i++) {
ogs->priorities[i].position = i;
ogs->priorities[i].priority = (i<og->order.count) ? og->order.vals[i] : 0;
}
qsort(ogs->priorities, count, sizeof(struct og_pos), compare_priority);
eff->invalidate_all = 1;
}
sensor_backup = NULL;
if (gf_node_dirty_get(node) & GF_SG_CHILD_DIRTY) {
/*rebuild sensor list*/
if (gf_list_count(ogs->sensors)) {
gf_list_del(ogs->sensors);
ogs->sensors = gf_list_new();
}
for (i=0; i<count; i++) {
child = (GF_Node*)gf_node_list_get_child(og->children, ogs->priorities[i].position);
if (!child || !is_sensor_node(child) ) continue;
hsens = get_sensor_handler(child);
if (hsens) gf_list_add(ogs->sensors, hsens);
}
}
/*if we have an active sensor at this level discard all sensors in current render context (cf VRML)*/
count2 = gf_list_count(ogs->sensors);
if (count2) {
sensor_backup = eff->sensors;
eff->sensors = gf_list_new();
/*add sensor to effects*/
for (i=0; i <count2; i++) {
SensorHandler *hsens = (SensorHandler *)gf_list_get(ogs->sensors, i);
effect_add_sensor(eff, hsens, &eff->transform);
}
}
gf_node_dirty_clear(node, 0);
if (eff->parent == (GroupingNode2D *) ogs) {
for (i=0; i<count; i++) {
group2d_start_child((GroupingNode2D *) ogs);
child = (GF_Node*)gf_node_list_get_child(og->children, ogs->priorities[i].position);
gf_node_render(child, eff);
group2d_end_child((GroupingNode2D *) ogs);
}
} else {
split_text_backup = eff->text_split_mode;
if (count>1) eff->text_split_mode = 0;
for (i=0; i<count; i++) {
child = (GF_Node*)gf_node_list_get_child(og->children, ogs->priorities[i].position);
gf_node_render(child, eff);
}
eff->text_split_mode = split_text_backup;
}
/*restore effect*/
invalidate_backup = eff->invalidate_all;
if (count2) {
/*destroy current effect list and restore previous*/
effect_reset_sensors(eff);
gf_list_del(eff->sensors);
eff->sensors = sensor_backup;
}
}
GF_Node *CloneNodeForEditing(GF_SceneGraph *inScene, GF_Node *orig) //, GF_Node *cloned_parent)
{
u32 i, j, count;
GF_Node *node, *child, *tmp;
GF_ChildNodeItem *list, *list2;
GF_FieldInfo field_orig, field;
/*this is not a mistake*/
if (!orig) return NULL;
/*check for DEF/USE
if (orig->sgprivate->NodeID) {
node = gf_sg_find_node(inScene, orig->sgprivate->NodeID);
//node already created, USE
if (node) {
gf_node_register(node, cloned_parent);
return node;
}
}
*/
/*create a node*/
/*
if (orig->sgprivate->tag == TAG_MPEG4_ProtoNode) {
proto_node = ((GF_ProtoInstance *)orig)->proto_interface;
//create the instance but don't load the code -c we MUST wait for ISed routes to be cloned before
node = gf_sg_proto_create_node(inScene, proto_node, (GF_ProtoInstance *) orig);
} else {
*/
node = gf_node_new(inScene, gf_node_get_tag(orig));
// }
count = gf_node_get_field_count(orig);
/*copy each field*/
for (i=0; i<count; i++) {
gf_node_get_field(orig, i, &field_orig);
/*get target ptr*/
gf_node_get_field(node, i, &field);
assert(field.eventType==field_orig.eventType);
assert(field.fieldType==field_orig.fieldType);
/*duplicate it*/
switch (field.fieldType) {
case GF_SG_VRML_SFNODE:
child = CloneNodeForEditing(inScene, (GF_Node *) (* ((GF_Node **) field_orig.far_ptr)));//, node);
*((GF_Node **) field.far_ptr) = child;
break;
case GF_SG_VRML_MFNODE:
list = *( (GF_ChildNodeItem **) field_orig.far_ptr);
list2 = *( (GF_ChildNodeItem **) field.far_ptr);
for (j=0; j<gf_node_list_get_count(list); j++) {
tmp = (GF_Node *)gf_node_list_get_child(list, j);
child = CloneNodeForEditing(inScene, tmp);//, node);
gf_node_list_add_child(&list2, child);
}
break;
default:
gf_sg_vrml_field_copy(field.far_ptr, field_orig.far_ptr, field.fieldType);
break;
}
}
/*register node
if (orig->sgprivate->NodeID) {
Node_SetID(node, orig->sgprivate->NodeID);
gf_node_register(node, cloned_parent);
}*/
/*init node before creating ISed routes so the eventIn handler are in place*/
if (gf_node_get_tag(node) != TAG_ProtoNode) gf_node_init(node);
return node;
}
static GF_Err BM_XReplace(GF_BifsDecoder *codec, GF_BitStream *bs, GF_List *com_list)
{
GF_FieldInfo targetField, fromField, decfield;
GF_Node *target, *n, *fromNode;
s32 pos = -2;
u32 id, nbBits, ind, aind;
GF_Err e;
GF_Command *com;
GF_CommandField *inf;
id = 1 + gf_bs_read_int(bs, codec->info->config.NodeIDBits);
target = gf_sg_find_node(codec->current_graph, id);
if (!target) return GF_SG_UNKNOWN_NODE;
e = GF_OK;
com = gf_sg_command_new(codec->current_graph, GF_SG_XREPLACE);
BM_SetCommandNode(com, target);
nbBits = gf_get_bit_size(gf_node_get_num_fields_in_mode(target, GF_SG_FIELD_CODING_IN)-1);
ind = gf_bs_read_int(bs, nbBits);
e = gf_bifs_get_field_index(target, ind, GF_SG_FIELD_CODING_IN, &aind);
if (e) return e;
e = gf_node_get_field(target, aind, &targetField);
if (e) return e;
inf = gf_sg_command_field_new(com);
inf->fieldIndex = aind;
if (!gf_sg_vrml_is_sf_field(targetField.fieldType)) {
/*this is indexed replacement*/
if (gf_bs_read_int(bs, 1)) {
/*index is dynamic*/
if (gf_bs_read_int(bs, 1)) {
id = 1 + gf_bs_read_int(bs, codec->info->config.NodeIDBits);
n = gf_sg_find_node(codec->current_graph, id);
if (!n) return GF_SG_UNKNOWN_NODE;
com->toNodeID = id;
nbBits = gf_get_bit_size(gf_node_get_num_fields_in_mode(n, GF_SG_FIELD_CODING_DEF)-1);
ind = gf_bs_read_int(bs, nbBits);
e = gf_bifs_get_field_index(n, ind, GF_SG_FIELD_CODING_DEF, &aind);
if (e) return e;
e = gf_node_get_field(n, aind, &fromField);
if (e) return e;
com->toFieldIndex = aind;
} else {
u32 type = gf_bs_read_int(bs, 2);
switch (type) {
case 0:
pos = gf_bs_read_int(bs, 16);
break;
case 2:
pos = 0;
break;
case 3:
pos = -1;
break;
}
}
}
if (targetField.fieldType==GF_SG_VRML_MFNODE) {
if (gf_bs_read_int(bs, 1)) {
target = gf_node_list_get_child(*(GF_ChildNodeItem **)targetField.far_ptr, pos);
if (!target) return GF_SG_UNKNOWN_NODE;
nbBits = gf_get_bit_size(gf_node_get_num_fields_in_mode(target, GF_SG_FIELD_CODING_IN)-1);
ind = gf_bs_read_int(bs, nbBits);
e = gf_bifs_get_field_index(target, ind, GF_SG_FIELD_CODING_IN, &aind);
if (e) return e;
e = gf_node_get_field(target, aind, &targetField);
if (e) return e;
pos = -2;
com->child_field = aind;
com->ChildNodeTag = gf_node_get_tag(target);
if (com->ChildNodeTag == TAG_ProtoNode) {
s32 p_id = gf_sg_proto_get_id(gf_node_get_proto(target));
com->ChildNodeTag = -p_id;
}
}
}
inf->pos = pos;
}
fromNode = NULL;
if (gf_bs_read_int(bs, 1)) {
id = 1 + gf_bs_read_int(bs, codec->info->config.NodeIDBits);
fromNode = gf_sg_find_node(codec->current_graph, id);
if (!fromNode) return GF_SG_UNKNOWN_NODE;
com->fromNodeID = id;
nbBits = gf_get_bit_size(gf_node_get_num_fields_in_mode(fromNode, GF_SG_FIELD_CODING_DEF)-1);
ind = gf_bs_read_int(bs, nbBits);
e = gf_bifs_get_field_index(fromNode, ind, GF_SG_FIELD_CODING_DEF, &aind);
if (e) return e;
e = gf_node_get_field(fromNode, aind, &fromField);
if (e) return e;
com->fromFieldIndex = aind;
return GF_OK;
}
if (pos>= -1) {
inf->fieldType = gf_sg_vrml_get_sf_type(targetField.fieldType);
} else {
inf->fieldType = targetField.fieldType;
}
decfield.fieldIndex = inf->fieldIndex;
decfield.fieldType = inf->fieldType;
if (inf->fieldType==GF_SG_VRML_SFNODE) {
decfield.far_ptr = inf->field_ptr = &inf->new_node;
} else if (inf->fieldType==GF_SG_VRML_MFNODE) {
decfield.far_ptr = inf->field_ptr = &inf->node_list;
} else {
decfield.far_ptr = inf->field_ptr = gf_sg_vrml_field_pointer_new(inf->fieldType);
}
e = gf_bifs_dec_sf_field(codec, bs, target, &decfield, 1);
if (e) return e;
gf_list_add(com_list, com);
return GF_OK;
}
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;
}
GF_EXPORT
GF_Err gf_sm_stats_for_command(GF_StatManager *stat, GF_Command *com)
{
#ifdef GPAC_DISABLE_VRML
return GF_NOT_SUPPORTED;
#else
GF_FieldInfo field;
GF_Err e;
GF_ChildNodeItem *list;
GF_CommandField *inf = NULL;
if (gf_list_count(com->command_fields))
inf = (GF_CommandField*)gf_list_get(com->command_fields, 0);
if (!com || !stat) return GF_BAD_PARAM;
switch (com->tag) {
case GF_SG_SCENE_REPLACE:
if (com->node) StatNodeGraph(stat, com->node);
break;
case GF_SG_NODE_REPLACE:
if (inf && inf->new_node) StatNodeGraph(stat, inf->new_node);
break;
case GF_SG_FIELD_REPLACE:
if (!inf) return GF_OK;
e = gf_node_get_field(com->node, inf->fieldIndex, &field);
if (e) return e;
switch (field.fieldType) {
case GF_SG_VRML_SFNODE:
if (inf->new_node) StatNodeGraph(stat, inf->new_node);
break;
case GF_SG_VRML_MFNODE:
list = * ((GF_ChildNodeItem**) inf->field_ptr);
while (list) {
StatNodeGraph(stat, list->node);
list = list->next;
}
break;
default:
field.far_ptr = inf->field_ptr;
StatField(stat->stats, &field);
break;
}
break;
case GF_SG_INDEXED_REPLACE:
if (!inf) return GF_OK;
e = gf_node_get_field(com->node, inf->fieldIndex, &field);
if (e) return e;
if (field.fieldType == GF_SG_VRML_MFNODE) {
StatNodeGraph(stat, inf->new_node);
} else {
field.fieldType = gf_sg_vrml_get_sf_type(field.fieldType);
field.far_ptr = inf->field_ptr;
StatSingleField(stat->stats, &field);
}
break;
case GF_SG_NODE_DELETE:
if (com->node) StatNode(stat->stats, com->node, 0, 1, NULL);
break;
case GF_SG_INDEXED_DELETE:
if (!inf) return GF_OK;
e = gf_node_get_field(com->node, inf->fieldIndex, &field);
if (e) return e;
/*then we need special handling in case of a node*/
if (gf_sg_vrml_get_sf_type(field.fieldType) == GF_SG_VRML_SFNODE) {
GF_Node *n = gf_node_list_get_child( * (GF_ChildNodeItem **) field.far_ptr, inf->pos);
if (n) StatNode(stat->stats, n, 0, 1, NULL);
} else {
StatRemField(stat->stats, inf->fieldType, NULL);
}
break;
case GF_SG_NODE_INSERT:
if (inf && inf->new_node) StatNodeGraph(stat, inf->new_node);
break;
case GF_SG_INDEXED_INSERT:
if (!inf) return GF_OK;
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) {
field.fieldType = gf_sg_vrml_get_sf_type(field.fieldType);
field.far_ptr = inf->field_ptr;
StatSingleField(stat->stats, &field);
} else {
if (inf->new_node) StatNodeGraph(stat, inf->new_node);
}
break;
case GF_SG_ROUTE_REPLACE:
case GF_SG_ROUTE_DELETE:
case GF_SG_ROUTE_INSERT:
return GF_OK;
default:
return GF_BAD_PARAM;
}
return GF_OK;
#endif
}
static void svg_traverse_switch(GF_Node *node, void *rs, Bool is_destroy)
{
GF_Matrix2D backup_matrix;
GF_Matrix mx_3d;
SVGPropertiesPointers backup_props;
u32 backup_flags;
s32 *selected_idx = gf_node_get_private(node);
u32 styling_size = sizeof(SVGPropertiesPointers);
SVGAllAttributes all_atts;
GF_TraverseState *tr_state = (GF_TraverseState *) rs;
if (is_destroy) {
gf_free(selected_idx);
gf_sc_check_focus_upon_destroy(node);
return;
}
gf_svg_flatten_attributes((SVG_Element *)node, &all_atts);
if (gf_node_dirty_get(node)) {
u32 pos = 0;
GF_ChildNodeItem *child = ((SVG_Element*)node)->children;
*selected_idx = -1;
while (child) {
SVGAllAttributes atts;
gf_svg_flatten_attributes((SVG_Element *)child->node, &atts);
if (compositor_svg_evaluate_conditional(tr_state->visual->compositor, &atts)) {
*selected_idx = pos;
break;
}
pos++;
child = child->next;
}
drawable_reset_group_highlight(tr_state, node);
gf_node_dirty_clear(node, 0);
}
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)) {
memcpy(tr_state->svg_props, &backup_props, styling_size);
tr_state->svg_flags = backup_flags;
return;
}
if (*selected_idx >= 0) {
compositor_svg_apply_local_transformation(tr_state, &all_atts, &backup_matrix, &mx_3d);
if (tr_state->traversing_mode == TRAVERSE_GET_BOUNDS) {
gf_sc_get_nodes_bounds(node, ((SVG_Element *)node)->children, tr_state, selected_idx);
} else if (*selected_idx >= 0) {
GF_Node *child = gf_node_list_get_child(((SVG_Element *)node)->children, *selected_idx);
gf_node_traverse(child, tr_state);
drawable_check_focus_highlight(node, tr_state, NULL);
}
compositor_svg_restore_parent_transformation(tr_state, &backup_matrix, &mx_3d);
}
memcpy(tr_state->svg_props, &backup_props, styling_size);
tr_state->svg_flags = backup_flags;
}
