void compositor_background_modified(GF_Node *node)
{
M_Background *bck = (M_Background *)node;
BackgroundStack *st = (BackgroundStack *) gf_node_get_private(node);
if (!st) return;
if (!gf_sg_vrml_field_equal(&bck->skyColor, &st->sky_col, GF_SG_VRML_MFCOLOR)
|| !gf_sg_vrml_field_equal(&bck->skyAngle, &st->sky_ang, GF_SG_VRML_MFFLOAT)
) {
if (st->sky_mesh) mesh_free(st->sky_mesh);
st->sky_mesh = NULL;
gf_sg_vrml_field_copy(&st->sky_col, &bck->skyColor, GF_SG_VRML_MFCOLOR);
gf_sg_vrml_field_copy(&st->sky_ang, &bck->skyAngle, GF_SG_VRML_MFFLOAT);
}
if (!gf_sg_vrml_field_equal(&bck->groundColor, &st->ground_col, GF_SG_VRML_MFCOLOR)
|| !gf_sg_vrml_field_equal(&bck->groundAngle, &st->ground_ang, GF_SG_VRML_MFFLOAT)
) {
if (st->ground_mesh) mesh_free(st->ground_mesh);
st->ground_mesh = NULL;
gf_sg_vrml_field_copy(&st->ground_col, &bck->groundColor, GF_SG_VRML_MFCOLOR);
gf_sg_vrml_field_copy(&st->ground_ang, &bck->groundAngle, GF_SG_VRML_MFFLOAT);
}
back_check_gf_sc_texture_change(&st->txh_front, &bck->frontUrl);
back_check_gf_sc_texture_change(&st->txh_back, &bck->backUrl);
back_check_gf_sc_texture_change(&st->txh_top, &bck->topUrl);
back_check_gf_sc_texture_change(&st->txh_bottom, &bck->bottomUrl);
back_check_gf_sc_texture_change(&st->txh_left, &bck->leftUrl);
back_check_gf_sc_texture_change(&st->txh_right, &bck->rightUrl);
gf_sc_invalidate(st->compositor, NULL);
}
static void animationstream_check_url(AnimationStreamStack *stack, M_AnimationStream *as)
{
if (!stack->stream) {
gf_sg_vrml_mf_reset(&stack->current_url, GF_SG_VRML_MFURL);
gf_sg_vrml_field_copy(&stack->current_url, &as->url, GF_SG_VRML_MFURL);
stack->stream = gf_mo_register((GF_Node *)as, &as->url, 0, 0);
gf_sc_invalidate(stack->compositor, NULL);
/*if changed while playing trigger*/
if (as->isActive) {
gf_mo_play(stack->stream, 0, -1, 0);
gf_mo_set_speed(stack->stream, as->speed);
}
return;
}
/*check change*/
if (gf_mo_url_changed(stack->stream, &as->url)) {
gf_sg_vrml_mf_reset(&stack->current_url, GF_SG_VRML_MFURL);
gf_sg_vrml_field_copy(&stack->current_url, &as->url, GF_SG_VRML_MFURL);
/*if changed while playing stop old source*/
if (as->isActive) {
gf_mo_set_flag(stack->stream, GF_MO_DISPLAY_REMOVE, 1);
gf_mo_stop(stack->stream);
}
gf_mo_unregister((GF_Node *)as, stack->stream);
stack->stream = gf_mo_register((GF_Node *)as, &as->url, 0, 0);
/*if changed while playing play new source*/
if (as->isActive) {
gf_mo_play(stack->stream, 0, -1, 0);
gf_mo_set_speed(stack->stream, as->speed);
}
gf_sc_invalidate(stack->compositor, NULL);
}
}
GF_Command *gf_sg_command_clone(GF_Command *com, GF_SceneGraph *inGraph)
{
u32 i, count;
GF_Command *dest;
if (com->tag==GF_SG_SCENE_REPLACE) return NULL;
/*FIXME - to do*/
if (gf_list_count(com->new_proto_list)) return NULL;
dest = gf_sg_command_new(inGraph, com->tag);
/*node the command applies to - may be NULL*/
dest->node = gf_node_clone(inGraph, com->node, NULL);
/*route insert, replace and delete*/
dest->RouteID = com->RouteID;
if (com->def_name) dest->def_name = strdup(com->def_name);
dest->fromNodeID = com->fromNodeID;
dest->fromFieldIndex = com->fromFieldIndex;
dest->toNodeID = com->toNodeID;
dest->toFieldIndex = com->toFieldIndex;
dest->del_proto_list_size = com->del_proto_list_size;
if (com->del_proto_list_size) {
dest->del_proto_list = (u32*)malloc(sizeof(u32) * com->del_proto_list_size);
memcpy(dest->del_proto_list, com->del_proto_list, sizeof(u32) * com->del_proto_list_size);
}
count = gf_list_count(com->command_fields);
for (i=0; i<count; i++) {
GF_CommandField *fo = (GF_CommandField *)gf_list_get(com->command_fields, i);
GF_CommandField *fd = (GF_CommandField *)gf_sg_command_field_new(dest);
fd->fieldIndex = fo->fieldIndex;
fd->fieldType = fo->fieldType;
fd->pos = fo->pos;
if (fo->field_ptr) {
fd->field_ptr = gf_sg_vrml_field_pointer_new(fd->fieldType);
gf_sg_vrml_field_copy(fd->field_ptr, fo->field_ptr, fo->fieldType);
}
if (fo->new_node) {
fd->new_node = gf_node_clone(inGraph, fo->new_node, dest->node);
fd->field_ptr = &fd->new_node;
}
if (fo->node_list) {
GF_ChildNodeItem *child, *cur, *prev;
prev = NULL;
child = fo->node_list;
while (child) {
cur = (GF_ChildNodeItem*) malloc(sizeof(GF_ChildNodeItem));
cur->node = gf_node_clone(inGraph, child->node, dest->node);
cur->next = NULL;
if (prev) prev->next = cur;
else fd->node_list = cur;
prev = cur;
child = child->next;
}
fd->field_ptr = &fd->node_list;
}
}
return dest;
}
static void Extrusion_SetCrossSection(GF_Node *node, GF_Route *route)
{
M_Extrusion *eg = (M_Extrusion *)node;
gf_sg_vrml_field_copy(&eg->crossSection, &eg->set_crossSection, GF_SG_VRML_MFVEC2F);
gf_sg_vrml_mf_reset(&eg->set_crossSection, GF_SG_VRML_MFVEC2F);
}
static void ElevationGrid_SetHeight(GF_Node *node, GF_Route *route)
{
M_ElevationGrid *eg = (M_ElevationGrid *)node;
gf_sg_vrml_field_copy(&eg->height, &eg->set_height, GF_SG_VRML_MFFLOAT);
gf_sg_vrml_mf_reset(&eg->set_height, GF_SG_VRML_MFFLOAT);
}
static void ILS_SetCoordIndex(GF_Node *node, GF_Route *route)
{
M_IndexedLineSet *ils = (M_IndexedLineSet *)node;
gf_sg_vrml_field_copy(&ils->coordIndex, &ils->set_coordIndex, GF_SG_VRML_MFINT32);
gf_sg_vrml_mf_reset(&ils->set_coordIndex, GF_SG_VRML_MFINT32);
}
static void IFS_SetTexCoordIndex(GF_Node *node, GF_Route *route)
{
M_IndexedFaceSet *ifs = (M_IndexedFaceSet *)node;
gf_sg_vrml_field_copy(&ifs->texCoordIndex, &ifs->set_texCoordIndex, GF_SG_VRML_MFINT32);
gf_sg_vrml_mf_reset(&ifs->set_texCoordIndex, GF_SG_VRML_MFINT32);
}
GF_EXPORT
void gf_sg_vrml_field_clone(void *dest, void *orig, u32 field_type, GF_SceneGraph *inScene)
{
u32 size, i, sf_type;
void *dst_field, *orig_field;
if (!dest || !orig) return;
switch (field_type) {
case GF_SG_VRML_SFBOOL:
memcpy(dest, orig, sizeof(SFBool));
break;
case GF_SG_VRML_SFCOLOR:
memcpy(dest, orig, sizeof(SFColor));
break;
case GF_SG_VRML_SFFLOAT:
memcpy(dest, orig, sizeof(SFFloat));
break;
case GF_SG_VRML_SFINT32:
memcpy(dest, orig, sizeof(SFInt32));
break;
case GF_SG_VRML_SFROTATION:
memcpy(dest, orig, sizeof(SFRotation));
break;
case GF_SG_VRML_SFTIME:
memcpy(dest, orig, sizeof(SFTime));
break;
case GF_SG_VRML_SFVEC2F:
memcpy(dest, orig, sizeof(SFVec2f));
break;
case GF_SG_VRML_SFVEC3F:
memcpy(dest, orig, sizeof(SFVec3f));
break;
case GF_SG_VRML_SFATTRREF:
memcpy(dest, orig, sizeof(SFAttrRef));
break;
case GF_SG_VRML_SFSTRING:
if ( ((SFString*)dest)->buffer) gf_free(((SFString*)dest)->buffer);
if ( ((SFString*)orig)->buffer )
((SFString*)dest)->buffer = gf_strdup(((SFString*)orig)->buffer);
else
((SFString*)dest)->buffer = NULL;
break;
case GF_SG_VRML_SFURL:
if ( ((SFURL *)dest)->url ) gf_free( ((SFURL *)dest)->url );
((SFURL *)dest)->OD_ID = ((SFURL *)orig)->OD_ID;
if (((SFURL *)orig)->url)
((SFURL *)dest)->url = gf_strdup(((SFURL *)orig)->url);
else
((SFURL *)dest)->url = NULL;
break;
case GF_SG_VRML_SFIMAGE:
if (((SFImage *)dest)->pixels) gf_free(((SFImage *)dest)->pixels);
((SFImage *)dest)->width = ((SFImage *)orig)->width;
((SFImage *)dest)->height = ((SFImage *)orig)->height;
((SFImage *)dest)->numComponents = ((SFImage *)orig)->numComponents;
size = ((SFImage *)dest)->width * ((SFImage *)dest)->height * ((SFImage *)dest)->numComponents;
((SFImage *)dest)->pixels = (u8*)gf_malloc(sizeof(char)*size);
memcpy(((SFImage *)dest)->pixels, ((SFImage *)orig)->pixels, sizeof(char)*size);
break;
case GF_SG_VRML_SFCOMMANDBUFFER:
{
SFCommandBuffer *cb_dst = (SFCommandBuffer *)dest;
SFCommandBuffer *cb_src = (SFCommandBuffer *)orig;
cb_dst->bufferSize = cb_src->bufferSize;
if (cb_dst->bufferSize && !gf_list_count(cb_src->commandList) ) {
cb_dst->buffer = (u8*)gf_realloc(cb_dst->buffer, sizeof(char)*cb_dst->bufferSize);
memcpy(cb_dst->buffer, cb_src->buffer, sizeof(char)*cb_src->bufferSize);
} else {
u32 j, c2;
if (cb_dst->buffer) gf_free(cb_dst->buffer);
cb_dst->buffer = NULL;
/*clone command list*/
c2 = gf_list_count(cb_src->commandList);
for (j=0; j<c2;j++) {
GF_Command *sub_com = (GF_Command *)gf_list_get(cb_src->commandList, j);
GF_Command *new_com = gf_sg_vrml_command_clone(sub_com, inScene, 0);
gf_list_add(cb_dst->commandList, new_com);
}
}
}
break;
/*simply copy text string*/
case GF_SG_VRML_SFSCRIPT:
if (((SFScript*)dest)->script_text) gf_free(((SFScript*)dest)->script_text);
((SFScript*)dest)->script_text = NULL;
if ( ((SFScript*)orig)->script_text)
((SFScript *)dest)->script_text = (char *)gf_strdup( (char*) ((SFScript*)orig)->script_text );
break;
//simple MFFields, do a memcpy
case GF_SG_VRML_MFBOOL:
case GF_SG_VRML_MFFLOAT:
case GF_SG_VRML_MFTIME:
case GF_SG_VRML_MFINT32:
case GF_SG_VRML_MFVEC3F:
case GF_SG_VRML_MFVEC2F:
case GF_SG_VRML_MFCOLOR:
case GF_SG_VRML_MFROTATION:
case GF_SG_VRML_MFATTRREF:
size = gf_sg_vrml_get_sf_size(field_type) * ((GenMFField *)orig)->count;
if (((GenMFField *)orig)->count != ((GenMFField *)dest)->count) {
((GenMFField *)dest)->array = gf_realloc(((GenMFField *)dest)->array, size);
((GenMFField *)dest)->count = ((GenMFField *)orig)->count;
}
memcpy(((GenMFField *)dest)->array, ((GenMFField *)orig)->array, size);
break;
//complex MFFields
case GF_SG_VRML_MFSTRING:
case GF_SG_VRML_MFIMAGE:
case GF_SG_VRML_MFURL:
case GF_SG_VRML_MFSCRIPT:
size = ((GenMFField *)orig)->count;
gf_sg_vrml_mf_reset(dest, field_type);
gf_sg_vrml_mf_alloc(dest, field_type, size);
sf_type = gf_sg_vrml_get_sf_type(field_type);
//duplicate all items
for (i=0; i<size; i++) {
gf_sg_vrml_mf_get_item(dest, field_type, &dst_field, i);
gf_sg_vrml_mf_get_item(orig, field_type, &orig_field, i);
gf_sg_vrml_field_copy(dst_field, orig_field, sf_type);
}
break;
}
}
GF_Node *CloneNodeForEditing(GF_SceneGraph *inScene, GF_Node *orig) //, GF_Node *cloned_parent)
{
u32 i, j, count;
GF_Node *node, *child, *tmp;
GF_List *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_List **) field_orig.far_ptr);
list2 = *( (GF_List **) field.far_ptr);
for (j=0; j<gf_list_count(list); j++) {
tmp = (GF_Node *)gf_list_get(list, j);
child = CloneNodeForEditing(inScene, tmp);//, node);
gf_list_add(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;
}
void RenderMediaControl(GF_Node *node, void *rs, Bool is_destroy)
{
Bool shall_restart, need_restart;
GF_MediaObject *prev;
GF_ObjectManager *odm;
GF_TraverseState *tr_state = (GF_TraverseState *)rs;
MediaControlStack *stack =(MediaControlStack *) gf_node_get_private(node);
if (is_destroy) {
GF_ObjectManager *odm;
MediaControlStack *stack = (MediaControlStack *) gf_node_get_private(node);
/*reset ODM using this control*/
if (stack->stream) {
if (stack->stream->odm) {
odm = stack->stream->odm;
gf_odm_remove_mediacontrol(odm, stack);
}
/*also removes the association ck<->MC if the object has been destroyed before the node*/
if (stack->ck) stack->ck->mc = NULL;
}
gf_list_del(stack->seg);
gf_sg_vrml_mf_reset(&stack->url, GF_SG_VRML_MFURL);
gf_free(stack);
return;
}
//we need to disable culling otherwise we may never be called back again ...
tr_state->disable_cull = 1;
/*not changed nothing to do - note we need to register with stream yet for control switching...*/
if (stack->stream && (!stack->changed || !stack->control->enabled)) return;
need_restart = (stack->changed==2) ? 1 : 0;
shall_restart = (stack->control->mediaStartTime>=0) ? 1 : 0;
/*check url target*/
if (stack->stream) {
if (MC_URLChanged(&stack->url, &stack->control->url)) {
gf_sg_vrml_mf_reset(&stack->url, GF_SG_VRML_MFURL);
prev = stack->stream;
if (gf_list_find(stack->parent->scene_objects, prev)<0)
prev = NULL;
stack->stream = gf_scene_get_media_object(stack->parent, &stack->control->url, GF_MEDIA_OBJECT_UNDEF, 0);
if (stack->stream) {
if (!stack->stream->odm) return;
/*MediaControl on inline: if dynamic scene, make sure it is connected before attaching...*/
if (stack->stream->odm->subscene) {
if (stack->stream->odm->subscene->is_dynamic_scene && !stack->stream->odm->subscene->dyn_ck) return;
}
gf_sg_vrml_field_copy(&stack->url, &stack->control->url, GF_SG_VRML_MFURL);
/*remove from prev*/
if (prev && prev->odm && (prev != stack->stream)) gf_odm_remove_mediacontrol(prev->odm, stack);
/*register with new*/
/*if we assigned the media control to an exiting object - force the state of the object*/
gf_odm_set_mediacontrol((GF_ObjectManager *) stack->stream->odm, stack);
while (gf_list_count(stack->seg)) gf_list_rem(stack->seg, 0);
gf_odm_init_segments((GF_ObjectManager *) stack->stream->odm, stack->seg, &stack->control->url);
stack->current_seg = 0;
//do not restart if no mediaStartTime and speed is 1
if ((stack->control->mediaStartTime>0) || gf_list_count(stack->seg) || (stack->control->mediaSpeed != FIX_ONE) ) {
shall_restart = need_restart = 1;
} else {
shall_restart = need_restart = 0;
//URL changed, we are by default in PLAY mode.
stack->media_speed = 1;
}
stack->ck = gf_odm_get_media_clock(stack->stream->odm);
}
/*control has been removed and we were paused, resume*/
else if (stack->paused) {
mediacontrol_resume((GF_ObjectManager *) prev->odm, 0);
stack->paused = 0;
}
/*MediaControl has been detached*/
else {
if (prev)
gf_odm_remove_mediacontrol(prev->odm, stack);
return;
}
}
} else {
stack->stream = gf_scene_get_media_object(stack->parent, &stack->control->url, GF_MEDIA_OBJECT_UNDEF, 0);
if (!stack->stream || !stack->stream->odm) {
if (stack->control->url.count) gf_term_invalidate_compositor(stack->parent->root_od->term);
stack->stream = NULL;
stack->changed = 0;
return;
}
stack->ck = gf_odm_get_media_clock(stack->stream->odm);
/*OD not ready yet*/
if (!stack->ck) {
stack->stream = NULL;
if (stack->control->url.count) {
stack->is_init = 0;
gf_term_invalidate_compositor(stack->parent->root_od->term);
}
return;
}
gf_sg_vrml_field_copy(&stack->url, &stack->control->url, GF_SG_VRML_MFURL);
gf_odm_set_mediacontrol((GF_ObjectManager *) stack->stream->odm, stack);
while (gf_list_count(stack->seg)) gf_list_rem(stack->seg, 0);
gf_odm_init_segments((GF_ObjectManager *) stack->stream->odm, stack->seg, &stack->control->url);
stack->current_seg = 0;
/*we shouldn't have to restart unless start/stop times have been changed, which is tested below*/
need_restart = 0;
}
if (!stack->changed || !stack->control->enabled || !stack->stream) return;
/*if not previously enabled and now enabled, switch all other controls off and reactivate*/
if (!stack->enabled) {
stack->enabled = 1;
need_restart = gf_odm_switch_mediacontrol(stack->stream->odm, stack);
}
stack->changed = 0;
if (!stack->control->mediaSpeed) shall_restart = 0;
odm = (GF_ObjectManager *)stack->stream->odm;
/*check for changes*/
if (!stack->is_init) {
/*not linked yet*/
if (!odm) return;
stack->media_speed = stack->control->mediaSpeed;
stack->enabled = stack->control->enabled;
stack->media_start = stack->control->mediaStartTime;
stack->media_stop = stack->control->mediaStopTime;
stack->is_init = 1;
stack->paused = 0;
/*the object has already been started, and media start time is not 0, restart*/
if (stack->stream->num_open) {
if ( (stack->media_start > 0) || (gf_list_count(stack->seg)>0 ) || (stack->media_speed!=FIX_ONE ) ) {
mediacontrol_restart(odm);
} else if (stack->media_speed == 0) {
mediacontrol_pause(odm);
stack->paused = 1;
}
}
return;
}
if (stack->media_speed != stack->control->mediaSpeed) {
/*if no speed pause*/
if (!stack->control->mediaSpeed && !stack->paused) {
mediacontrol_pause(odm);
stack->paused = 1;
}
/*else resume if paused*/
else if (stack->control->mediaSpeed && stack->paused) {
mediacontrol_resume(odm, 0);
stack->paused = 0;
need_restart += shall_restart;
}
/*else set speed*/
else if (stack->media_speed && stack->control->mediaSpeed) {
/*don't set speed if we have to restart the media ...*/
if (!shall_restart) MC_SetSpeed(odm, stack->control->mediaSpeed);
need_restart += shall_restart;
}
/*init state was paused*/
else if (!stack->media_speed) {
need_restart ++;
}
stack->media_speed = stack->control->mediaSpeed;
}
/*check start/stop changes*/
if (stack->media_start != stack->control->mediaStartTime) {
stack->media_start = stack->control->mediaStartTime;
need_restart += shall_restart;
}
/*stop change triggers restart no matter what (new range) if playing*/
if (stack->media_stop != stack->control->mediaStopTime) {
stack->media_stop = stack->control->mediaStopTime;
if (stack->control->mediaSpeed) need_restart = 1;
}
if (need_restart) {
mediacontrol_restart(odm);
}
/*handle preroll*/
}
static GF_Err IS_ProcessData(GF_SceneDecoder *plug, const char *inBuffer, u32 inBufferLength,
u16 ES_ID, u32 AU_time, u32 mmlevel)
{
u32 i, j, count;
Double scene_time;
GF_BitStream *bs;
GF_FieldInfo *field;
ISStack *st;
ISPriv *priv = (ISPriv *)plug->privateStack;
GF_Err e = GF_OK;
/*decode data frame except if local stringSensor*/
bs = gf_bs_new(inBuffer, inBufferLength, GF_BITSTREAM_READ);
i=0;
while ((field = (GF_FieldInfo *)gf_list_enum(priv->ddf, &i))) {
/*store present flag in eventIn for command skip - this is an ugly hack but it works since DDF don't have event types*/
field->eventType = gf_bs_read_int(bs, 1);
/*parse val ourselves (we don't want to depend on bifs codec)*/
if (field->eventType) {
switch (field->fieldType) {
case GF_SG_VRML_SFBOOL: * ((SFBool *) field->far_ptr) = (SFBool) gf_bs_read_int(bs, 1); break;
case GF_SG_VRML_SFFLOAT: *((SFFloat *)field->far_ptr) = FLT2FIX( gf_bs_read_float(bs) ); break;
case GF_SG_VRML_SFINT32: *((SFInt32 *)field->far_ptr) = (s32) gf_bs_read_int(bs, 32); break;
case GF_SG_VRML_SFTIME: *((SFTime *)field->far_ptr) = gf_bs_read_double(bs); break;
case GF_SG_VRML_SFVEC2F:
((SFVec2f *)field->far_ptr)->x = FLT2FIX( gf_bs_read_float(bs) );
((SFVec2f *)field->far_ptr)->y = FLT2FIX( gf_bs_read_float(bs) );
break;
case GF_SG_VRML_SFVEC3F:
((SFVec3f *)field->far_ptr)->x = FLT2FIX( gf_bs_read_float(bs) );
((SFVec3f *)field->far_ptr)->y = FLT2FIX( gf_bs_read_float(bs) );
((SFVec3f *)field->far_ptr)->z = FLT2FIX( gf_bs_read_float(bs) );
break;
case GF_SG_VRML_SFCOLOR:
((SFColor *)field->far_ptr)->red = FLT2FIX( gf_bs_read_float(bs) );
((SFColor *)field->far_ptr)->green = FLT2FIX( gf_bs_read_float(bs) );
((SFColor *)field->far_ptr)->blue = FLT2FIX( gf_bs_read_float(bs) );
break;
case GF_SG_VRML_SFVEC4F:
case GF_SG_VRML_SFROTATION:
((SFRotation *)field->far_ptr)->x = FLT2FIX( gf_bs_read_float(bs) );
((SFRotation *)field->far_ptr)->y = FLT2FIX( gf_bs_read_float(bs) );
((SFRotation *)field->far_ptr)->z = FLT2FIX( gf_bs_read_float(bs) );
((SFRotation *)field->far_ptr)->q = FLT2FIX( gf_bs_read_float(bs) );
break;
case GF_SG_VRML_SFSTRING:
{
u32 size, length;
size = gf_bs_read_int(bs, 5);
length = gf_bs_read_int(bs, size);
if (gf_bs_available(bs) < length) return GF_NON_COMPLIANT_BITSTREAM;
if ( ((SFString *)field->far_ptr)->buffer ) gf_free( ((SFString *)field->far_ptr)->buffer);
((SFString *)field->far_ptr)->buffer = (char*)gf_malloc(sizeof(char)*(length+1));
memset(((SFString *)field->far_ptr)->buffer , 0, length+1);
for (j=0; j<length; j++) {
((SFString *)field->far_ptr)->buffer[j] = gf_bs_read_int(bs, 8);
}
}
break;
}
}
}
gf_bs_del(bs);
/*special case for StringSensor in local mode: lookup for special chars*/
if ((priv->type == IS_StringSensor) && priv->is_local) {
char tmp_utf8[5000];
const unsigned short *ptr;
u32 len;
GF_FieldInfo *field1 = (GF_FieldInfo *)gf_list_get(priv->ddf, 0);
GF_FieldInfo *field2 = (GF_FieldInfo *)gf_list_get(priv->ddf, 1);
SFString *inText = (SFString *) field1->far_ptr;
SFString *outText = (SFString *) field2->far_ptr;
field1->eventType = field2->eventType = 0;
priv->enteredText[priv->text_len] = (short) '\0';
len = gf_utf8_wcslen(priv->enteredText);
if (len && (priv->enteredText[len-1] == priv->termChar)) {
ptr = priv->enteredText;
len = gf_utf8_wcstombs(tmp_utf8, 5000, &ptr);
if (outText->buffer) gf_free(outText->buffer);
outText->buffer = (char*)gf_malloc(sizeof(char) * (len));
memcpy(outText->buffer, tmp_utf8, sizeof(char) * len-1);
outText->buffer[len-1] = 0;
if (inText->buffer) gf_free(inText->buffer);
inText->buffer = NULL;
priv->text_len = 0;
field1->eventType = field2->eventType = 1;
} else {
if (priv->delChar) {
/*remove chars*/
if ((len>1) && (priv->enteredText[len-1] == priv->delChar)) {
priv->enteredText[len-1] = (short) '\0';
len--;
if (len) {
priv->enteredText[len-1] = (short) '\0';
len--;
}
}
}
priv->text_len = len;
ptr = priv->enteredText;
len = gf_utf8_wcstombs(tmp_utf8, 5000, &ptr);
if (inText->buffer) gf_free(inText->buffer);
inText->buffer = (char*)gf_malloc(sizeof(char) * (len+1));
memcpy(inText->buffer, tmp_utf8, sizeof(char) * len);
inText->buffer[len] = 0;
field1->eventType = 1;
}
}
gf_term_lock_compositor(priv->scene->root_od->term, 1);
/*apply it*/
i=0;
while ((st = (ISStack*)gf_list_enum(priv->is_nodes, &i))) {
assert(st->is);
assert(st->mo);
if (!st->is->enabled) continue;
count = gf_list_count(st->is->buffer.commandList);
scene_time = gf_scene_get_time(priv->scene);
for (j=0; j<count; j++) {
GF_Command *com = (GF_Command *)gf_list_get(st->is->buffer.commandList, j);
GF_FieldInfo *field = (GF_FieldInfo *)gf_list_get(priv->ddf, j);
GF_CommandField *info = (GF_CommandField *)gf_list_get(com->command_fields, 0);
if (info && field && field->eventType) {
gf_sg_vrml_field_copy(info->field_ptr, field->far_ptr, field->fieldType);
gf_sg_command_apply(priv->scene->graph, com, scene_time);
}
}
}
gf_term_lock_compositor(priv->scene->root_od->term, 0);
return e;
}
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 ITSS_SetIndex(GF_Node *node, GF_Route *route)
{
X_IndexedTriangleStripSet *itss = (X_IndexedTriangleStripSet*)node;
gf_sg_vrml_field_copy(&itss->index, &itss->set_index, GF_SG_VRML_MFINT32);
gf_sg_vrml_mf_reset(&itss->set_index, GF_SG_VRML_MFINT32);
}
GF_EXPORT
void gf_sg_vrml_field_copy(void *dest, void *orig, u32 field_type)
{
u32 size, i, sf_type;
void *dst_field, *orig_field;
if (!dest || !orig) return;
switch (field_type) {
case GF_SG_VRML_SFBOOL:
memcpy(dest, orig, sizeof(SFBool));
break;
case GF_SG_VRML_SFCOLOR:
memcpy(dest, orig, sizeof(SFColor));
break;
case GF_SG_VRML_SFFLOAT:
memcpy(dest, orig, sizeof(SFFloat));
break;
case GF_SG_VRML_SFINT32:
memcpy(dest, orig, sizeof(SFInt32));
break;
case GF_SG_VRML_SFROTATION:
memcpy(dest, orig, sizeof(SFRotation));
break;
case GF_SG_VRML_SFTIME:
memcpy(dest, orig, sizeof(SFTime));
break;
case GF_SG_VRML_SFVEC2F:
memcpy(dest, orig, sizeof(SFVec2f));
break;
case GF_SG_VRML_SFVEC3F:
memcpy(dest, orig, sizeof(SFVec3f));
break;
case GF_SG_VRML_SFSTRING:
if ( ((SFString*)dest)->buffer) free(((SFString*)dest)->buffer);
if ( ((SFString*)orig)->buffer )
((SFString*)dest)->buffer = strdup(((SFString*)orig)->buffer);
else
((SFString*)dest)->buffer = NULL;
break;
case GF_SG_VRML_SFURL:
if ( ((SFURL *)dest)->url ) free( ((SFURL *)dest)->url );
((SFURL *)dest)->OD_ID = ((SFURL *)orig)->OD_ID;
if (((SFURL *)orig)->url)
((SFURL *)dest)->url = strdup(((SFURL *)orig)->url);
else
((SFURL *)dest)->url = NULL;
break;
case GF_SG_VRML_SFIMAGE:
if (((SFImage *)dest)->pixels) free(((SFImage *)dest)->pixels);
((SFImage *)dest)->width = ((SFImage *)orig)->width;
((SFImage *)dest)->height = ((SFImage *)orig)->height;
((SFImage *)dest)->numComponents = ((SFImage *)orig)->numComponents;
size = ((SFImage *)dest)->width * ((SFImage *)dest)->height * ((SFImage *)dest)->numComponents;
((SFImage *)dest)->pixels = (u8*)malloc(sizeof(char)*size);
memcpy(((SFImage *)dest)->pixels, ((SFImage *)orig)->pixels, sizeof(char)*size);
break;
case GF_SG_VRML_SFCOMMANDBUFFER:
gf_sg_sfcommand_del( *(SFCommandBuffer *)dest);
((SFCommandBuffer *)dest)->commandList = gf_list_new();
((SFCommandBuffer *)dest)->bufferSize = ((SFCommandBuffer *)orig)->bufferSize;
if (((SFCommandBuffer *)dest)->bufferSize) {
((SFCommandBuffer *)dest)->buffer = (u8*)malloc(sizeof(char)*((SFCommandBuffer *)orig)->bufferSize);
memcpy(((SFCommandBuffer *)dest)->buffer,
((SFCommandBuffer *)orig)->buffer,
sizeof(char)*((SFCommandBuffer *)orig)->bufferSize);
} else {
((SFCommandBuffer *)dest)->buffer = NULL;
}
break;
/*simply copy text string*/
case GF_SG_VRML_SFSCRIPT:
if (((SFScript*)dest)->script_text) free(((SFScript*)dest)->script_text);
((SFScript*)dest)->script_text = NULL;
if ( ((SFScript*)orig)->script_text)
((SFScript *)dest)->script_text = (u8*)strdup( (char*) ((SFScript*)orig)->script_text );
break;
//MFFields
case GF_SG_VRML_MFBOOL:
case GF_SG_VRML_MFFLOAT:
case GF_SG_VRML_MFTIME:
case GF_SG_VRML_MFINT32:
case GF_SG_VRML_MFSTRING:
case GF_SG_VRML_MFVEC3F:
case GF_SG_VRML_MFVEC2F:
case GF_SG_VRML_MFCOLOR:
case GF_SG_VRML_MFROTATION:
case GF_SG_VRML_MFIMAGE:
case GF_SG_VRML_MFURL:
case GF_SG_VRML_MFSCRIPT:
size = ((GenMFField *)orig)->count;
gf_sg_vrml_mf_reset(dest, field_type);
gf_sg_vrml_mf_alloc(dest, field_type, size);
sf_type = gf_sg_vrml_get_sf_type(field_type);
//duplicate all items
for (i=0; i<size; i++) {
gf_sg_vrml_mf_get_item(dest, field_type, &dst_field, i);
gf_sg_vrml_mf_get_item(orig, field_type, &orig_field, i);
gf_sg_vrml_field_copy(dst_field, orig_field, sf_type);
}
break;
}
}
static void ILS2D_SetColorIndex(GF_Node *node, GF_Route *route)
{
M_IndexedLineSet2D *ils2D = (M_IndexedLineSet2D *)node;
gf_sg_vrml_field_copy(&ils2D->colorIndex, &ils2D->set_colorIndex, GF_SG_VRML_MFINT32);
gf_sg_vrml_mf_reset(&ils2D->set_colorIndex, GF_SG_VRML_MFINT32);
}
static void Extrusion_SetOrientation(GF_Node *node, GF_Route *route)
{
M_Extrusion *eg = (M_Extrusion *)node;
gf_sg_vrml_field_copy(&eg->orientation, &eg->set_orientation, GF_SG_VRML_MFROTATION);
gf_sg_vrml_mf_reset(&eg->set_orientation, GF_SG_VRML_MFROTATION);
}
static void Extrusion_SetSpine(GF_Node *node, GF_Route *route)
{
M_Extrusion *eg = (M_Extrusion *)node;
gf_sg_vrml_field_copy(&eg->spine, &eg->set_spine, GF_SG_VRML_MFVEC3F);
gf_sg_vrml_mf_reset(&eg->set_spine, GF_SG_VRML_MFVEC3F);
}
static void IFS2D_SetCoordIndex(GF_Node *node, GF_Route *route)
{
M_IndexedFaceSet2D *ifs2D = (M_IndexedFaceSet2D *)node;
gf_sg_vrml_field_copy(&ifs2D->coordIndex, &ifs2D->set_coordIndex, GF_SG_VRML_MFINT32);
gf_sg_vrml_mf_reset(&ifs2D->set_coordIndex, GF_SG_VRML_MFINT32);
}
