static void TraverseFog(GF_Node *node, void *rs, Bool is_destroy)
{
Fixed density, vrange;
SFVec3f start, end;
ViewStack *vp_st;
M_Viewpoint *vp;
GF_TraverseState *tr_state = (GF_TraverseState *)rs;
M_Fog *fog = (M_Fog *) node;
ViewStack *st = (ViewStack *) gf_node_get_private(node);
if (is_destroy) {
DestroyViewStack(node);
return;
}
if (!tr_state->fogs) return;
/*first traverse, bound if needed*/
if (gf_list_find(tr_state->fogs, node) < 0) {
gf_list_add(tr_state->fogs, node);
if (gf_list_get(tr_state->fogs, 0) == fog) {
if (!fog->isBound) Bindable_SetIsBound(node, 1);
}
assert(gf_list_find(st->reg_stacks, tr_state->fogs)==-1);
gf_list_add(st->reg_stacks, tr_state->fogs);
gf_mx_copy(st->world_view_mx, tr_state->model_matrix);
/*in any case don't draw the first time*/
gf_sc_invalidate(tr_state->visual->compositor, NULL);
return;
}
/*not evaluating, return*/
if (tr_state->traversing_mode != TRAVERSE_BINDABLE) {
if ((tr_state->traversing_mode==TRAVERSE_SORT) || (tr_state->traversing_mode==TRAVERSE_GET_BOUNDS) )
gf_mx_copy(st->world_view_mx, tr_state->model_matrix);
return;
}
/*not bound*/
if (!fog->isBound || !fog->visibilityRange) return;
/*fog visibility is expressed in current bound VP so get its matrix*/
vp = (M_Viewpoint*)gf_list_get(tr_state->viewpoints, 0);
vp_st = NULL;
if (vp && vp->isBound) vp_st = (ViewStack *) gf_node_get_private((GF_Node *)vp);
start.x = start.y = start.z = 0;
end.x = end.y = 0;
end.z = fog->visibilityRange;
if (vp_st) {
gf_mx_apply_vec(&vp_st->world_view_mx, &start);
gf_mx_apply_vec(&vp_st->world_view_mx, &end);
}
gf_mx_apply_vec(&st->world_view_mx, &start);
gf_mx_apply_vec(&st->world_view_mx, &end);
gf_vec_diff(end, end, start);
vrange = gf_vec_len(end);
density = gf_invfix(vrange);
visual_3d_set_fog(tr_state->visual, fog->fogType.buffer, fog->color, density, vrange);
}
void gf_sr_register_extra_graph(GF_Renderer *sr, GF_SceneGraph *extra_scene, Bool do_remove)
{
gf_sr_lock(sr, 1);
if (do_remove) gf_list_del_item(sr->extra_scenes, extra_scene);
else if (gf_list_find(sr->extra_scenes, extra_scene)<0) gf_list_add(sr->extra_scenes, extra_scene);
gf_sr_lock(sr, 0);
}
static void IS_Register(GF_Node *n)
{
GF_ObjectManager *odm;
ISPriv *is_dec;
u32 i;
ISStack *st = (ISStack *)gf_node_get_private(n);
odm = st->mo->odm;
if (!odm) return;
assert(odm->codec && (odm->codec->type == GF_STREAM_INTERACT));
/*get IS dec*/
is_dec = (ISPriv*)odm->codec->decio->privateStack;
if ( gf_list_find(is_dec->is_nodes, st) == -1 )
gf_list_add(is_dec->is_nodes, st);
/*start stream*/
gf_mo_play(st->mo, 0, -1, 0);
gf_term_unqueue_node_traverse(odm->term, n);
/*we want at least one sensor enabled*/
i=0;
while ((st = gf_list_enum(is_dec->is_nodes, &i))) {
if (st->is->enabled) {
st->registered = 1;
if (is_dec->io_dev && is_dec->io_dev->Start) is_dec->io_dev->Start(is_dec->io_dev);
break;
}
}
}
GF_EXPORT
s32 gf_list_del_item(GF_List *ptr, void *item)
{
s32 i = gf_list_find(ptr, item);
if (i>=0) gf_list_rem(ptr, (u32) i);
return i;
}
GF_Descriptor *RP_EmulateIOD(RTPClient *rtp, const char *sub_url)
{
GF_ObjectDescriptor *the_od;
RTPStream *a_str, *ch;
u32 i;
if (rtp->media_type==GF_MEDIA_OBJECT_INTERACT) return NULL;
if (rtp->media_type==GF_MEDIA_OBJECT_UPDATES) return NULL;
/*single object generation*/
a_str = NULL;
if (sub_url || ((rtp->media_type != GF_MEDIA_OBJECT_SCENE) && (rtp->media_type != GF_MEDIA_OBJECT_UNDEF)) ) {
i=0;
while ((ch = (RTPStream *)gf_list_enum(rtp->channels, &i))) {
if (ch->depacketizer->sl_map.StreamType != get_stream_type_from_hint(rtp->media_type)) continue;
if (!sub_url || (ch->control && strstr(sub_url, ch->control)) ) {
the_od = RP_GetChannelOD(ch, i-1);
if (!the_od) continue;
return (GF_Descriptor *) the_od;
}
if (!a_str) a_str = ch;
}
if (a_str) {
the_od = RP_GetChannelOD(a_str, gf_list_find(rtp->channels, a_str) );
return (GF_Descriptor *) the_od;
}
return NULL;
}
return NULL;
}
void gf_mse_remove_active_source_buffer(GF_HTML_MediaSource *ms, GF_HTML_SourceBuffer *sb) {
s32 activePos;
activePos = gf_list_find(ms->activeSourceBuffers.list, sb);
if (activePos >= 0) {
gf_list_rem(ms->activeSourceBuffers.list, activePos);
gf_mse_fire_event(ms->activeSourceBuffers.evt_target, GF_EVENT_HTML_MSE_REMOVE_SOURCE_BUFFER);
}
}
GF_EXPORT
void gf_node_register_iri(GF_SceneGraph *sg, XMLRI *target)
{
#ifndef GPAC_DISABLE_SVG
if (gf_list_find(sg->xlink_hrefs, target)<0) {
gf_list_add(sg->xlink_hrefs, target);
}
#endif
}
GF_EXPORT
void gf_sc_texture_setup(GF_TextureHandler *txh, GF_Compositor *compositor, GF_Node *owner)
{
memset(txh, 0, sizeof(GF_TextureHandler));
txh->owner = owner;
txh->compositor = compositor;
/*insert texture in reverse order, so that textures in sub documents/scenes are updated before parent ones*/
if (gf_list_find(compositor->textures, txh)<0)
gf_list_insert(compositor->textures, txh, 0);
if (!txh->update_texture_fcnt) txh->update_texture_fcnt = update_texture_void;
}
/* when a timed element restarts, since the list of timed elements in the scene graph,
to which scene time is notified at each rendering cycle, is sorted, we need to remove
and reinsert this timed element as if it was a new one, to make sure the sorting is correct */
static void gf_smil_mark_modified(SMIL_Timing_RTI *rti, Bool remove)
{
GF_SceneGraph * sg = rti->timed_elt->sgprivate->scenegraph;
while (sg->parent_scene) sg = sg->parent_scene;
if (remove) {
gf_list_del_item(sg->modified_smil_timed_elements, rti);
} else {
if (gf_list_find(sg->modified_smil_timed_elements, rti) == -1) {
gf_list_add(sg->modified_smil_timed_elements, rti);
}
}
}
GF_EXPORT
GF_Err gf_modules_close_interface(GF_BaseInterface *ifce)
{
ModuleInstance *par;
s32 i;
if (!ifce) return GF_BAD_PARAM;
par = (ModuleInstance *) ifce->HPLUG;
if (!par || !ifce->InterfaceType) return GF_BAD_PARAM;
i = gf_list_find(par->plugman->plug_list, par);
if (i<0) return GF_BAD_PARAM;
i = gf_list_find(par->interfaces, ifce);
if (i<0) return GF_BAD_PARAM;
gf_list_rem(par->interfaces, (u32) i);
par->destroy_func(ifce);
gf_modules_unload_library(par);
//GF_LOG(GF_LOG_DEBUG, GF_LOG_CORE, ("[Core] interface %s unloaded\n", ifce->module_name));
return GF_OK;
}
Bool gf_codec_remove_channel(GF_Codec *codec, struct _es_channel *ch)
{
s32 i;
assert( codec );
assert( codec->inChannels);
assert(ch);
i = gf_list_find(codec->inChannels, ch);
if (i>=0) {
if (codec->decio) codec->decio->DetachStream(codec->decio, ch->esd->ESID);
gf_list_rem(codec->inChannels, (u32) i);
return 1;
}
return 0;
}
void BindableStackDelete(GF_List *stack)
{
while (gf_list_count(stack)) {
GF_List *bind_stack_list;
GF_Node *bindable = (GF_Node*)gf_list_get(stack, 0);
gf_list_rem(stack, 0);
bind_stack_list = Bindable_GetStack(bindable);
if (bind_stack_list) {
gf_list_del_item(bind_stack_list, stack);
assert(gf_list_find(bind_stack_list, stack)<0);
}
}
gf_list_del(stack);
}
GF_Err gf_mse_remove_source_buffer(GF_HTML_MediaSource *ms, GF_HTML_SourceBuffer *sb) {
s32 pos;
pos = gf_list_find(ms->sourceBuffers.list, sb);
if (pos < 0) {
return GF_NOT_FOUND;
} else {
gf_mse_source_buffer_abort(sb);
/* TODO: update the audio/video/text tracks */
gf_mse_remove_active_source_buffer(ms, sb);
gf_list_rem(ms->sourceBuffers.list, pos);
gf_mse_fire_event(ms->sourceBuffers.evt_target, GF_EVENT_HTML_MSE_REMOVE_SOURCE_BUFFER);
gf_mse_source_buffer_del(sb);
}
return GF_OK;
}
static void on_dom_node_end(void *cbk, const char *name, const char *ns)
{
GF_DOMParser *par = (GF_DOMParser *)cbk;
GF_XMLNode *last = (GF_XMLNode *)gf_list_last(par->stack);
gf_list_rem_last(par->stack);
if (!last || strcmp(last->name, name) || (!ns && last->ns) || (ns && !last->ns) || (ns && strcmp(last->ns, ns) ) ) {
par->parser->suspended = 1;
gf_xml_dom_node_del(last);
if (last==par->root) par->root=NULL;
return;
}
if (last != par->root) {
GF_XMLNode *node = (GF_XMLNode *)gf_list_last(par->stack);
assert(node->content);
assert(gf_list_find(node->content, last) == -1);
gf_list_add(node->content, last);
}
}
static void on_dom_node_end(void *cbk, const char *name, const char *ns)
{
GF_DOMParser *par = (GF_DOMParser *)cbk;
GF_XMLNode *last = (GF_XMLNode *)gf_list_last(par->stack);
gf_list_rem_last(par->stack);
if (!last || strcmp(last->name, name) || (!ns && last->ns) || (ns && !last->ns) || (ns && strcmp(last->ns, ns) ) ) {
format_sax_error(par->parser, 0, "Invalid node stack: closing node is %s but %s was expected", name, last->name);
par->parser->suspended = 1;
gf_xml_dom_node_del(last);
if (last==par->root) par->root=NULL;
return;
}
if (last != par->root) {
GF_XMLNode *node = (GF_XMLNode *)gf_list_last(par->stack);
assert(node->content);
assert(gf_list_find(node->content, last) == -1);
gf_list_add(node->content, last);
}
}
void gf_odm_set_mediacontrol(GF_ObjectManager *odm, MediaControlStack *ctrl)
{
u32 i;
GF_Channel *ch;
/*keep track of it*/
if (ctrl && (gf_list_find(odm->mc_stack, ctrl) < 0)) gf_list_add(odm->mc_stack, ctrl);
if (ctrl && !ctrl->control->enabled) return;
if (odm->subscene && odm->subscene->is_dynamic_scene) {
if (odm->subscene->dyn_ck) {
/*deactivate current control*/
if (ctrl && odm->subscene->dyn_ck->mc) {
odm->subscene->dyn_ck->mc->control->enabled = 0;
gf_node_event_out((GF_Node *)odm->subscene->dyn_ck->mc->control, 7/*"enabled"*/);
}
odm->subscene->dyn_ck->mc = ctrl;
}
} else {
/*for each clock in the controled OD*/
i=0;
while ((ch = (GF_Channel*)gf_list_enum(odm->channels, &i))) {
if (ch->clock->mc != ctrl) {
/*deactivate current control*/
if (ctrl && ch->clock->mc) {
ch->clock->mc->control->enabled = 0;
gf_node_event_out((GF_Node *)ch->clock->mc->control, 7/*"enabled"*/);
}
/*and attach this control to the clock*/
ch->clock->mc = ctrl;
}
}
}
/*store active control on media*/
odm->media_ctrl = gf_odm_get_mediacontrol(odm);
}
static void TraverseViewpoint(GF_Node *node, void *rs, Bool is_destroy)
{
SFVec3f pos, v1, v2;
SFRotation ori;
GF_Matrix mx;
GF_TraverseState *tr_state = (GF_TraverseState *)rs;
M_Viewpoint *vp = (M_Viewpoint*) node;
ViewStack *st = (ViewStack *) gf_node_get_private(node);
if (is_destroy) {
DestroyViewStack(node);
return;
}
/*may happen in get_bounds*/
if (!tr_state->viewpoints) return;
// if (!tr_state->camera->is_3D) return;
/*first traverse, bound if needed*/
if (gf_list_find(tr_state->viewpoints, node) < 0) {
gf_list_add(tr_state->viewpoints, node);
assert(gf_list_find(st->reg_stacks, tr_state->viewpoints)==-1);
gf_list_add(st->reg_stacks, tr_state->viewpoints);
if (gf_list_get(tr_state->viewpoints, 0) == vp) {
if (!vp->isBound) Bindable_SetIsBound(node, 1);
} else {
if (gf_inline_is_default_viewpoint(node)) Bindable_SetSetBind(node, 1);
}
VPCHANGED(tr_state->visual->compositor);
/*in any case don't draw the first time (since the viewport could have been declared last)*/
if (tr_state->layer3d) gf_node_dirty_set(tr_state->layer3d, GF_SG_VRML_BINDABLE_DIRTY, 0);
gf_sc_invalidate(tr_state->visual->compositor, NULL);
}
/*not evaluating vp, return*/
if (tr_state->traversing_mode != TRAVERSE_BINDABLE) {
/*store model matrix if changed - NOTE: we always have a 1-frame delay between VP used and real world...
we could remove this by pre-traversing the scene before applying vp, but that would mean 2 scene
traversals*/
if ((tr_state->traversing_mode==TRAVERSE_SORT) || (tr_state->traversing_mode==TRAVERSE_GET_BOUNDS) ) {
if (!gf_mx_equal(&st->world_view_mx, &tr_state->model_matrix)) {
gf_mx_copy(st->world_view_mx, tr_state->model_matrix);
gf_node_dirty_set(node, 0, 0);
}
}
return;
}
/*not bound or in 2D visual*/
if (!vp->isBound || !tr_state->navigations) return;
if (!gf_node_dirty_get(node)) return;
gf_node_dirty_clear(node, 0);
/*move to local system*/
gf_mx_copy(mx, st->world_view_mx);
gf_mx_add_translation(&mx, vp->position.x, vp->position.y, vp->position.z);
gf_mx_add_rotation(&mx, vp->orientation.q, vp->orientation.x, vp->orientation.y, vp->orientation.z);
gf_mx_decompose(&mx, &pos, &v1, &ori, &v2);
/*get center*/
v1.x = v1.y = v1.z = 0;
#ifndef GPAC_DISABLE_X3D
/*X3D specifies examine center*/
if (gf_node_get_tag(node)==TAG_X3D_Viewpoint) v1 = ((X_Viewpoint *)node)->centerOfRotation;
#endif
gf_mx_apply_vec(&st->world_view_mx, &v1);
/*set frustrum param - animate only if not bound last frame and jump false*/
visual_3d_viewpoint_change(tr_state, node, (!st->prev_was_bound && !vp->jump) ? 1 : 0, vp->fieldOfView, pos, ori, v1);
st->prev_was_bound = 1;
}
void gf_inline_on_modified(GF_Node *node)
{
u32 ODID;
GF_MediaObject *mo;
M_Inline *pInline = (M_Inline *) node;
GF_Scene *scene = (GF_Scene *)gf_node_get_private(node);
ODID = gf_mo_get_od_id(&pInline->url);
if (scene) {
mo = (scene->root_od) ? scene->root_od->mo : NULL;
/*disconnect current inline if we're the last one using it (same as regular OD session leave/join)*/
if (mo) {
Bool changed = GF_TRUE;
if (ODID != GF_MEDIA_EXTERNAL_ID) {
if (ODID && (ODID==scene->root_od->OD->objectDescriptorID)) changed = GF_FALSE;
} else {
if (gf_mo_is_same_url(mo, &pInline->url, NULL, 0) ) changed = GF_FALSE;
}
if (mo->num_open) {
if (!changed) return;
gf_scene_notify_event(scene, GF_EVENT_UNLOAD, node, NULL, GF_OK, GF_TRUE);
gf_node_dirty_parents(node);
gf_mo_event_target_remove_by_node(mo, node);
/*reset the scene pointer as it may get destroyed*/
switch (gf_node_get_tag(node)) {
case TAG_MPEG4_Inline:
#ifndef GPAC_DISABLE_X3D
case TAG_X3D_Inline:
#endif
gf_node_set_private(node, NULL);
break;
}
mo->num_open --;
if (!mo->num_open) {
if (ODID == GF_MEDIA_EXTERNAL_ID) {
GF_Scene *parent = scene->root_od->parentscene;
/*!!! THIS WILL DESTROY THE INLINE SCENE OBJECT !!!*/
gf_odm_disconnect(scene->root_od, GF_TRUE);
/*and force removal of the media object*/
if (parent) {
if (gf_list_del_item(parent->scene_objects, mo)>=0) {
gf_sg_vrml_mf_reset(&mo->URLs, GF_SG_VRML_MFURL);
gf_mo_del(mo);
}
}
} else {
gf_term_lock_media_queue(scene->root_od->term, GF_TRUE);
/*external media are completely unloaded, except addons which are only declared once */
if (!scene->root_od->addon && (scene->root_od->OD->objectDescriptorID==GF_MEDIA_EXTERNAL_ID)) {
scene->root_od->action_type = GF_ODM_ACTION_DELETE;
} else {
scene->root_od->action_type = GF_ODM_ACTION_STOP;
}
if (gf_list_find(scene->root_od->term->media_queue, scene->root_od)<0)
gf_list_add(scene->root_od->term->media_queue, scene->root_od);
gf_term_lock_media_queue(scene->root_od->term, GF_FALSE);
}
}
}
}
}
/*force a redraw and load scene at next pass - we cannot load the scene now because
- we can be in a JS call (eg JS mutex blocked)
- locating scene objects matching the new url needs exclusive access to the MediaObject list, achieved with the term net mutex
- another service may already be setting up objects (eg exclusive access to the net mutex grabbed), which can trigger event forwarding
- some event forwarders may request JS context (eg access to JS mutex)
In such a case we would end up in a deadlock - this needs urgent fixing ...
*/
if (ODID) {
/*if no parent we must process the url change as we may not be traversed later on (not in the scene tree)*/
if (gf_node_get_parent(node, 0)==NULL) {
gf_inline_set_scene(pInline);
} else {
gf_node_dirty_parents(node);
}
}
}
static void TraverseViewport(GF_Node *node, void *rs, Bool is_destroy)
{
Fixed sx, sy, w, h, tx, ty;
#ifndef GPAC_DISABLE_3D
GF_Matrix mx;
#endif
GF_Matrix2D mat;
GF_Rect rc, rc_bckup;
ViewStack *st = (ViewStack *) gf_node_get_private(node);
M_Viewport *vp = (M_Viewport *) node;
GF_TraverseState *tr_state = (GF_TraverseState *)rs;
if (is_destroy) {
DestroyViewStack(node);
return;
}
#ifndef GPAC_DISABLE_3D
if (tr_state->visual->type_3d>1) return;
#endif
/*first traverse, bound if needed*/
if (gf_list_find(tr_state->viewpoints, node) < 0) {
gf_list_add(tr_state->viewpoints, node);
assert(gf_list_find(st->reg_stacks, tr_state->viewpoints)==-1);
gf_list_add(st->reg_stacks, tr_state->viewpoints);
if (gf_list_get(tr_state->viewpoints, 0) == vp) {
if (!vp->isBound) Bindable_SetIsBound(node, 1);
} else {
if (gf_inline_is_default_viewpoint(node)) Bindable_SetSetBindEx(node, 1, tr_state->viewpoints);
}
VPCHANGED(tr_state->visual->compositor);
/*in any case don't draw the first time (since the viewport could have been declared last)*/
gf_sc_invalidate(tr_state->visual->compositor, NULL);
return;
}
if (tr_state->traversing_mode != TRAVERSE_BINDABLE) return;
if (!vp->isBound) return;
if (gf_list_get(tr_state->viewpoints, 0) != vp)
return;
#ifndef GPAC_DISABLE_3D
if (tr_state->visual->type_3d) {
w = tr_state->bbox.max_edge.x - tr_state->bbox.min_edge.x;
h = tr_state->bbox.max_edge.y - tr_state->bbox.min_edge.y;
} else
#endif
{
w = tr_state->bounds.width;
h = tr_state->bounds.height;
}
if (!w || !h) return;
/*if no parent this is the main viewport, don't update if not changed*/
// if (!tr_state->is_layer && !gf_node_dirty_get(node)) return;
gf_node_dirty_clear(node, 0);
gf_mx2d_init(mat);
gf_mx2d_add_translation(&mat, vp->position.x, vp->position.y);
gf_mx2d_add_rotation(&mat, 0, 0, vp->orientation);
//compute scaling ratio
sx = (vp->size.x>=0) ? vp->size.x : w;
sy = (vp->size.y>=0) ? vp->size.y : h;
rc = gf_rect_center(sx, sy);
rc_bckup = rc;
switch (vp->fit) {
/*covers all area and respect aspect ratio*/
case 2:
if (gf_divfix(rc.width, w) > gf_divfix(rc.height, h)) {
rc.width = gf_muldiv(rc.width, h, rc.height);
rc.height = h;
} else {
rc.height = gf_muldiv(rc.height , w, rc.width);
rc.width = w;
}
break;
/*fits inside the area and respect AR*/
case 1:
if (gf_divfix(rc.width, w)> gf_divfix(rc.height, h)) {
rc.height = gf_muldiv(rc.height, w, rc.width);
rc.width = w;
} else {
rc.width = gf_muldiv(rc.width, h, rc.height);
rc.height = h;
}
break;
/*fit entirely: nothing to change*/
case 0:
rc.width = w;
rc.height = h;
break;
default:
return;
}
sx = gf_divfix(rc.width, rc_bckup.width);
sy = gf_divfix(rc.height, rc_bckup.height);
/*viewport on root visual, remove compositor scale*/
if (!tr_state->is_layer && (tr_state->visual->compositor->visual==tr_state->visual) ) {
sx = gf_divfix(sx, tr_state->visual->compositor->scale_x);
sy = gf_divfix(sy, tr_state->visual->compositor->scale_y);
}
rc.x = - rc.width/2;
rc.y = rc.height/2;
tx = ty = 0;
if (vp->fit && vp->alignment.count) {
/*left alignment*/
if (vp->alignment.vals[0] == -1) tx = rc.width/2 - w/2;
else if (vp->alignment.vals[0] == 1) tx = w/2 - rc.width/2;
if (vp->alignment.count>1) {
/*top-alignment*/
if (vp->alignment.vals[1]==-1) ty = rc.height/2 - h/2;
else if (vp->alignment.vals[1]==1) ty = h/2 - rc.height/2;
}
}
gf_mx2d_init(mat);
if (tr_state->pixel_metrics) {
gf_mx2d_add_scale(&mat, sx, sy);
} else {
/*if we are not in pixelMetrics, undo the meterMetrics->pixelMetrics transformation*/
gf_mx2d_add_scale(&mat, gf_divfix(sx, tr_state->min_hsize), gf_divfix(sy, tr_state->min_hsize) );
}
gf_mx2d_add_translation(&mat, tx, ty);
gf_mx2d_add_translation(&mat, -gf_mulfix(vp->position.x,sx), -gf_mulfix(vp->position.y,sy) );
gf_mx2d_add_rotation(&mat, 0, 0, vp->orientation);
tr_state->bounds = rc;
tr_state->bounds.x += tx;
tr_state->bounds.y += ty;
#ifndef GPAC_DISABLE_3D
if (tr_state->visual->type_3d) {
/*in layers directly modify the model matrix*/
if (tr_state->is_layer) {
gf_mx_from_mx2d(&mx, &mat);
gf_mx_add_matrix(&tr_state->model_matrix, &mx);
}
/*otherwise add to camera viewport matrix*/
else {
gf_mx_from_mx2d(&tr_state->camera->viewport, &mat);
tr_state->camera->flags = (CAM_HAS_VIEWPORT | CAM_IS_DIRTY);
}
} else
#endif
gf_mx2d_pre_multiply(&tr_state->transform, &mat);
}
static void term_on_connect(void *user_priv, GF_ClientService *service, LPNETCHANNEL netch, GF_Err err)
{
GF_Channel *ch;
GF_ObjectManager *root;
GET_TERM();
GF_LOG(GF_LOG_DEBUG, GF_LOG_MEDIA, ("[Terminal] %s connection ACK received from %s - %s\n", netch ? "Channel" : "Service", service->url, gf_error_to_string(err) ));
root = service->owner;
if (root && (root->net_service != service)) {
gf_term_message(term, service->url, "Incompatible module type", GF_SERVICE_ERROR);
return;
}
/*this is service connection*/
if (!netch) {
gf_term_service_media_event(service->owner, GF_EVENT_MEDIA_SETUP_DONE);
if (err) {
char msg[5000];
snprintf(msg, sizeof(msg)-1, "Cannot open %s", service->url);
gf_term_message(term, service->url, msg, err);
gf_term_service_media_event(service->owner, GF_EVENT_ERROR);
/*destroy service only if attached*/
if (root) {
gf_term_lock_media_queue(term, 1);
service->ifce->CloseService(service->ifce);
root->net_service = NULL;
if (service->owner && service->nb_odm_users) service->nb_odm_users--;
service->owner = NULL;
/*depends on module: some module could forget to call gf_term_on_disconnect */
if ( gf_list_del_item(term->net_services, service) >= 0) {
/*and queue for destroy*/
gf_list_add(term->net_services_to_remove, service);
}
gf_term_lock_media_queue(term, 0);
if (!root->parentscene) {
GF_Event evt;
evt.type = GF_EVENT_CONNECT;
evt.connect.is_connected = 0;
gf_term_send_event(term, &evt);
} else {
if (root->subscene) gf_scene_notify_event(root->subscene, GF_EVENT_SCENE_ATTACHED, NULL, NULL, err);
/*try to reinsert OD for VRML/X3D with multiple URLs:
1- first remove from parent scene without destroying object, this will trigger a re-setup
if other URLs are present
2- then destroy object*/
gf_scene_remove_object(root->parentscene, root, 0);
gf_odm_disconnect(root, 1);
}
return;
}
}
if (!root) {
/*channel service connect*/
u32 i;
GF_ChannelSetup *cs;
GF_List *ODs;
if (!gf_list_count(term->channels_pending)) {
return;
}
ODs = gf_list_new();
gf_term_lock_net(term, 1);
i=0;
while ((cs = (GF_ChannelSetup*)gf_list_enum(term->channels_pending, &i))) {
if (cs->ch->service != service) continue;
gf_list_rem(term->channels_pending, i-1);
i--;
/*even if error do setup (channel needs to be deleted)*/
if (gf_odm_post_es_setup(cs->ch, cs->dec, err) == GF_OK) {
if (cs->ch->odm && (gf_list_find(ODs, cs->ch->odm)==-1) ) gf_list_add(ODs, cs->ch->odm);
}
gf_free(cs);
}
gf_term_lock_net(term, 0);
/*finally setup all ODs concerned (we do this later in case of scalability)*/
while (gf_list_count(ODs)) {
GF_ObjectManager *odm = (GF_ObjectManager*)gf_list_get(ODs, 0);
gf_list_rem(ODs, 0);
/*force re-setup*/
gf_scene_setup_object(odm->parentscene, odm);
}
gf_list_del(ODs);
} else {
/*setup od*/
gf_odm_setup_entry_point(root, service->url);
}
/*load cache if requested*/
if (!err && term->enable_cache) {
err = gf_term_service_cache_load(service);
/*not a fatal error*/
if (err) gf_term_message(term, "GPAC Cache", "Cannot load cache", err);
}
return;
}
/*this is channel connection*/
ch = gf_term_get_channel(service, netch);
if (!ch) {
GF_LOG(GF_LOG_ERROR, GF_LOG_MEDIA, ("[Terminal] Channel connection ACK error: channel not found\n"));
return;
}
/*confirm channel connection even if error - this allow playback of objects even if not all streams are setup*/
gf_term_lock_net(term, 1);
gf_es_on_connect(ch);
gf_term_lock_net(term, 0);
if (err && ((err!=GF_STREAM_NOT_FOUND) || (ch->esd->decoderConfig->streamType!=GF_STREAM_INTERACT))) {
GF_LOG(GF_LOG_ERROR, GF_LOG_MEDIA, ("[Terminal] Channel %d connection error: %s\n", ch->esd->ESID, gf_error_to_string(err) ));
ch->es_state = GF_ESM_ES_UNAVAILABLE;
/* return;*/
}
if (ch->odm->mo) {
GF_LOG(GF_LOG_DEBUG, GF_LOG_MEDIA, ("[Terminal] Channel %d connected - %d objects opened\n", ch->esd->ESID, ch->odm->mo->num_open ));
} else {
GF_LOG(GF_LOG_DEBUG, GF_LOG_MEDIA, ("[Terminal] Channel %d connected - not attached to the scene\n", ch->esd->ESID));
}
/*Plays request are skiped until all channels are connected. We send a PLAY on the objecy in case
1-OD user has requested a play
2-this is a channel of the root OD
*/
if ( (ch->odm->mo && ch->odm->mo->num_open)
|| !ch->odm->parentscene
) {
gf_odm_start(ch->odm, 0);
}
#if 0
else if (ch->odm->codec && ch->odm->codec->ck && ch->odm->codec->ck->no_time_ctrl) {
gf_odm_play(ch->odm);
}
#endif
}
void gf_inline_on_modified(GF_Node *node)
{
u32 ODID;
GF_MediaObject *mo;
M_Inline *pInline = (M_Inline *) node;
GF_Scene *scene = (GF_Scene *)gf_node_get_private(node);
ODID = gf_mo_get_od_id(&pInline->url);
if (scene) {
mo = (scene->root_od) ? scene->root_od->mo : NULL;
/*disconnect current inline if we're the last one using it (same as regular OD session leave/join)*/
if (mo) {
Bool changed = 1;
if (ODID != GF_MEDIA_EXTERNAL_ID) {
if (ODID && (ODID==scene->root_od->OD->objectDescriptorID)) changed = 0;
} else {
if (gf_mo_is_same_url(mo, &pInline->url, NULL, 0) ) changed = 0;
}
if (mo->num_open) {
if (!changed) return;
gf_scene_notify_event(scene, GF_EVENT_UNLOAD, node, NULL, GF_OK);
gf_node_dirty_parents(node);
gf_list_del_item(mo->nodes, node);
/*reset the scene pointer as it may get destroyed*/
switch (gf_node_get_tag(node)) {
case TAG_MPEG4_Inline:
#ifndef GPAC_DISABLE_X3D
case TAG_X3D_Inline:
#endif
gf_node_set_private(node, NULL);
break;
}
mo->num_open --;
if (!mo->num_open) {
if (ODID == GF_MEDIA_EXTERNAL_ID) {
GF_Scene *parent = scene->root_od->parentscene;
/*!!! THIS WILL DESTROY THE INLINE SCENE OBJECT !!!*/
gf_odm_disconnect(scene->root_od, 1);
/*and force removal of the media object*/
if (parent) {
if (gf_list_del_item(parent->scene_objects, mo)>=0) {
gf_sg_vrml_mf_reset(&mo->URLs, GF_SG_VRML_MFURL);
gf_list_del(mo->nodes);
gf_free(mo);
}
}
} else {
gf_term_lock_media_queue(scene->root_od->term, 1);
/*external media are completely unloaded*/
if (scene->root_od->OD->objectDescriptorID==GF_MEDIA_EXTERNAL_ID) {
scene->root_od->action_type = GF_ODM_ACTION_DELETE;
} else {
scene->root_od->action_type = GF_ODM_ACTION_STOP;
}
if (gf_list_find(scene->root_od->term->media_queue, scene->root_od)<0)
gf_list_add(scene->root_od->term->media_queue, scene->root_od);
gf_term_lock_media_queue(scene->root_od->term, 0);
}
}
}
}
} else {
gf_node_dirty_parents(node);
}
if (ODID) gf_inline_set_scene(pInline);
}
static void TraverseNavigationInfo(GF_Node *node, void *rs, Bool is_destroy)
{
u32 i;
#ifndef GPAC_DISABLE_3D
u32 nb_select_mode;
SFVec3f start, end;
Fixed scale;
ViewStack *st = (ViewStack *) gf_node_get_private(node);
#endif
GF_TraverseState *tr_state = (GF_TraverseState *)rs;
M_NavigationInfo *ni = (M_NavigationInfo *) node;
if (is_destroy) {
DestroyViewStack(node);
return;
}
#ifdef GPAC_DISABLE_3D
/*FIXME, we only deal with one node, no bind stack for the current time*/
for (i=0; i<ni->type.count; i++) {
if (ni->type.vals[i] && !stricmp(ni->type.vals[i], "NONE")) {
tr_state->visual->compositor->navigation_disabled = 1;
}
}
#else
if (!tr_state->navigations) return;
/*first traverse, bound if needed*/
if (gf_list_find(tr_state->navigations, node) < 0) {
gf_list_add(tr_state->navigations, node);
if (gf_list_get(tr_state->navigations, 0) == ni) {
if (!ni->isBound) Bindable_SetIsBound(node, 1);
}
assert(gf_list_find(st->reg_stacks, tr_state->navigations)==-1);
gf_list_add(st->reg_stacks, tr_state->navigations);
gf_mx_copy(st->world_view_mx, tr_state->model_matrix);
/*in any case don't draw the first time*/
gf_sc_invalidate(tr_state->visual->compositor, NULL);
return;
}
/*not bound*/
if (!ni->isBound) return;
/*not evaluating, return*/
if (tr_state->traversing_mode != TRAVERSE_BINDABLE) {
if ((tr_state->traversing_mode==TRAVERSE_SORT) || (tr_state->traversing_mode==TRAVERSE_GET_BOUNDS) ) {
if (!gf_mx_equal(&st->world_view_mx, &tr_state->model_matrix)) {
gf_mx_copy(st->world_view_mx, tr_state->model_matrix);
gf_node_dirty_set(node, 0, 0);
}
}
return;
}
if (!gf_node_dirty_get(node)) return;
gf_node_dirty_clear(node, 0);
nb_select_mode = 0;
tr_state->camera->navigation_flags = 0;
tr_state->camera->navigate_mode = 0;
for (i=0; i<ni->type.count; i++) {
if (ni->type.vals[i] && !stricmp(ni->type.vals[i], "ANY")) tr_state->camera->navigation_flags |= NAV_ANY;
else {
nb_select_mode++;
}
if (!tr_state->camera->navigate_mode) {
if (ni->type.vals[i] && !stricmp(ni->type.vals[i], "NONE")) tr_state->camera->navigate_mode = GF_NAVIGATE_NONE;
else if (ni->type.vals[i] && !stricmp(ni->type.vals[i], "WALK")) tr_state->camera->navigate_mode = GF_NAVIGATE_WALK;
else if (ni->type.vals[i] && !stricmp(ni->type.vals[i], "EXAMINE")) tr_state->camera->navigate_mode = GF_NAVIGATE_EXAMINE;
else if (ni->type.vals[i] && !stricmp(ni->type.vals[i], "FLY")) tr_state->camera->navigate_mode = GF_NAVIGATE_FLY;
else if (ni->type.vals[i] && !stricmp(ni->type.vals[i], "VR")) tr_state->camera->navigate_mode = GF_NAVIGATE_VR;
}
}
if (nb_select_mode>1) tr_state->camera->navigation_flags |= NAV_SELECTABLE;
if (ni->headlight) tr_state->camera->navigation_flags |= NAV_HEADLIGHT;
start.x = start.y = start.z = 0;
end.x = end.y = 0;
end.z = FIX_ONE;
gf_mx_apply_vec(&st->world_view_mx, &start);
gf_mx_apply_vec(&st->world_view_mx, &end);
gf_vec_diff(end, end, start);
scale = gf_vec_len(end);
tr_state->camera->speed = gf_mulfix(scale, ni->speed);
tr_state->camera->visibility = gf_mulfix(scale, ni->visibilityLimit);
if (ni->avatarSize.count) tr_state->camera->avatar_size.x = gf_mulfix(scale, ni->avatarSize.vals[0]);
if (ni->avatarSize.count>1) tr_state->camera->avatar_size.y = gf_mulfix(scale, ni->avatarSize.vals[1]);
if (ni->avatarSize.count>2) tr_state->camera->avatar_size.z = gf_mulfix(scale, ni->avatarSize.vals[2]);
if (0 && tr_state->pixel_metrics) {
u32 s = MAX(tr_state->visual->width, tr_state->visual->height);
s /= 2;
// tr_state->camera->speed = ni->speed;
tr_state->camera->visibility *= s;
tr_state->camera->avatar_size.x *= s;
tr_state->camera->avatar_size.y *= s;
tr_state->camera->avatar_size.z *= s;
}
#endif
}
static void TraverseBackground2D(GF_Node *node, void *rs, Bool is_destroy)
{
u32 col;
BackgroundStatus *status;
M_Background2D *bck;
Background2DStack *stack = (Background2DStack *) gf_node_get_private(node);
GF_TraverseState *tr_state = (GF_TraverseState *)rs;
if (is_destroy) {
DestroyBackground2D(node);
return;
}
bck = (M_Background2D *)node;
/*special case for background in Layer2D: the background is seen as a regular drawable, so
RENDER_BINDABLE is not used*/
switch (tr_state->traversing_mode) {
case TRAVERSE_DRAW_2D:
DrawBackground2D_2D(tr_state->ctx, tr_state);
return;
case TRAVERSE_PICK:
case TRAVERSE_GET_BOUNDS:
return;
}
/*first traverse, bound if needed*/
if (gf_list_find(tr_state->backgrounds, node) < 0) {
M_Background2D *top_bck = (M_Background2D *)node;
gf_list_add(tr_state->backgrounds, node);
assert(gf_list_find(stack->reg_stacks, tr_state->backgrounds)==-1);
gf_list_add(stack->reg_stacks, tr_state->backgrounds);
b2D_new_status(stack, bck);
/*only bound if we're on top*/
top_bck = gf_list_get(tr_state->backgrounds, 0);
if (!bck->isBound) {
if (top_bck== bck) {
Bindable_SetIsBound(node, 1);
} else if (!top_bck->isBound) {
bck->set_bind = 1;
bck->on_set_bind(node, NULL);
}
}
/*open the stream if any*/
if (back_use_texture(bck) && !stack->txh.is_open) gf_sc_texture_play(&stack->txh, &bck->url);
/*in any case don't draw the first time (since the background could have been declared last)*/
gf_sc_invalidate(stack->txh.compositor, NULL);
return;
}
if (!bck->isBound) return;
status = b2d_get_status(stack, tr_state->backgrounds);
if (!status) return;
if (gf_node_dirty_get(node)) {
stack->flags |= CTX_APP_DIRTY;
gf_node_dirty_clear(node, 0);
col = GF_COL_ARGB_FIXED(FIX_ONE, bck->backColor.red, bck->backColor.green, bck->backColor.blue);
if (col != status->ctx.aspect.fill_color) {
status->ctx.aspect.fill_color = col;
stack->flags |= CTX_APP_DIRTY;
}
}
if (back_use_texture(bck) ) {
if (stack->txh.tx_io && !(status->ctx.flags & CTX_APP_DIRTY) && stack->txh.needs_refresh)
stack->flags |= CTX_TEXTURE_DIRTY;
}
status->ctx.flags = stack->flags;
if (tr_state->traversing_mode != TRAVERSE_BINDABLE) return;
/*3D mode*/
#ifndef GPAC_DISABLE_3D
if (tr_state->visual->type_3d) {
DrawBackground2D_3D(bck, stack, tr_state);
} else
#endif
DrawBackground2D_2D(&status->ctx, tr_state);
}
Bool gf_es_owns_clock(GF_Channel *ch)
{
/*if the clock is not in the same namespace (used with dynamic scenes), it's not ours*/
if (gf_list_find(ch->odm->net_service->Clocks, ch->clock)<0) return 0;
return (ch->esd->ESID==ch->clock->clockID) ? 1 : 0;
}
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 void TraverseBackground(GF_Node *node, void *rs, Bool is_destroy)
{
M_Background *bck;
BackgroundStack *st;
SFColor bcol;
SFVec4f res;
Fixed scale;
Bool has_sky, has_ground, front_tx, back_tx, top_tx, bottom_tx, right_tx, left_tx;
GF_Matrix mx;
GF_Compositor *compositor;
GF_TraverseState *tr_state = (GF_TraverseState *)rs;
if (is_destroy) {
DestroyBackground(node);
return;
}
gf_node_dirty_clear(node, 0);
bck = (M_Background *)node;
st = (BackgroundStack *) gf_node_get_private(node);
compositor = (GF_Compositor*)st->compositor;
/*may happen in get_bounds*/
if (!tr_state->backgrounds) return;
/*first traverse, bound if needed*/
if (gf_list_find(tr_state->backgrounds, node) < 0) {
gf_list_add(tr_state->backgrounds, node);
assert(gf_list_find(st->reg_stacks, tr_state->backgrounds)==-1);
gf_list_add(st->reg_stacks, tr_state->backgrounds);
/*only bound if we're on top*/
if (gf_list_get(tr_state->backgrounds, 0) == bck) {
if (!bck->isBound) Bindable_SetIsBound(node, 1);
}
/*check streams*/
if (back_use_texture(&bck->frontUrl) && !st->txh_front.is_open) gf_sc_texture_play(&st->txh_front, &bck->frontUrl);
if (back_use_texture(&bck->bottomUrl) && !st->txh_bottom.is_open) gf_sc_texture_play(&st->txh_bottom, &bck->bottomUrl);
if (back_use_texture(&bck->backUrl) && !st->txh_back.is_open) gf_sc_texture_play(&st->txh_back, &bck->backUrl);
if (back_use_texture(&bck->topUrl) && !st->txh_top.is_open) gf_sc_texture_play(&st->txh_top, &bck->topUrl);
if (back_use_texture(&bck->rightUrl) && !st->txh_right.is_open) gf_sc_texture_play(&st->txh_right, &bck->rightUrl);
if (back_use_texture(&bck->leftUrl) && !st->txh_left.is_open) gf_sc_texture_play(&st->txh_left, &bck->leftUrl);
/*in any case don't draw the first time (since the background could have been declared last)*/
gf_sc_invalidate(st->compositor, NULL);
return;
}
if (!bck->isBound) return;
if (tr_state->traversing_mode != TRAVERSE_BINDABLE) {
if (tr_state->traversing_mode == TRAVERSE_SORT) {
gf_mx_copy(st->current_mx, tr_state->model_matrix);
}
return;
}
front_tx = back_gf_sc_texture_enabled(&bck->frontUrl, &st->txh_front);
back_tx = back_gf_sc_texture_enabled(&bck->backUrl, &st->txh_back);
top_tx = back_gf_sc_texture_enabled(&bck->topUrl, &st->txh_top);
bottom_tx = back_gf_sc_texture_enabled(&bck->bottomUrl, &st->txh_bottom);
right_tx = back_gf_sc_texture_enabled(&bck->rightUrl, &st->txh_right);
left_tx = back_gf_sc_texture_enabled(&bck->leftUrl, &st->txh_left);
has_sky = ((bck->skyColor.count>1) && bck->skyAngle.count) ? 1 : 0;
has_ground = ((bck->groundColor.count>1) && bck->groundAngle.count) ? 1 : 0;
bcol.red = bcol.green = bcol.blue = 0;
if (bck->skyColor.count) bcol = bck->skyColor.vals[0];
/*if we clear the main visual clear it entirely - ONLY IF NOT IN LAYER*/
if ((tr_state->visual == compositor->visual) && (tr_state->visual->back_stack == tr_state->backgrounds)) {
visual_3d_clear(tr_state->visual, bcol, FIX_ONE);
if (!has_sky && !has_ground && !front_tx && !back_tx && !top_tx && !bottom_tx && !left_tx && !right_tx) {
return;
}
}
/*undo translation*/
res.x = res.y = res.z = 0;
res.q = FIX_ONE;
gf_mx_apply_vec_4x4(&tr_state->camera->unprojection, &res);
assert(res.q);
res.x = gf_divfix(res.x, res.q);
res.y = gf_divfix(res.y, res.q);
res.z = gf_divfix(res.z, res.q);
/*NB: we don't support local rotation of the background ...*/
/*enable background state (turn off all quality options)*/
visual_3d_set_background_state(tr_state->visual, 1);
if (has_sky) {
GF_Matrix bck_mx;
gf_mx_copy(bck_mx, tr_state->model_matrix);
gf_mx_copy(tr_state->model_matrix, st->current_mx);
if (!st->sky_mesh) {
st->sky_mesh = new_mesh();
back_build_dome(st->sky_mesh, &bck->skyAngle, &bck->skyColor, 0);
}
gf_mx_init(mx);
gf_mx_add_translation(&mx, res.x, res.y, res.z);
/*CHECKME - not sure why, we need to scale less in fixed point otherwise z-far clipping occur - probably some
rounding issues...*/
#ifdef GPAC_FIXED_POINT
scale = (tr_state->camera->z_far/10)*8;
#else
scale = 9*tr_state->camera->z_far/10;
#endif
gf_mx_add_scale(&mx, scale, scale, scale);
gf_mx_add_matrix(&tr_state->model_matrix, &mx);
visual_3d_mesh_paint(tr_state, st->sky_mesh);
gf_mx_copy(tr_state->model_matrix, bck_mx);
}
if (has_ground) {
GF_Matrix bck_mx;
gf_mx_copy(bck_mx, tr_state->model_matrix);
gf_mx_copy(tr_state->model_matrix, st->current_mx);
if (!st->ground_mesh) {
st->ground_mesh = new_mesh();
back_build_dome(st->ground_mesh, &bck->groundAngle, &bck->groundColor, 1);
}
gf_mx_init(mx);
gf_mx_add_translation(&mx, res.x, res.y, res.z);
/*cf above*/
#ifdef GPAC_FIXED_POINT
scale = (tr_state->camera->z_far/100)*70;
#else
scale = 85*tr_state->camera->z_far/100;
#endif
gf_mx_add_scale(&mx, scale, -scale, scale);
gf_mx_add_matrix(&tr_state->model_matrix, &mx);
visual_3d_mesh_paint(tr_state, st->ground_mesh);
gf_mx_copy(tr_state->model_matrix, bck_mx);
}
if (front_tx || back_tx || left_tx || right_tx || top_tx || bottom_tx) {
GF_Matrix bck_mx;
gf_mx_copy(bck_mx, tr_state->model_matrix);
gf_mx_copy(tr_state->model_matrix, st->current_mx);
gf_mx_init(mx);
gf_mx_add_translation(&mx, res.x, res.y, res.z);
#ifdef GPAC_FIXED_POINT
scale = (tr_state->camera->z_far/100)*99;
gf_mx_add_scale(&mx, scale, scale, scale);
#else
gf_mx_add_scale(&mx, tr_state->camera->z_far, tr_state->camera->z_far, tr_state->camera->z_far);
#endif
visual_3d_enable_antialias(tr_state->visual, 1);
gf_mx_add_matrix(&tr_state->model_matrix, &mx);
if (front_tx) back_draw_texture(tr_state, &st->txh_front, st->front_mesh);
if (back_tx) back_draw_texture(tr_state, &st->txh_back, st->back_mesh);
if (top_tx) back_draw_texture(tr_state, &st->txh_top, st->top_mesh);
if (bottom_tx) back_draw_texture(tr_state, &st->txh_bottom, st->bottom_mesh);
if (left_tx) back_draw_texture(tr_state, &st->txh_left, st->left_mesh);
if (right_tx) back_draw_texture(tr_state, &st->txh_right, st->right_mesh);
gf_mx_copy(tr_state->model_matrix, bck_mx);
}
/*enable background state (turn off all quality options)*/
visual_3d_set_background_state(tr_state->visual, 0);
}
