GF_EXPORT
const char *gf_term_get_world_info(GF_Terminal *term, GF_ObjectManager *scene_od, GF_List *descriptions)
{
GF_Node *info;
if (!term) return NULL;
info = NULL;
if (!scene_od) {
if (!term->root_scene) return NULL;
info = (GF_Node*)term->root_scene->world_info;
} else {
if (!gf_term_check_odm(term, scene_od)) return NULL;
info = (GF_Node*) (scene_od->subscene ? scene_od->subscene->world_info : scene_od->parentscene->world_info);
}
if (!info) return NULL;
if (gf_node_get_tag(info) == TAG_SVG_title) {
/*FIXME*/
//return ((SVG_titleElement *) info)->textContent;
return "TO FIX IN GPAC!!";
} else {
#ifndef GPAC_DISABLE_VRML
M_WorldInfo *wi = (M_WorldInfo *) info;
if (descriptions) {
u32 i;
for (i=0; i<wi->info.count; i++) {
gf_list_add(descriptions, wi->info.vals[i]);
}
}
return wi->title.buffer;
#endif
}
return "GPAC";
}
static void RenderAnchor(GF_Node *node, void *rs, Bool is_destroy)
{
AnchorStack *st = (AnchorStack *) gf_node_get_private(node);
RenderEffect3D *eff = (RenderEffect3D *)rs;
if (is_destroy) {
R3D_SensorDeleted(st->compositor, &st->hdl);
DeleteGroupingNode((GroupingNode *)st);
free(st);
return;
}
if (!st->compositor->user->EventProc) {
st->enabled = 0;
return;
}
/*note we don't clear dirty flag, this is done in traversing*/
if (gf_node_dirty_get(node) & GF_SG_NODE_DIRTY) {
MFURL *url;
if (gf_node_get_tag(node)==TAG_MPEG4_Anchor) {
url = & ((M_Anchor *)node)->url;
} else {
url = & ((X_Anchor *)node)->url;
}
st->enabled = 0;
if (url->count && url->vals[0].url && strlen(url->vals[0].url) )
st->enabled = 1;
}
grouping_traverse((GroupingNode*)st, eff, NULL);
}
static void svg_compute_text_width(GF_Node *node, SVGAllAttributes *atts, GF_TraverseState *tr_state )
{
GF_ChildNodeItem *child;
Bool is_switch = GF_FALSE;
/*compute length of all text blocks*/
switch (gf_node_get_tag(node)) {
case TAG_DOMText:
get_domtext_width(node, atts, tr_state);
break;
case TAG_SVG_tspan:
get_tspan_width(node, tr_state);
break;
case TAG_SVG_switch:
is_switch = GF_TRUE;
case TAG_SVG_a:
child = ((GF_ParentNode *)node)->children;
while (child) {
if (is_switch) {
SVGAllAttributes a_atts;
gf_svg_flatten_attributes((SVG_Element*)child->node, &a_atts);
if (compositor_svg_evaluate_conditional(tr_state->visual->compositor, &a_atts)) {
svg_compute_text_width(child->node, atts, tr_state);
break;
}
} else {
svg_compute_text_width(child->node, atts, tr_state);
}
child = child->next;
}
break;
default:
break;
}
}
GF_EXPORT
Bool gf_smil_timing_is_active(GF_Node *node)
{
SMILTimingAttributesPointers *timingp = NULL;
u32 tag = gf_node_get_tag(node);
if ((tag>=GF_NODE_RANGE_FIRST_SVG) && (tag<=GF_NODE_RANGE_LAST_SVG)) {
timingp = ((SVGTimedAnimBaseElement *)node)->timingp;
}
#ifdef GPAC_ENABLE_SVG_SA
else if ((tag>=GF_NODE_RANGE_FIRST_SVG_SA) && (tag<=GF_NODE_RANGE_LAST_SVG_SA)) {
timingp = ((SVG_SA_Element *)node)->timingp;
}
#endif
#ifdef GPAC_ENABLE_SVG_SANI
else if ((tag>=GF_NODE_RANGE_FIRST_SVG_SANI) && (tag<=GF_NODE_RANGE_LAST_SVG_SANI)) {
timingp = ((SVG_SANI_Element *)node)->timingp;
}
#endif
else {
return 0;
}
if (!timingp || !timingp->runtime) return 0;
return (timingp->runtime->status == SMIL_STATUS_ACTIVE);
}
void compositor_imagetexture_modified(GF_Node *node)
{
MFURL url;
SFURL sfurl;
GF_TextureHandler *txh = (GF_TextureHandler *) gf_node_get_private(node);
if (!txh) return;
if (gf_node_get_tag(node)!=TAG_MPEG4_CacheTexture) {
url = ((M_ImageTexture *) node)->url;
} else {
url.count = 1;
sfurl.OD_ID=GF_MEDIA_EXTERNAL_ID;
sfurl.url = ((M_CacheTexture *) node)->image.buffer;
url.vals = &sfurl;
}
/*if open and changed, stop and play*/
if (txh->is_open) {
if (! gf_sc_texture_check_url_change(txh, &url)) return;
gf_sc_texture_stop(txh);
gf_sc_texture_play(txh, &url);
return;
}
/*if not open and changed play*/
if (url.count)
gf_sc_texture_play(txh, &url);
}
static GF_Err BM_ParseGlobalQuantizer(GF_BifsDecoder *codec, GF_BitStream *bs, GF_List *com_list)
{
GF_Node *node;
GF_Command *com;
GF_CommandField *inf;
node = gf_bifs_dec_node(codec, bs, NDT_SFWorldNode);
/*reset global QP*/
if (codec->scenegraph->global_qp) {
gf_node_unregister(codec->scenegraph->global_qp, NULL);
}
codec->ActiveQP = NULL;
codec->scenegraph->global_qp = NULL;
if (node && (gf_node_get_tag(node) != TAG_MPEG4_QuantizationParameter)) {
gf_node_unregister(node, NULL);
return GF_NON_COMPLIANT_BITSTREAM;
}
/*register global QP*/
codec->ActiveQP = (M_QuantizationParameter *) node;
codec->ActiveQP->isLocal = 0;
codec->scenegraph->global_qp = node;
if (node) {
/*register TWICE: once for the command, and for the scenegraph globalQP*/
node->sgprivate->num_instances = 2;
}
com = gf_sg_command_new(codec->current_graph, GF_SG_GLOBAL_QUANTIZER);
inf = gf_sg_command_field_new(com);
inf->new_node = node;
inf->field_ptr = &inf->new_node;
inf->fieldType = GF_SG_VRML_SFNODE;
gf_list_add(com_list, com);
return GF_OK;
}
static void get_tspan_width(GF_Node *node, void *rs)
{
SVGPropertiesPointers backup_props;
u32 backup_flags;
GF_TraverseState *tr_state = (GF_TraverseState *)rs;
SVG_Element *tspan = (SVG_Element *)node;
SVGAllAttributes atts;
GF_ChildNodeItem *child;
gf_svg_flatten_attributes(tspan, &atts);
if (!compositor_svg_traverse_base(node, &atts, tr_state, &backup_props, &backup_flags))
return;
child = ((GF_ParentNode *) tspan)->children;
while (child) {
switch (gf_node_get_tag(child->node)) {
case TAG_DOMText:
get_domtext_width(child->node, &atts, tr_state);
break;
case TAG_SVG_tspan:
get_tspan_width(child->node, tr_state);
break;
default:
break;
}
child=child->next;
}
memcpy(tr_state->svg_props, &backup_props, sizeof(SVGPropertiesPointers));
tr_state->svg_flags = backup_flags;
}
GF_Err gf_sc_get_viewpoint(GF_Compositor *compositor, u32 viewpoint_idx, const char **outName, Bool *is_bound)
{
#ifndef GPAC_DISABLE_VRML
u32 count;
GF_Node *n;
if (!compositor->visual) return GF_BAD_PARAM;
count = gf_list_count(compositor->visual->view_stack);
if (!viewpoint_idx) return GF_BAD_PARAM;
if (viewpoint_idx>count) return GF_EOS;
n = (GF_Node*)gf_list_get(compositor->visual->view_stack, viewpoint_idx-1);
switch (gf_node_get_tag(n)) {
case TAG_MPEG4_Viewport:
*outName = ((M_Viewport*)n)->description.buffer;
*is_bound = ((M_Viewport*)n)->isBound;
return GF_OK;
case TAG_MPEG4_Viewpoint:
#ifndef GPAC_DISABLE_X3D
case TAG_X3D_Viewpoint:
#endif
*outName = ((M_Viewpoint*)n)->description.buffer;
*is_bound = ((M_Viewpoint*)n)->isBound;
return GF_OK;
default:
*outName = NULL;
return GF_OK;
}
#else
return GF_NOT_SUPPORTED;
#endif
}
GF_List *Bindable_GetStack(GF_Node *bindable)
{
void *st;
if (!bindable) return 0;
st = gf_node_get_private(bindable);
switch (gf_node_get_tag(bindable)) {
case TAG_MPEG4_Background2D:
return ((Background2DStack*)st)->reg_stacks;
case TAG_MPEG4_Viewport:
case TAG_MPEG4_NavigationInfo:
#ifndef GPAC_DISABLE_X3D
case TAG_X3D_NavigationInfo:
#endif
return ((ViewStack*)st)->reg_stacks;
#ifndef GPAC_DISABLE_3D
case TAG_MPEG4_Background:
#ifndef GPAC_DISABLE_X3D
case TAG_X3D_Background:
#endif
return ((BackgroundStack*)st)->reg_stacks;
case TAG_MPEG4_Viewpoint:
case TAG_MPEG4_Fog:
#ifndef GPAC_DISABLE_X3D
case TAG_X3D_Viewpoint:
case TAG_X3D_Fog:
#endif
return ((ViewStack*)st)->reg_stacks;
#endif
default:
return NULL;
}
}
Bool Bindable_GetIsBound(GF_Node *bindable)
{
if (!bindable) return GF_FALSE;
switch (gf_node_get_tag(bindable)) {
case TAG_MPEG4_Background2D:
return ((M_Background2D*)bindable)->isBound;
case TAG_MPEG4_Viewport:
return ((M_Viewport*)bindable)->isBound;
case TAG_MPEG4_Background:
#ifndef GPAC_DISABLE_X3D
case TAG_X3D_Background:
#endif
return ((M_Background*)bindable)->isBound;
case TAG_MPEG4_NavigationInfo:
#ifndef GPAC_DISABLE_X3D
case TAG_X3D_NavigationInfo:
#endif
return ((M_NavigationInfo*)bindable)->isBound;
case TAG_MPEG4_Viewpoint:
#ifndef GPAC_DISABLE_X3D
case TAG_X3D_Viewpoint:
#endif
return ((M_Viewpoint*)bindable)->isBound;
case TAG_MPEG4_Fog:
#ifndef GPAC_DISABLE_X3D
case TAG_X3D_Fog:
#endif
return ((M_Fog*)bindable)->isBound;
default:
return GF_FALSE;
}
}
static Bool svg_font_uri_check(GF_Node *node, FontURIStack *st)
{
GF_Font *font;
GF_Node *font_elt;
SVGAllAttributes atts;
gf_svg_flatten_attributes((SVG_Element*)node, &atts);
if (!atts.xlink_href) return 0;
if (atts.xlink_href->type == XMLRI_ELEMENTID) {
if (!atts.xlink_href->target) atts.xlink_href->target = gf_sg_find_node_by_name(gf_node_get_graph(node), atts.xlink_href->string+1);
} else {
GF_SceneGraph *ext_sg;
char *font_name = strchr(atts.xlink_href->string, '#');
if (!font_name) return 0;
if (!st->mo) {
st->mo = gf_mo_load_xlink_resource(node, 0, 0, -1);
if (!st->mo) return 0;
}
ext_sg = gf_mo_get_scenegraph(st->mo);
if (!ext_sg) return 0;
atts.xlink_href->target = gf_sg_find_node_by_name(ext_sg, font_name+1);
if (!atts.xlink_href->target) return 0;
}
font_elt = atts.xlink_href->target;
if (gf_node_get_tag(font_elt) != TAG_SVG_font) return 0;
font = gf_node_get_private(font_elt);
if (!font) return 0;
st->alias = font;
gf_mo_is_done(st->mo);
font->not_loaded = 0;
return 1;
}
static void imagetexture_destroy(GF_Node *node, void *rs, Bool is_destroy)
{
if (is_destroy) {
GF_TextureHandler *txh = (GF_TextureHandler *) gf_node_get_private(node);
/*cleanup cache if needed*/
if (gf_node_get_tag(node)==TAG_MPEG4_CacheTexture) {
char section[64];
const char *opt, *file;
Bool delete_file = 1;
M_CacheTexture *ct = (M_CacheTexture*)node;
sprintf(section, "@cache=%p", ct);
file = gf_cfg_get_key(txh->compositor->user->config, section, "cacheFile");
opt = gf_cfg_get_key(txh->compositor->user->config, section, "expireAfterNTP");
if (opt) {
u32 sec, frac, exp;
sscanf(opt, "%u", &exp);
gf_net_get_ntp(&sec, &frac);
if (!exp || (exp>sec)) delete_file=0;
}
if (delete_file) {
gf_delete_file((char*)file);
gf_cfg_del_section(txh->compositor->user->config, section);
}
if (txh->data) gf_free(txh->data);
txh->data = NULL;
}
gf_sc_texture_destroy(txh);
gf_free(txh);
}
}
Bool gf_svg_is_property(GF_Node *node, GF_FieldInfo *target_attribute)
{
u32 tag = gf_node_get_tag(node);
if (tag > GF_NODE_RANGE_LAST_VRML) {
SVG_Element *e = (SVG_Element *)node;
SVGAttribute *att = e->attributes;
while (att) {
if (att->data == target_attribute->far_ptr) break;
att = att->next;
}
if (!att) return 0;
switch (att->tag) {
case TAG_SVG_ATT_audio_level:
case TAG_SVG_ATT_color:
case TAG_SVG_ATT_color_rendering:
case TAG_SVG_ATT_display:
case TAG_SVG_ATT_display_align:
case TAG_SVG_ATT_fill:
case TAG_SVG_ATT_fill_opacity:
case TAG_SVG_ATT_fill_rule:
case TAG_SVG_ATT_font_family:
case TAG_SVG_ATT_font_size:
case TAG_SVG_ATT_font_style:
case TAG_SVG_ATT_font_variant:
case TAG_SVG_ATT_font_weight:
case TAG_SVG_ATT_image_rendering:
case TAG_SVG_ATT_line_increment:
case TAG_SVG_ATT_opacity:
case TAG_SVG_ATT_pointer_events:
case TAG_SVG_ATT_shape_rendering:
case TAG_SVG_ATT_solid_color:
case TAG_SVG_ATT_solid_opacity:
case TAG_SVG_ATT_stop_color:
case TAG_SVG_ATT_stop_opacity:
case TAG_SVG_ATT_stroke:
case TAG_SVG_ATT_stroke_dasharray:
case TAG_SVG_ATT_stroke_dashoffset:
case TAG_SVG_ATT_stroke_linecap:
case TAG_SVG_ATT_stroke_linejoin:
case TAG_SVG_ATT_stroke_miterlimit:
case TAG_SVG_ATT_stroke_opacity:
case TAG_SVG_ATT_stroke_width:
case TAG_SVG_ATT_text_align:
case TAG_SVG_ATT_text_anchor:
case TAG_SVG_ATT_text_rendering:
case TAG_SVG_ATT_vector_effect:
case TAG_SVG_ATT_viewport_fill:
case TAG_SVG_ATT_viewport_fill_opacity:
case TAG_SVG_ATT_visibility:
return 1;
default:
return 0;
}
}
else {
return 0;
}
}
GF_SensorHandler *compositor_mpeg4_get_sensor_handler(GF_Node *n)
{
GF_SensorHandler *hs;
switch (gf_node_get_tag(n)) {
/*anchor is not considered as a child sensor node when picking sensors*/
case TAG_MPEG4_Anchor:
hs = gf_sc_anchor_get_handler(n);
break;
#ifndef GPAC_DISABLE_X3D
case TAG_X3D_Anchor:
hs = gf_sc_anchor_get_handler(n);
break;
#endif
case TAG_MPEG4_DiscSensor:
hs = disc_sensor_get_handler(n);
break;
case TAG_MPEG4_PlaneSensor2D:
hs = plane_sensor2d_get_handler(n);
break;
case TAG_MPEG4_ProximitySensor2D:
hs = proximity_sensor2d_get_handler(n);
break;
case TAG_MPEG4_TouchSensor:
hs = touch_sensor_get_handler(n);
break;
#ifndef GPAC_DISABLE_X3D
case TAG_X3D_TouchSensor:
hs = touch_sensor_get_handler(n);
break;
#endif
#ifndef GPAC_DISABLE_3D
case TAG_MPEG4_CylinderSensor:
hs = cylinder_sensor_get_handler(n);
break;
case TAG_MPEG4_PlaneSensor:
hs = plane_sensor_get_handler(n);
break;
case TAG_MPEG4_SphereSensor:
hs = sphere_get_handler(n);
break;
#ifndef GPAC_DISABLE_X3D
case TAG_X3D_CylinderSensor:
hs = cylinder_sensor_get_handler(n);
break;
case TAG_X3D_PlaneSensor:
hs = plane_sensor_get_handler(n);
break;
case TAG_X3D_SphereSensor:
hs = sphere_get_handler(n);
break;
#endif
#endif /*GPAC_DISABLE_3D*/
default: return NULL;
}
if (hs && hs->IsEnabled(n)) return hs;
return NULL;
}
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);
}
}
void BD_CheckSFTimeOffset(GF_BifsDecoder *codec, GF_Node *node, GF_FieldInfo *inf)
{
if (gf_node_get_tag(node) != TAG_ProtoNode) {
if (!stricmp(inf->name, "startTime") || !stricmp(inf->name, "stopTime"))
BD_OffsetSFTime(codec, (Double *)inf->far_ptr);
} else if (gf_sg_proto_field_is_sftime_offset(node, inf)) {
BD_OffsetSFTime(codec, (Double *)inf->far_ptr);
}
}
static Bool text_is_3d_material(GF_TraverseState *tr_state)
{
GF_Node *__mat;
if (!tr_state->appear) return 0;
__mat = ((M_Appearance *)tr_state->appear)->material;
if (!__mat) return 0;
if (gf_node_get_tag(__mat)==TAG_MPEG4_Material2D) return 0;
return 1;
}
void SFCommandBufferChanged(GF_BifsDecoder * codec, GF_Node *node)
{
void Conditional_BufferReplaced(GF_BifsDecoder * codec, GF_Node *node);
switch (gf_node_get_tag(node)) {
case TAG_MPEG4_Conditional:
Conditional_BufferReplaced(codec, node);
break;
}
}
GF_Err gf_bifs_dec_qp_set(GF_BifsDecoder *codec, GF_Node *qp)
{
assert(gf_node_get_tag(qp) == TAG_MPEG4_QuantizationParameter);
/*if we have an active QP, push it into the stack*/
if (codec->ActiveQP && ((GF_Node*)codec->ActiveQP != codec->scenegraph->global_qp) )
gf_list_insert(codec->QPs, codec->ActiveQP, 0);
codec->ActiveQP = (M_QuantizationParameter *)qp;
return GF_OK;
}
void CTXLoad_NodeCallback(void *cbk, u32 type, GF_Node *node, void *param)
{
if ((type==GF_SG_CALLBACK_INIT) && (gf_node_get_tag(node) == TAG_MPEG4_Conditional) ) {
M_Conditional*c = (M_Conditional*)node;
c->on_activate = CTXLoad_OnActivate;
c->on_reverseActivate = CTXLoad_OnReverseActivate;
gf_node_set_private(node, cbk);
} else {
gf_term_node_callback(cbk, type, node, param);
}
}
GF_TextureHandler *R2D_GetTextureHandler(GF_Node *n)
{
if (!n) return NULL;
switch (gf_node_get_tag(n)) {
case TAG_MPEG4_CompositeTexture2D: return ct2D_get_texture(n);
case TAG_MPEG4_MatteTexture: return r2d_matte_get_texture(n);
case TAG_MPEG4_LinearGradient: return r2d_lg_get_texture(n);
case TAG_MPEG4_RadialGradient: return r2d_rg_get_texture(n);
default: return gf_sr_texture_get_handler(n);
}
}
GF_EXPORT
GF_TextureHandler *gf_sc_texture_get_handler(GF_Node *n)
{
if (!n) return NULL;
switch (gf_node_get_tag(n)) {
#ifndef GPAC_DISABLE_VRML
case TAG_MPEG4_ImageTexture:
case TAG_MPEG4_CacheTexture:
return it_get_texture(n);
case TAG_MPEG4_MovieTexture:
return mt_get_texture(n);
case TAG_MPEG4_PixelTexture:
return pt_get_texture(n);
case TAG_MPEG4_CompositeTexture2D:
case TAG_MPEG4_CompositeTexture3D:
return compositor_get_composite_texture(n);
case TAG_MPEG4_LinearGradient:
case TAG_MPEG4_RadialGradient:
return compositor_mpeg4_get_gradient_texture(n);
case TAG_MPEG4_MatteTexture:
{
GF_TextureHandler *hdl = gf_sc_texture_get_handler( ((M_MatteTexture*)n)->surfaceB );
if (hdl) hdl->matteTexture = n;
return hdl;
}
#endif /*GPAC_DISABLE_VRML*/
#ifndef GPAC_DISABLE_X3D
case TAG_X3D_ImageTexture:
return it_get_texture(n);
case TAG_X3D_MovieTexture:
return mt_get_texture(n);
case TAG_X3D_PixelTexture:
return pt_get_texture(n);
#endif
#ifndef GPAC_DISABLE_SVG
case TAG_SVG_linearGradient:
case TAG_SVG_radialGradient:
return compositor_svg_get_gradient_texture(n);
case TAG_SVG_image:
case TAG_SVG_video:
return compositor_svg_get_image_texture(n);
#endif
case TAG_ProtoNode:
return gf_sc_hardcoded_proto_get_texture_handler(n);
default:
return NULL;
}
}
Bool compositor_svg_get_viewport(GF_Node *n, GF_Rect *rc)
{
SVGsvgStack *stack;
if (gf_node_get_tag(n) != TAG_SVG_svg) return 0;
stack = gf_node_get_private(n);
rc->width = stack->parent_vp.x;
rc->height = stack->parent_vp.y;
/*not supported yet*/
rc->x = rc->y = 0;
return 1;
}
Bool compositor_is_composite_texture(GF_Node *appear)
{
u32 tag;
if (!appear) return 0;
tag = gf_node_get_tag(appear);
if ((tag==TAG_MPEG4_Appearance)
#ifndef GPAC_DISABLE_X3D
|| (tag==TAG_X3D_Appearance)
#endif
) {
M_Appearance *ap = (M_Appearance *)appear;
if (!ap->texture) return 0;
switch (gf_node_get_tag(((M_Appearance *)appear)->texture)) {
case TAG_MPEG4_CompositeTexture2D:
case TAG_MPEG4_CompositeTexture3D:
return 1;
}
}
return 0;
}
void compositor_init_afx_node(GF_Compositor *compositor, GF_Node *node, MFURL *url)
{
GF_MediaObject *mo = gf_mo_register(node, url, 0, 0);
if (!mo) {
GF_LOG(GF_LOG_WARNING, GF_LOG_COMPOSE, ("[Compositor] AFX Decoder not found for node %s - node may not be completely/correctly rendered\n", gf_node_get_class_name(node)));
}
#ifndef GPAC_DISABLE_VRML
if (gf_node_get_tag(node)==TAG_MPEG4_BitWrapper) {
compositor_init_bitwrapper(compositor, node);
}
#endif
}
void node_init(void *cbk, GF_Node *node)
{
BIFSVID *b2v = cbk;
switch (gf_node_get_tag(node)) {
case TAG_MPEG4_Conditional:
case TAG_MPEG4_QuantizationParameter:
break;
default:
if (b2v->sr) gf_sc_on_node_init(b2v->sr, node);
break;
}
}
void svg_filter_apply(GF_Node *node, GF_TextureHandler *source, GF_Rect *region)
{
GF_ChildNodeItem *l = ((GF_ParentNode*)node)->children;
while (l) {
switch (gf_node_get_tag(l->node)) {
case TAG_SVG_feComponentTransfer:
apply_feComponentTransfer(l->node, source, region);
break;
}
l = l->next;
}
}
Bool compositor_background_transparent(GF_Node *node)
{
if (node && (gf_node_get_tag(node) == TAG_MPEG4_Background2D)) {
Background2DStack *st;
if (!((M_Background2D *)node)->isBound) return 1;
st = (Background2DStack *) gf_node_get_private(node);
if (st->txh.transparent) return 1;
return 0;
}
/*consider all other background nodes transparent*/
return 1;
}
void InitTimeSensor(GF_Renderer *sr, GF_Node *node)
{
TimeSensorStack *st;
GF_SAFEALLOC(st, TimeSensorStack);
st->time_handle.UpdateTimeNode = UpdateTimeSensor;
st->time_handle.obj = node;
st->store_info = 1;
st->compositor = sr;
st->is_x3d = (gf_node_get_tag(node)==TAG_X3D_TimeSensor) ? 1 : 0;
gf_node_set_private(node, st);
gf_node_set_callback_function(node, DestroyTimeSensor);
/*time sensor needs to be run only if def'ed, otherwise it doesn't impact scene*/
if (gf_node_get_id(node)) gf_sr_register_time_node(sr, &st->time_handle);
}
static void SG_CheckFieldChange(GF_Node *node, GF_FieldInfo *field)
{
/*and propagate eventIn if any*/
if (field->on_event_in) {
field->on_event_in(node);
} else if ((field->eventType==GF_SG_EVENT_IN) && (gf_node_get_tag(node) == TAG_MPEG4_Script)) {
gf_sg_script_event_in(node, field);
} else {
/*Notify eventOut in all cases to handle protos*/
gf_node_event_out(node, field->fieldIndex);
}
/*signal node modif*/
gf_node_changed(node, field);
}
