static void traverse_transform(GF_Node *node, Transform2DStack *stack, GF_TraverseState *tr_state)
{
if (stack->is_null) return;
/*note we don't clear dirty flag, this is done in traversing*/
if (stack->is_identity) {
group_2d_traverse(node, (GroupingNode2D *)stack, tr_state);
}
#ifndef GPAC_DISABLE_3D
else if (tr_state->visual->type_3d) {
GF_Matrix mx_bckup;
gf_mx_copy(mx_bckup, tr_state->model_matrix);
gf_mx_add_matrix_2d(&tr_state->model_matrix, &stack->mat);
group_2d_traverse(node, (GroupingNode2D *)stack, tr_state);
gf_mx_copy(tr_state->model_matrix, mx_bckup);
}
#endif
else {
GF_Matrix2D bckup;
gf_mx2d_copy(bckup, tr_state->transform);
gf_mx2d_pre_multiply(&tr_state->transform, &stack->mat);
group_2d_traverse(node, (GroupingNode2D *)stack, tr_state);
gf_mx2d_copy(tr_state->transform, bckup);
}
if (tr_state->traversing_mode == TRAVERSE_GET_BOUNDS) {
gf_mx2d_apply_rect(&stack->mat, &tr_state->bounds);
}
}
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);
}
static void TraverseDepthGroup(GF_Node *node, void *rs, Bool is_destroy)
{
#ifdef GF_SR_USE_DEPTH
Fixed depth_gain, depth_offset;
#endif
DepthGroupStack *stack = (DepthGroupStack *)gf_node_get_private(node);
GF_TraverseState *tr_state = (GF_TraverseState *) rs;
if (is_destroy) {
gf_free(stack);
return;
}
if (tr_state->traversing_mode==TRAVERSE_SORT) {
if (gf_node_dirty_get(node) & GF_SG_NODE_DIRTY) {
gf_node_dirty_clear(node, GF_SG_NODE_DIRTY);
/*flag is not set for PROTO*/
gf_node_dirty_set(node, GF_SG_CHILD_DIRTY, 0);
}
}
DepthGroup_GetNode(node, &stack->dg);
#ifdef GF_SR_USE_DEPTH
depth_gain = tr_state->depth_gain;
depth_offset = tr_state->depth_offset;
// new offset is multiplied by parent gain and added to parent offset
tr_state->depth_offset = gf_mulfix(stack->dg.depth_offset, tr_state->depth_gain) + tr_state->depth_offset;
// gain is multiplied by parent gain
tr_state->depth_gain = gf_mulfix(tr_state->depth_gain, stack->dg.depth_gain);
#endif
#ifndef GPAC_DISABLE_3D
if (tr_state->visual->type_3d) {
GF_Matrix mx_bckup, mx;
gf_mx_copy(mx_bckup, tr_state->model_matrix);
gf_mx_init(mx);
mx.m[14] = gf_mulfix(stack->dg.depth_offset, tr_state->visual->compositor->depth_gl_scale);
gf_mx_add_matrix(&tr_state->model_matrix, &mx);
group_2d_traverse((GF_Node *)&stack->dg, (GroupingNode2D*)stack, tr_state);
gf_mx_copy(tr_state->model_matrix, mx_bckup);
} else
#endif
{
group_2d_traverse((GF_Node *)&stack->dg, (GroupingNode2D*)stack, tr_state);
}
#ifdef GF_SR_USE_DEPTH
tr_state->depth_gain = depth_gain;
tr_state->depth_offset = depth_offset;
#endif
}
static void TraverseTransform(GF_Node *n, void *rs, Bool is_destroy)
{
GF_Matrix gf_mx_bckup;
TransformStack *st = (TransformStack *)gf_node_get_private(n);
M_Transform *tr = (M_Transform *)n;
GF_TraverseState *tr_state = (GF_TraverseState *)rs;
if (is_destroy) {
DestroyTransform(n);
return;
}
/*note we don't clear dirty flag, this is done in traversing*/
if (gf_node_dirty_get(n) & GF_SG_NODE_DIRTY) {
Bool scale_rot, recenter;
gf_mx_init(st->mx);
if (tr->translation.x || tr->translation.y || tr->translation.z)
gf_mx_add_translation(&st->mx, tr->translation.x, tr->translation.y, tr->translation.z);
recenter = (tr->center.x || tr->center.y || tr->center.z) ? 1 : 0;
if (recenter)
gf_mx_add_translation(&st->mx, tr->center.x, tr->center.y, tr->center.z);
if (tr->rotation.q) gf_mx_add_rotation(&st->mx, tr->rotation.q, tr->rotation.x, tr->rotation.y, tr->rotation.z);
scale_rot = (tr->scaleOrientation.q) ? 1 : 0;
if (scale_rot)
gf_mx_add_rotation(&st->mx, tr->scaleOrientation.q, tr->scaleOrientation.x, tr->scaleOrientation.y, tr->scaleOrientation.z);
if ((tr->scale.x != FIX_ONE) || (tr->scale.y != FIX_ONE) || (tr->scale.z != FIX_ONE))
gf_mx_add_scale(&st->mx, tr->scale.x, tr->scale.y, tr->scale.z);
if (scale_rot)
gf_mx_add_rotation(&st->mx, -tr->scaleOrientation.q, tr->scaleOrientation.x, tr->scaleOrientation.y, tr->scaleOrientation.z);
if (recenter)
gf_mx_add_translation(&st->mx, -tr->center.x, -tr->center.y, -tr->center.z);
st->has_scale = ((tr->scale.x != FIX_ONE) || (tr->scale.y != FIX_ONE) || (tr->scale.z != FIX_ONE)) ? 1 : 0;
}
gf_mx_copy(gf_mx_bckup, tr_state->model_matrix);
gf_mx_add_matrix(&tr_state->model_matrix, &st->mx);
/*note we don't clear dirty flag, this is done in traversing*/
group_3d_traverse(n, (GroupingNode *) st, tr_state);
gf_mx_copy(tr_state->model_matrix, gf_mx_bckup);
if (tr_state->traversing_mode==TRAVERSE_GET_BOUNDS)
gf_mx_apply_bbox(&st->mx, &tr_state->bbox);
}
void compositor_svg_restore_parent_transformation(GF_TraverseState *tr_state, GF_Matrix2D *backup_matrix_2d, GF_Matrix *backup_matrix)
{
#ifndef GPAC_DISABLE_3D
if (tr_state->visual->type_3d && backup_matrix) {
gf_mx_copy(tr_state->model_matrix, *backup_matrix);
return;
}
#endif
gf_mx2d_copy(tr_state->transform, *backup_matrix_2d);
}
void compositor_svg_apply_local_transformation(GF_TraverseState *tr_state, SVGAllAttributes *atts, GF_Matrix2D *backup_matrix_2d, GF_Matrix *backup_matrix)
{
#ifndef GPAC_DISABLE_3D
if (tr_state->visual->type_3d && backup_matrix) {
GF_Matrix tmp;
Bool is_draw = (tr_state->traversing_mode==TRAVERSE_SORT) ? 1 : 0;
gf_mx_copy(*backup_matrix, tr_state->model_matrix);
if (is_draw) visual_3d_matrix_push(tr_state->visual);
if (atts->transform && atts->transform->is_ref) {
gf_mx_from_mx2d(&tr_state->model_matrix, &tr_state->vb_transform);
if (is_draw) {
GF_Matrix tmp;
gf_mx_init(tmp);
gf_mx_add_translation(&tmp, -tr_state->camera->width/2, tr_state->camera->height/2, 0);
gf_mx_add_scale(&tmp, FIX_ONE, -FIX_ONE, FIX_ONE);
gf_mx_add_matrix(&tmp, &tr_state->model_matrix);
visual_3d_matrix_load(tr_state->visual, tmp.m);
}
}
if (atts->motionTransform) {
if (is_draw) {
gf_mx_from_mx2d(&tmp, atts->motionTransform);
visual_3d_matrix_add(tr_state->visual, tmp.m);
} else {
gf_mx_add_matrix_2d(&tr_state->model_matrix, atts->motionTransform);
}
}
if (atts->transform) {
if (is_draw) {
gf_mx_from_mx2d(&tmp, &atts->transform->mat);
visual_3d_matrix_add(tr_state->visual, tmp.m);
} else {
gf_mx_add_matrix_2d(&tr_state->model_matrix, &atts->transform->mat);
}
}
return;
}
#endif
gf_mx2d_copy(*backup_matrix_2d, tr_state->transform);
if (atts->transform && atts->transform->is_ref)
gf_mx2d_copy(tr_state->transform, tr_state->vb_transform);
if (atts->motionTransform)
gf_mx2d_pre_multiply(&tr_state->transform, atts->motionTransform);
if (atts->transform)
gf_mx2d_pre_multiply(&tr_state->transform, &atts->transform->mat);
}
static void OnPlaneSensor2D(SensorHandler *sh, Bool is_over, GF_Event *ev, RayHitInfo *hit_info)
{
M_PlaneSensor2D *ps = (M_PlaneSensor2D *)sh->owner;
PS2DStack *stack = (PS2DStack *) gf_node_get_private(sh->owner);
if (ps->isActive && (!ps->enabled || ((ev->type==GF_EVENT_MOUSEUP) && (ev->mouse.button==GF_MOUSE_LEFT)) )) {
if (ps->autoOffset) {
ps->offset = ps->translation_changed;
gf_node_event_out_str(sh->owner, "offset");
}
ps->isActive = 0;
gf_node_event_out_str(sh->owner, "isActive");
R3D_SetGrabbed(stack->compositor, 0);
} else if (!ps->isActive && (ev->type==GF_EVENT_MOUSEDOWN) && (ev->mouse.button==GF_MOUSE_LEFT)) {
gf_mx_copy(stack->initial_matrix, hit_info->local_to_world);
stack->start_drag.x = hit_info->local_point.x - ps->offset.x;
stack->start_drag.y = hit_info->local_point.y - ps->offset.y;
ps->isActive = 1;
gf_node_event_out_str(sh->owner, "isActive");
R3D_SetGrabbed(stack->compositor, 1);
} else if (ps->isActive) {
GF_Ray loc_ray;
SFVec3f res;
loc_ray = hit_info->world_ray;
gf_mx_apply_ray(&stack->initial_matrix, &loc_ray);
R3D_Get2DPlaneIntersection(&loc_ray, &res);
ps->trackPoint_changed.x = res.x;
ps->trackPoint_changed.y = res.y;
gf_node_event_out_str(sh->owner, "trackPoint_changed");
res.x -= stack->start_drag.x;
res.y -= stack->start_drag.y;
/*clip*/
if (ps->minPosition.x <= ps->maxPosition.x) {
if (res.x < ps->minPosition.x) res.x = ps->minPosition.x;
if (res.x > ps->maxPosition.x) res.x = ps->maxPosition.x;
}
if (ps->minPosition.y <= ps->maxPosition.y) {
if (res.y < ps->minPosition.y) res.y = ps->minPosition.y;
if (res.y > ps->maxPosition.y) res.y = ps->maxPosition.y;
}
ps->translation_changed.x = res.x;
ps->translation_changed.y = res.y;
gf_node_event_out_str(sh->owner, "translation_changed");
}
}
static void OnPlaneSensor(SensorHandler *sh, Bool is_over, GF_Event *ev, RayHitInfo *hit_info)
{
M_PlaneSensor *ps = (M_PlaneSensor *)sh->owner;
PSStack *stack = (PSStack *) gf_node_get_private(sh->owner);
if (ps->isActive && (!ps->enabled || ((ev->type==GF_EVENT_MOUSEUP) && (ev->mouse.button==GF_MOUSE_LEFT)) )) {
if (ps->autoOffset) {
ps->offset = ps->translation_changed;
gf_node_event_out_str(sh->owner, "offset");
}
ps->isActive = 0;
gf_node_event_out_str(sh->owner, "isActive");
R3D_SetGrabbed(stack->compositor, 0);
}
else if (!ps->isActive && (ev->type==GF_EVENT_MOUSEDOWN) && (ev->mouse.button==GF_MOUSE_LEFT)) {
gf_mx_copy(stack->initial_matrix, hit_info->local_to_world);
gf_vec_diff(stack->start_drag, hit_info->local_point, ps->offset);
stack->tracker.normal.x = stack->tracker.normal.y = 0; stack->tracker.normal.z = FIX_ONE;
stack->tracker.d = - gf_vec_dot(stack->start_drag, stack->tracker.normal);
ps->isActive = 1;
gf_node_event_out_str(sh->owner, "isActive");
R3D_SetGrabbed(stack->compositor, 1);
}
else if (ps->isActive) {
GF_Ray loc_ray;
SFVec3f res;
loc_ray = hit_info->world_ray;
gf_mx_apply_ray(&stack->initial_matrix, &loc_ray);
gf_plane_intersect_line(&stack->tracker, &loc_ray.orig, &loc_ray.dir, &res);
ps->trackPoint_changed = res;
gf_node_event_out_str(sh->owner, "trackPoint_changed");
gf_vec_diff(res, res, stack->start_drag);
/*clip*/
if (ps->minPosition.x <= ps->maxPosition.x) {
if (res.x < ps->minPosition.x) res.x = ps->minPosition.x;
if (res.x > ps->maxPosition.x) res.x = ps->maxPosition.x;
}
if (ps->minPosition.y <= ps->maxPosition.y) {
if (res.y < ps->minPosition.y) res.y = ps->minPosition.y;
if (res.y > ps->maxPosition.y) res.y = ps->maxPosition.y;
}
ps->translation_changed = res;
gf_node_event_out_str(sh->owner, "translation_changed");
}
}
static void OnDiscSensor(SensorHandler *sh, Bool is_over, GF_Event *ev, RayHitInfo *hit_info)
{
M_DiscSensor *ds = (M_DiscSensor *)sh->owner;
DiscSensorStack *stack = (DiscSensorStack *) gf_node_get_private(sh->owner);
if (ds->isActive && (!ds->enabled || ((ev->type==GF_EVENT_MOUSEUP) && (ev->mouse.button==GF_MOUSE_LEFT) ) ) ) {
if (ds->autoOffset) {
ds->offset = ds->rotation_changed;
/*that's an exposedField*/
gf_node_event_out_str(sh->owner, "offset");
}
ds->isActive = 0;
gf_node_event_out_str(sh->owner, "isActive");
R3D_SetGrabbed(stack->compositor, 0);
}
else if (!ds->isActive && (ev->type==GF_EVENT_MOUSEDOWN) && (ev->mouse.button==GF_MOUSE_LEFT)) {
/*store inverse matrix*/
gf_mx_copy(stack->initial_matrix, hit_info->local_to_world);
stack->start_angle = gf_atan2(hit_info->local_point.y, hit_info->local_point.x);
ds->isActive = 1;
gf_node_event_out_str(sh->owner, "isActive");
R3D_SetGrabbed(stack->compositor, 1);
}
else if (ds->isActive) {
GF_Ray loc_ray;
Fixed rot;
SFVec3f res;
loc_ray = hit_info->world_ray;
gf_mx_apply_ray(&stack->initial_matrix, &loc_ray);
R3D_Get2DPlaneIntersection(&loc_ray, &res);
rot = gf_atan2(res.y, res.x) - stack->start_angle + ds->offset;
if (ds->minAngle < ds->maxAngle) {
/*FIXME this doesn't work properly*/
if (rot < ds->minAngle) rot = ds->minAngle;
if (rot > ds->maxAngle) rot = ds->maxAngle;
}
ds->rotation_changed = rot;
gf_node_event_out_str(sh->owner, "rotation_changed");
ds->trackPoint_changed.x = res.x;
ds->trackPoint_changed.y = res.y;
gf_node_event_out_str(sh->owner, "trackPoint_changed");
}
}
static void TraversePlaneClipper(GF_Node *node, void *rs, Bool is_destroy)
{
PlaneClipperStack *stack = (PlaneClipperStack *)gf_node_get_private(node);
GF_TraverseState *tr_state = (GF_TraverseState *) rs;
if (is_destroy) {
group_3d_delete(node);
return;
}
if (gf_node_dirty_get(node)) {
PlaneClipper_GetNode(node, &stack->pc);
}
if (tr_state->num_clip_planes==MAX_USER_CLIP_PLANES) {
group_3d_traverse((GF_Node*)&stack->pc, (GroupingNode*)stack, tr_state);
return;
}
if (tr_state->traversing_mode == TRAVERSE_SORT) {
GF_Matrix mx;
gf_mx_copy(mx, tr_state->model_matrix);
visual_3d_set_clip_plane(tr_state->visual, stack->pc.plane, &mx, 0);
tr_state->num_clip_planes++;
group_3d_traverse((GF_Node*)&stack->pc, (GroupingNode*)stack, tr_state);
visual_3d_reset_clip_plane(tr_state->visual);
tr_state->num_clip_planes--;
} else {
tr_state->clip_planes[tr_state->num_clip_planes] = stack->pc.plane;
gf_mx_apply_plane(&tr_state->model_matrix, &tr_state->clip_planes[tr_state->num_clip_planes]);
tr_state->num_clip_planes++;
group_3d_traverse((GF_Node*)&stack->pc, (GroupingNode*)stack, tr_state);
tr_state->num_clip_planes--;
}
}
Bool compositor_compositetexture_handle_event(GF_Compositor *compositor, GF_Node *composite_appear, GF_Event *ev, Bool is_flush)
{
GF_Ray ray;
Fixed dist;
Bool had_text_sel=0;
GF_Matrix mx;
GF_TraverseState *tr_state;
GF_ChildNodeItem *children, *l;
Bool res;
SFVec3f txcoord, loc_pt, world_pt;
GF_Matrix l2w_mx, w2l_mx;
CompositeTextureStack *stack;
GF_Node *appear, *prev_appear;
M_Appearance *ap = (M_Appearance *)composite_appear;
assert(ap && ap->texture);
if (ev->type > GF_EVENT_MOUSEMOVE) return 0;
stack = gf_node_get_private(ap->texture);
if (!stack->txh.tx_io) return 0;
tr_state = NULL;
children = NULL;
if (!is_flush) {
txcoord.x = compositor->hit_texcoords.x;
txcoord.y = compositor->hit_texcoords.y;
txcoord.z = 0;
if (gf_sc_texture_get_transform(&stack->txh, ap->textureTransform, &mx, 1)) {
/*tx coords are inverted when mapping, thus applying directly the matrix will give us the
untransformed coords*/
gf_mx_apply_vec(&mx, &txcoord);
while (txcoord.x<0) txcoord.x += FIX_ONE; while (txcoord.x>FIX_ONE) txcoord.x -= FIX_ONE;
while (txcoord.y<0) txcoord.y += FIX_ONE; while (txcoord.y>FIX_ONE) txcoord.y -= FIX_ONE;
}
/*convert to tx space*/
ev->mouse.x = FIX2INT( (txcoord.x - FIX_ONE/2) * stack->visual->width + FIX_ONE/2);
ev->mouse.y = FIX2INT( (txcoord.y - FIX_ONE/2) * stack->visual->height + FIX_ONE/2);
GF_SAFEALLOC(tr_state, GF_TraverseState);
tr_state->vrml_sensors = gf_list_new();
tr_state->visual = stack->visual;
tr_state->traversing_mode = TRAVERSE_PICK;
tr_state->pixel_metrics = gf_sg_use_pixel_metrics(gf_node_get_graph(ap->texture));
tr_state->vp_size.x = INT2FIX(stack->txh.width);
tr_state->vp_size.y = INT2FIX(stack->txh.height);
tr_state->color_mat.identity = 1;
gf_mx2d_init(tr_state->transform);
#ifndef GPAC_DISABLE_3D
gf_mx_init(tr_state->model_matrix);
#endif
/*collect sensors*/
l = children = ((M_CompositeTexture2D*)ap->texture)->children;
while (l) {
GF_SensorHandler *hsens = compositor_mpeg4_get_sensor_handler(l->node);
if (hsens) gf_list_add(tr_state->vrml_sensors, hsens);
l = l->next;
}
}
stack->temp_sensors = compositor->sensors;
stack->temp_previous_sensors = compositor->previous_sensors;
compositor->sensors = stack->sensors;
compositor->previous_sensors = stack->previous_sensors;
ray = compositor->hit_world_ray;
dist = compositor->hit_square_dist;
prev_appear = compositor->prev_hit_appear;
/*protect against destrucion in case of self-destroy*/
if (prev_appear) {
gf_node_register(prev_appear, NULL);
}
compositor->prev_hit_appear = stack->prev_hit_appear;
appear = compositor->hit_appear;
compositor->hit_appear = NULL;
/*also backup current hit state in case we hit a node in the texture but don't consume the event*/
loc_pt = compositor->hit_local_point;
world_pt = compositor->hit_world_point;
gf_mx_copy(l2w_mx, compositor->hit_local_to_world);
gf_mx_copy(w2l_mx, compositor->hit_world_to_local);
if (compositor->text_selection) had_text_sel=1;
if (is_flush) {
res = 0;
gf_list_reset(stack->sensors);
gf_sc_exec_event_vrml(compositor, ev);
} else {
res = visual_execute_event(stack->visual, tr_state, ev, children);
}
if (!had_text_sel && compositor->edited_text) {
stack->visual->has_text_edit = 1;
} else if (!compositor->text_selection) {
stack->visual->has_text_edit = 0;
}
if (!res) {
compositor->hit_local_point = loc_pt;
gf_mx_copy(compositor->hit_local_to_world, l2w_mx);
gf_mx_copy(compositor->hit_world_to_local, w2l_mx);
}
stack->prev_hit_appear = compositor->prev_hit_appear;
if (prev_appear) {
if (prev_appear->sgprivate->num_instances>1) {
compositor->prev_hit_appear = prev_appear;
compositor->hit_appear = appear;
} else {
compositor->prev_hit_appear = NULL;
compositor->hit_appear = NULL;
}
gf_node_unregister(prev_appear, NULL);
} else {
compositor->prev_hit_appear = prev_appear;
compositor->hit_appear = appear;
}
compositor->hit_world_point = world_pt;
compositor->hit_world_ray = ray;
compositor->hit_square_dist = dist;
stack->sensors = compositor->sensors;
stack->previous_sensors = compositor->previous_sensors;
compositor->sensors = stack->temp_sensors;
stack->temp_sensors = NULL;
compositor->previous_sensors = stack->temp_previous_sensors;
stack->temp_previous_sensors = NULL;
if (!is_flush) {
gf_list_del(tr_state->vrml_sensors);
#ifndef GPAC_DISABLE_3D
if (tr_state->layer3d) compositor->traverse_state->layer3d = tr_state->layer3d;
#endif
gf_free(tr_state);
}
return res;
}
static void TraverseUntransform(GF_Node *node, void *rs, Bool is_destroy)
{
UntransformStack *stack = (UntransformStack *)gf_node_get_private(node);
GF_TraverseState *tr_state = (GF_TraverseState *) rs;
if (is_destroy) {
gf_free(stack);
return;
}
if (tr_state->traversing_mode==TRAVERSE_SORT) {
if (gf_node_dirty_get(node)) {
Untransform_GetNode(node, &stack->untr); /*lets place it below*/
gf_node_dirty_clear(node, GF_SG_NODE_DIRTY);
}
}
#ifndef GPAC_DISABLE_3D
if (tr_state->visual->type_3d) {
GF_Matrix mx_model;
GF_Camera backup_cam;
if (!tr_state->camera) return;
gf_mx_copy(mx_model, tr_state->model_matrix);
gf_mx_init(tr_state->model_matrix);
memcpy(&backup_cam, tr_state->camera, sizeof(GF_Camera));
camera_invalidate(tr_state->camera);
tr_state->camera->is_3D=0;
tr_state->camera->flags |= CAM_NO_LOOKAT;
tr_state->camera->end_zoom = FIX_ONE;
camera_update(tr_state->camera, NULL, 1);
if (tr_state->traversing_mode == TRAVERSE_SORT) {
visual_3d_set_matrix_mode(tr_state->visual, V3D_MATRIX_PROJECTION);
visual_3d_matrix_load(tr_state->visual, tr_state->camera->projection.m);
visual_3d_set_matrix_mode(tr_state->visual, V3D_MATRIX_MODELVIEW);
visual_3d_matrix_load(tr_state->visual, tr_state->camera->modelview.m);
visual_3d_set_viewport(tr_state->visual, tr_state->camera->vp);
gf_node_traverse_children((GF_Node *)&stack->untr, tr_state);
gf_mx_copy(tr_state->model_matrix, mx_model);
memcpy(tr_state->camera, &backup_cam, sizeof(GF_Camera));
visual_3d_set_matrix_mode(tr_state->visual, V3D_MATRIX_PROJECTION);
visual_3d_matrix_load(tr_state->visual, tr_state->camera->projection.m);
visual_3d_set_matrix_mode(tr_state->visual, V3D_MATRIX_MODELVIEW);
visual_3d_matrix_load(tr_state->visual, tr_state->camera->modelview.m);
visual_3d_set_viewport(tr_state->visual, tr_state->camera->vp);
} else if (tr_state->traversing_mode == TRAVERSE_PICK) {
Fixed prev_dist = tr_state->visual->compositor->hit_square_dist;
GF_Ray r = tr_state->ray;
tr_state->ray.orig.x = INT2FIX(tr_state->pick_x);
tr_state->ray.orig.y = INT2FIX(tr_state->pick_y);
tr_state->ray.orig.z = 0;
tr_state->ray.dir.x = 0;
tr_state->ray.dir.y = 0;
tr_state->ray.dir.z = -FIX_ONE;
tr_state->visual->compositor->hit_square_dist=0;
gf_node_traverse_children((GF_Node *)&stack->untr, tr_state);
gf_mx_copy(tr_state->model_matrix, mx_model);
memcpy(tr_state->camera, &backup_cam, sizeof(GF_Camera));
tr_state->ray = r;
/*nothing picked, restore previous pick*/
if (!tr_state->visual->compositor->hit_square_dist)
tr_state->visual->compositor->hit_square_dist = prev_dist;
} else {
gf_node_traverse_children((GF_Node *)&stack->untr, tr_state);
gf_mx_copy(tr_state->model_matrix, mx_model);
memcpy(tr_state->camera, &backup_cam, sizeof(GF_Camera));
}
} else
#endif
{
GF_Matrix2D mx2d_backup;
gf_mx2d_copy(mx2d_backup, tr_state->transform);
gf_mx2d_init(tr_state->transform);
group_2d_traverse((GF_Node *)&stack->untr, (GroupingNode2D *)stack, tr_state);
gf_mx2d_copy(tr_state->transform, mx2d_backup);
}
}
void compositor_3d_draw_bitmap(Drawable *stack, DrawAspect2D *asp, GF_TraverseState *tr_state, Fixed width, Fixed height, Fixed bmp_scale_x, Fixed bmp_scale_y)
{
u8 alpha;
GF_TextureHandler *txh;
GF_Compositor *compositor = tr_state->visual->compositor;
if (!asp->fill_texture)
return;
txh = asp->fill_texture;
if (!txh || !txh->tx_io || !txh->width || !txh->height)
return;
if (((txh->pixelformat==GF_PIXEL_RGBD) || (txh->pixelformat==GF_PIXEL_YUVD))) {
if (compositor->depth_gl_type) {
if (txh->data && gf_sc_texture_convert(txh) )
visual_3d_point_sprite(tr_state->visual, stack, txh, tr_state);
return;
}
}
alpha = GF_COL_A(asp->fill_color);
/*THIS IS A HACK, will not work when setting filled=0, transparency and XLineProps*/
if (!alpha) alpha = GF_COL_A(asp->line_color);
visual_3d_set_state(tr_state->visual, V3D_STATE_LIGHT, GF_FALSE);
visual_3d_enable_antialias(tr_state->visual, GF_FALSE);
if (alpha && (alpha != 0xFF)) {
visual_3d_set_material_2d_argb(tr_state->visual, GF_COL_ARGB(alpha, 0xFF, 0xFF, 0xFF));
gf_sc_texture_set_blend_mode(txh, TX_MODULATE);
} else if (gf_sc_texture_is_transparent(txh)) {
gf_sc_texture_set_blend_mode(txh, TX_REPLACE);
} else {
visual_3d_set_state(tr_state->visual, V3D_STATE_BLEND, GF_FALSE);
}
/*ignore texture transform for bitmap*/
tr_state->mesh_num_textures = gf_sc_texture_enable(txh, NULL);
if (tr_state->mesh_num_textures) {
/*we must check the w & h passed are correct because of bitmap node initialization*/
if (width && height) {
if (!stack->mesh) {
SFVec2f size;
size.x = width;
size.y = height;
stack->mesh = new_mesh();
mesh_new_rectangle(stack->mesh, size, NULL, GF_FALSE);
}
}
if (stack->mesh) {
#ifdef GF_SR_USE_DEPTH
if (tr_state->depth_offset) {
GF_Matrix mx;
Fixed offset;
Fixed disp_depth = (compositor->display_depth<0) ? INT2FIX(tr_state->visual->height) : INT2FIX(compositor->display_depth);
if (disp_depth) {
GF_Matrix bck_mx;
if (!tr_state->pixel_metrics) disp_depth = gf_divfix(disp_depth, tr_state->min_hsize);
gf_mx_init(mx);
/*add recalibration by the scene*/
offset = tr_state->depth_offset;
if (tr_state->visual->depth_vp_range) {
offset = gf_divfix(offset, tr_state->visual->depth_vp_range/2);
}
gf_mx_add_translation(&mx, 0, 0, gf_mulfix(offset, disp_depth/2) );
gf_mx_copy(bck_mx, tr_state->model_matrix);
gf_mx_add_matrix(&tr_state->model_matrix, &mx);
visual_3d_mesh_paint(tr_state, stack->mesh);
gf_mx_copy(tr_state->model_matrix, bck_mx);
} else {
visual_3d_mesh_paint(tr_state, stack->mesh);
}
} else
#endif
visual_3d_mesh_paint(tr_state, stack->mesh);
}
gf_sc_texture_disable(txh);
tr_state->mesh_num_textures = 0;
}
}
void svg_drawable_3d_pick(Drawable *drawable, GF_TraverseState *tr_state, DrawAspect2D *asp)
{
SFVec3f local_pt, world_pt, vdiff;
SFVec3f hit_normal;
SFVec2f text_coords;
u32 i, count;
Fixed sqdist;
Bool node_is_over;
GF_Compositor *compositor;
GF_Matrix mx;
GF_Ray r;
compositor = tr_state->visual->compositor;
node_is_over = 0;
r = tr_state->ray;
gf_mx_copy(mx, tr_state->model_matrix);
gf_mx_inverse(&mx);
gf_mx_apply_ray(&mx, &r);
/*if we already have a hit point don't check anything below...*/
if (compositor->hit_square_dist && !compositor->grabbed_sensor && !tr_state->layer3d) {
GF_Plane p;
GF_BBox box;
SFVec3f hit = compositor->hit_world_point;
gf_mx_apply_vec(&mx, &hit);
p.normal = r.dir;
p.d = -1 * gf_vec_dot(p.normal, hit);
gf_bbox_from_rect(&box, &drawable->path->bbox);
if (gf_bbox_plane_relation(&box, &p) == GF_BBOX_FRONT) {
GF_LOG(GF_LOG_DEBUG, GF_LOG_COMPOSE, ("[SVG Picking] bounding box of node %s (DEF %s) below current hit point - skipping\n", gf_node_get_class_name(drawable->node), gf_node_get_name(drawable->node)));
return;
}
}
node_is_over = 0;
if (compositor_get_2d_plane_intersection(&r, &local_pt)) {
node_is_over = svg_drawable_is_over(drawable, local_pt.x, local_pt.y, asp, tr_state, NULL);
}
if (!node_is_over) return;
hit_normal.x = hit_normal.y = 0; hit_normal.z = FIX_ONE;
text_coords.x = gf_divfix(local_pt.x, drawable->path->bbox.width) + FIX_ONE/2;
text_coords.y = gf_divfix(local_pt.y, drawable->path->bbox.height) + FIX_ONE/2;
/*check distance from user and keep the closest hitpoint*/
world_pt = local_pt;
gf_mx_apply_vec(&tr_state->model_matrix, &world_pt);
for (i=0; i<tr_state->num_clip_planes; i++) {
if (gf_plane_get_distance(&tr_state->clip_planes[i], &world_pt) < 0) {
GF_LOG(GF_LOG_DEBUG, GF_LOG_COMPOSE, ("[SVG Picking] node %s (def %s) is not in clipper half space\n", gf_node_get_class_name(drawable->node), gf_node_get_name(drawable->node)));
return;
}
}
gf_vec_diff(vdiff, world_pt, tr_state->ray.orig);
sqdist = gf_vec_lensq(vdiff);
if (compositor->hit_square_dist && (compositor->hit_square_dist+FIX_EPSILON<sqdist)) {
GF_LOG(GF_LOG_DEBUG, GF_LOG_COMPOSE, ("[SVG Picking] node %s (def %s) is farther (%g) than current pick (%g)\n", gf_node_get_class_name(drawable->node), gf_node_get_name(drawable->node), FIX2FLT(sqdist), FIX2FLT(compositor->hit_square_dist)));
return;
}
compositor->hit_square_dist = sqdist;
/*also stack any VRML sensors present at the current level. If the event is not catched
by a listener in the SVG tree, the event will be forwarded to the VRML tree*/
gf_list_reset(compositor->sensors);
count = gf_list_count(tr_state->vrml_sensors);
for (i=0; i<count; i++) {
gf_list_add(compositor->sensors, gf_list_get(tr_state->vrml_sensors, i));
}
gf_mx_copy(compositor->hit_world_to_local, tr_state->model_matrix);
gf_mx_copy(compositor->hit_local_to_world, mx);
compositor->hit_local_point = local_pt;
compositor->hit_world_point = world_pt;
compositor->hit_world_ray = tr_state->ray;
compositor->hit_normal = hit_normal;
compositor->hit_texcoords = text_coords;
svg_clone_use_stack(compositor, tr_state);
/*not use in SVG patterns*/
compositor->hit_appear = NULL;
compositor->hit_node = drawable->node;
compositor->hit_text = NULL;
compositor->hit_use_dom_events = 1;
GF_LOG(GF_LOG_DEBUG, GF_LOG_COMPOSE, ("[SVG Picking] node %s (def %s) is under mouse - hit %g %g %g\n", gf_node_get_class_name(drawable->node), gf_node_get_name(drawable->node),
FIX2FLT(world_pt.x), FIX2FLT(world_pt.y), FIX2FLT(world_pt.z)));
}
static Bool OnDiscSensor(GF_SensorHandler *sh, Bool is_over, Bool is_cancel, GF_Event *ev, GF_Compositor *compositor)
{
Bool is_mouse = (ev->type<=GF_EVENT_MOUSEWHEEL) ? 1 : 0;
M_DiscSensor *ds = (M_DiscSensor *)sh->sensor;
DiscSensorStack *stack = (DiscSensorStack *) gf_node_get_private(sh->sensor);
if (ds->isActive &&
(!ds->enabled
|| /*mouse*/((ev->type==GF_EVENT_MOUSEUP) && (ev->mouse.button==GF_MOUSE_LEFT))
|| /*keyboar*/(!is_mouse && (!is_over|| ((ev->type==GF_EVENT_KEYDOWN) && (ev->key.key_code==GF_KEY_ENTER))) )
) ) {
if (ds->autoOffset) {
ds->offset = ds->rotation_changed;
/*that's an exposedField*/
if (!is_cancel) gf_node_event_out(sh->sensor, 4/*"offset"*/);
}
ds->isActive = 0;
if (!is_cancel) gf_node_event_out(sh->sensor, 5/*"isActive"*/);
sh->grabbed = 0;
return is_cancel ? 0 : 1;
} else if (is_mouse) {
if (!ds->isActive && (ev->type==GF_EVENT_MOUSEDOWN) && (ev->mouse.button==GF_MOUSE_LEFT)) {
/*store inverse matrix*/
gf_mx_copy(stack->initial_matrix, compositor->hit_local_to_world);
stack->start_angle = gf_atan2(compositor->hit_local_point.y, compositor->hit_local_point.x);
ds->isActive = 1;
gf_node_event_out(sh->sensor, 5/*"isActive"*/);
sh->grabbed = 1;
return 1;
}
else if (ds->isActive) {
GF_Ray loc_ray;
Fixed rot;
SFVec3f res;
loc_ray = compositor->hit_world_ray;
gf_mx_apply_ray(&stack->initial_matrix, &loc_ray);
compositor_get_2d_plane_intersection(&loc_ray, &res);
rot = gf_atan2(res.y, res.x) - stack->start_angle + ds->offset;
if (ds->minAngle < ds->maxAngle) {
/*FIXME this doesn't work properly*/
if (rot < ds->minAngle) rot = ds->minAngle;
if (rot > ds->maxAngle) rot = ds->maxAngle;
}
ds->rotation_changed = rot;
gf_node_event_out(sh->sensor, 6/*"rotation_changed"*/);
ds->trackPoint_changed.x = res.x;
ds->trackPoint_changed.y = res.y;
gf_node_event_out(sh->sensor, 7/*"trackPoint_changed"*/);
return 1;
}
} else {
if (!ds->isActive && is_over && (ev->type==GF_EVENT_KEYDOWN) && (ev->key.key_code==GF_KEY_ENTER)) {
ds->isActive = 1;
stack->start_angle = ds->offset;
gf_node_event_out(sh->sensor, 5/*"isActive"*/);
return 1;
}
else if (ds->isActive && (ev->type==GF_EVENT_KEYDOWN)) {
Fixed res;
Fixed diff = (ev->key.flags & GF_KEY_MOD_SHIFT) ? GF_PI/8 : GF_PI/64;
res = stack->start_angle;
switch (ev->key.key_code) {
case GF_KEY_LEFT:
case GF_KEY_UP:
res += -diff;
break;
case GF_KEY_RIGHT:
case GF_KEY_DOWN:
res += diff;
break;
case GF_KEY_HOME:
res = ds->offset;
break;
default:
return 0;
}
if (ds->minAngle < ds->maxAngle) {
/*FIXME this doesn't work properly*/
if (res < ds->minAngle) res = ds->minAngle;
if (res > ds->maxAngle) res = ds->maxAngle;
}
stack->start_angle = res;
ds->rotation_changed = res;
gf_node_event_out(sh->sensor, 6/*"rotation_changed"*/);
return 1;
}
}
return 0;
}
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 TraverseLOD(GF_Node *node, void *rs, Bool is_destroy)
{
GF_ChildNodeItem *children;
MFFloat *ranges;
SFVec3f pos, usr;
u32 which_child, nb_children;
Fixed dist;
Bool do_all;
GF_Matrix mx;
SFVec3f center;
GF_TraverseState *tr_state = (GF_TraverseState *)rs;
s32 *prev_child = (s32 *)gf_node_get_private(node);
if (is_destroy) {
gf_free(prev_child);
gf_sc_check_focus_upon_destroy(node);
return;
}
/*WARNING: X3D/MPEG4 NOT COMPATIBLE*/
if (gf_node_get_tag(node) == TAG_MPEG4_LOD) {
children = ((M_LOD *) node)->level;
ranges = &((M_LOD *) node)->range;
center = ((M_LOD *) node)->center;
#ifndef GPAC_DISABLE_X3D
} else {
children = ((X_LOD *) node)->children;
ranges = &((X_LOD *) node)->range;
center = ((X_LOD *) node)->center;
#endif
}
if (!children) return;
nb_children = gf_node_list_get_count(children);
if (!tr_state->camera) {
do_all = 1;
which_child = 0;
} else {
/*can't cache the matrix here*/
usr = tr_state->camera->position;
pos = center;
gf_mx_copy(mx, tr_state->model_matrix);
gf_mx_inverse(&mx);
gf_mx_apply_vec(&mx, &usr);
gf_vec_diff(pos, pos, usr);
dist = gf_vec_len(pos);
for (which_child=0; which_child<ranges->count; which_child++) {
if (dist<ranges->vals[which_child]) break;
}
if (which_child>=nb_children) which_child = nb_children-1;
/*check if we're traversing the same child or not for audio rendering*/
do_all = 0;
if (gf_node_dirty_get(node)) {
gf_node_dirty_clear(node, 0);
do_all = 1;
} else if ((s32) which_child != *prev_child) {
*prev_child = which_child;
do_all = 1;
}
}
if (do_all) {
u32 i;
Bool prev_switch = tr_state->switched_off;
GF_ChildNodeItem *l = children;
tr_state->switched_off = 1;
i=0;
while (l) {
if (i!=which_child) gf_node_traverse(l->node, rs);
l = l->next;
}
tr_state->switched_off = prev_switch;
}
gf_node_traverse(gf_node_list_get_child(children, which_child), rs);
}
static void TraverseLayer3D(GF_Node *node, void *rs, Bool is_destroy)
{
Bool prev_layer, changed = 0;
GF_List *oldb, *oldv, *oldf, *oldn;
GF_Rect rc;
u32 cur_lights;
GF_List *node_list_backup;
GF_BBox bbox_backup;
GF_Matrix model_backup;
GF_Matrix2D mx2d_backup;
GF_Camera *prev_cam;
GF_VisualManager *old_visual;
M_Layer3D *l = (M_Layer3D *)node;
Layer3DStack *st = (Layer3DStack *) gf_node_get_private(node);
GF_TraverseState *tr_state = (GF_TraverseState *) rs;
if (is_destroy) {
DestroyLayer3D(node);
return;
}
if (st->unsupported) return;
if (gf_node_dirty_get(node)) {
/*main visual in pixel metrics, use output width*/
if (tr_state->pixel_metrics && (tr_state->visual->compositor->visual==tr_state->visual)) {
st->clip.width = INT2FIX(tr_state->visual->compositor->vp_width);
st->clip.height = INT2FIX(tr_state->visual->compositor->vp_height);
} else {
visual_get_size_info(tr_state, &st->clip.width, &st->clip.height);
}
/*setup bounds in local coord system*/
if (l->size.x>=0) st->clip.width = l->size.x;
if (l->size.y>=0) st->clip.height = l->size.y;
st->clip = gf_rect_center(st->clip.width, st->clip.height);
changed = 1;
}
switch (tr_state->traversing_mode) {
case TRAVERSE_GET_BOUNDS:
if (!tr_state->for_node) {
tr_state->bounds = st->clip;
gf_bbox_from_rect(&tr_state->bbox, &st->clip);
return;
}
case TRAVERSE_PICK:
case TRAVERSE_SORT:
/*layers can only be used in a 2D context*/
if (tr_state->camera && tr_state->camera->is_3D) return;
break;
case TRAVERSE_DRAW_2D:
layer3d_draw_2d(node, tr_state);
return;
case TRAVERSE_DRAW_3D:
default:
return;
}
/*layer3D maintains its own stacks*/
oldb = tr_state->backgrounds;
oldv = tr_state->viewpoints;
oldf = tr_state->fogs;
oldn = tr_state->navigations;
tr_state->backgrounds = st->visual->back_stack;
tr_state->viewpoints = st->visual->view_stack;
tr_state->navigations = st->visual->navigation_stack;
tr_state->fogs = st->visual->fog_stack;
prev_layer = tr_state->is_layer;
tr_state->is_layer = 1;
prev_cam = tr_state->camera;
tr_state->camera = &st->visual->camera;
old_visual = tr_state->visual;
bbox_backup = tr_state->bbox;
gf_mx_copy(model_backup, tr_state->model_matrix);
gf_mx2d_copy(mx2d_backup, tr_state->transform);
/*compute viewport in visual coordinate*/
rc = st->clip;
if (prev_cam) {
gf_mx_apply_rect(&tr_state->model_matrix, &rc);
gf_mx_apply_rect(&prev_cam->modelview, &rc);
if (tr_state->camera->flags & CAM_HAS_VIEWPORT)
gf_mx_apply_rect(&prev_cam->viewport, &rc);
#if 0
if (tr_state->visual->compositor->visual==tr_state->visual) {
GF_Matrix mx;
gf_mx_init(mx);
gf_mx_add_scale(&mx, tr_state->visual->compositor->scale_x, tr_state->visual->compositor->scale_y, FIX_ONE);
gf_mx_apply_rect(&mx, &rc);
}
#endif
} else {
gf_mx2d_apply_rect(&tr_state->transform, &rc);
/* if (tr_state->visual->compositor->visual==tr_state->visual) {
gf_mx2d_init(mx2d_backup);
gf_mx2d_add_scale(&mx2d_backup, tr_state->visual->compositor->scale_x, tr_state->visual->compositor->scale_y);
gf_mx2d_apply_rect(&mx2d_backup, &rc);
}
*/
/*switch visual*/
tr_state->visual = st->visual;
}
/*check bindables*/
gf_mx_init(tr_state->model_matrix);
l3d_CheckBindables(node, tr_state, st->first);
if (prev_cam) gf_mx_copy(tr_state->model_matrix, model_backup);
/*drawing a layer means drawing all subelements as a whole (no depth sorting with parents)*/
if (tr_state->traversing_mode==TRAVERSE_SORT) {
if (gf_node_dirty_get(node)) changed = 1;
gf_node_dirty_clear(node, GF_SG_NODE_DIRTY|GF_SG_VRML_BINDABLE_DIRTY);
/*!! we were in a 2D mode, setup associated texture !!*/
if (!prev_cam) {
switch (layer3d_setup_offscreen(node, st, tr_state, rc.width, rc.height)) {
case 0:
goto l3d_exit;
case 2:
if (!changed && !(st->visual->camera.flags & CAM_IS_DIRTY) && !st->visual->camera.anim_len) {
GF_LOG(GF_LOG_DEBUG, GF_LOG_COMPOSE, ("[Layer3D] No changes found , skipping 3D draw\n"));
goto layer3d_unchanged_2d;
}
default:
break;
}
#ifdef GPAC_USE_TINYGL
if (st->tgl_ctx) ostgl_make_current(st->tgl_ctx, 0);
#endif
/*note that we don't backup the state as a layer3D cannot be declared in a layer3D*/
tr_state->layer3d = node;
rc = st->vp;
/*setup GL*/
visual_3d_setup(tr_state->visual);
visual_3d_set_matrix_mode(tr_state->visual, V3D_MATRIX_PROJECTION);
visual_3d_matrix_reset(tr_state->visual);
visual_3d_set_matrix_mode(tr_state->visual, V3D_MATRIX_TEXTURE);
visual_3d_matrix_reset(tr_state->visual);
visual_3d_set_matrix_mode(tr_state->visual, V3D_MATRIX_MODELVIEW);
visual_3d_matrix_reset(tr_state->visual);
} else {
visual_3d_set_matrix_mode(tr_state->visual, V3D_MATRIX_PROJECTION);
visual_3d_matrix_push(tr_state->visual);
visual_3d_set_matrix_mode(tr_state->visual, V3D_MATRIX_TEXTURE);
visual_3d_matrix_push(tr_state->visual);
visual_3d_set_matrix_mode(tr_state->visual, V3D_MATRIX_MODELVIEW);
visual_3d_matrix_push(tr_state->visual);
}
GF_LOG(GF_LOG_DEBUG, GF_LOG_COMPOSE, ("[Layer3D] Redrawing\n"));
layer3d_setup_clip(st, tr_state, prev_cam ? 1 : 0, rc);
cur_lights = tr_state->visual->num_lights;
/*this will init projection. Note that we're binding the viewpoint in the current pixelMetrics context
even if the viewpoint was declared in an inline below
if no previous camera, we're using offscreen rendering, force clear */
visual_3d_init_draw(tr_state, prev_cam ? 1 : 2);
visual_3d_check_collisions(tr_state, l->children);
tr_state->traversing_mode = TRAVERSE_SORT;
/*shortcut node list*/
node_list_backup = tr_state->visual->alpha_nodes_to_draw;
tr_state->visual->alpha_nodes_to_draw = gf_list_new();
/*reset cull flag*/
tr_state->cull_flag = 0;
group_3d_traverse(node, (GroupingNode *)st, tr_state);
visual_3d_flush_contexts(tr_state->visual, tr_state);
gf_list_del(tr_state->visual->alpha_nodes_to_draw);
tr_state->visual->alpha_nodes_to_draw = node_list_backup;
while (cur_lights < tr_state->visual->num_lights) {
visual_3d_remove_last_light(tr_state->visual);
}
tr_state->traversing_mode = TRAVERSE_SORT;
if (prev_cam) {
visual_3d_set_matrix_mode(tr_state->visual, V3D_MATRIX_PROJECTION);
visual_3d_matrix_pop(tr_state->visual);
visual_3d_set_matrix_mode(tr_state->visual, V3D_MATRIX_TEXTURE);
visual_3d_matrix_pop(tr_state->visual);
visual_3d_set_matrix_mode(tr_state->visual, V3D_MATRIX_MODELVIEW);
visual_3d_matrix_pop(tr_state->visual);
}
/*!! we were in a 2D mode, create drawable context!!*/
if (!prev_cam) {
DrawableContext *ctx;
/*with TinyGL we draw directly to the offscreen buffer*/
#ifndef GPAC_USE_TINYGL
gf_sc_copy_to_stencil(&st->txh);
#else
if (st->txh.pixelformat==GF_PIXEL_RGBDS)
gf_get_tinygl_depth(&st->txh);
#endif
if (tr_state->visual->compositor->rasterizer->stencil_texture_modified)
tr_state->visual->compositor->rasterizer->stencil_texture_modified(gf_sc_texture_get_stencil(&st->txh) );
gf_sc_texture_set_stencil(&st->txh, gf_sc_texture_get_stencil(&st->txh) );
changed = 1;
layer3d_unchanged_2d:
/*restore visual*/
tr_state->visual = old_visual;
tr_state->layer3d = NULL;
tr_state->appear = NULL;
// tr_state->camera = prev_cam;
ctx = drawable_init_context_mpeg4(st->drawable, tr_state);
if (!ctx) return;
ctx->aspect.fill_texture = &st->txh;
ctx->flags |= CTX_NO_ANTIALIAS;
if (changed) ctx->flags |= CTX_APP_DIRTY;
if (st->txh.transparent) ctx->flags |= CTX_IS_TRANSPARENT;
drawable_finalize_sort(ctx, tr_state, NULL);
}
}
/*check picking - we must fall in our 2D clipper except when mvt is grabbed on layer*/
else if (!gf_node_dirty_get(node) && (tr_state->traversing_mode==TRAVERSE_PICK)) {
GF_Ray prev_r;
SFVec3f start, end;
SFVec4f res;
Fixed in_x, in_y;
Bool do_pick = 0;
if (!prev_cam) rc = st->vp;
layer3d_setup_clip(st, tr_state, prev_cam ? 1 : 0, rc);
if (tr_state->visual->compositor->active_layer==node) {
do_pick = (tr_state->visual->compositor->grabbed_sensor || tr_state->visual->compositor->navigation_state) ? 1 : 0;
}
if (!prev_cam) gf_mx_from_mx2d(&tr_state->model_matrix, &tr_state->transform);
if (!do_pick && !gf_list_count(tr_state->visual->compositor->sensors))
do_pick = gf_sc_pick_in_clipper(tr_state, &st->clip);
if (!do_pick) goto l3d_exit;
prev_r = tr_state->ray;
compositor_get_2d_plane_intersection(&tr_state->ray, &start);
gf_mx_inverse(&tr_state->model_matrix);
gf_mx_apply_vec(&tr_state->model_matrix, &start);
if (tr_state->visual->compositor->visual==tr_state->visual) {
start.x = gf_mulfix(start.x, tr_state->visual->compositor->scale_x);
start.y = gf_mulfix(start.y, tr_state->visual->compositor->scale_y);
} else if (!prev_cam) {
start.x = gf_muldiv(start.x, st->visual->camera.width, st->clip.width);
start.y = gf_muldiv(start.y, st->visual->camera.height, st->clip.height);
}
visual_3d_setup_projection(tr_state, 1);
in_x = 2 * gf_divfix(start.x, st->visual->camera.width);
in_y = 2 * gf_divfix(start.y, st->visual->camera.height);
res.x = in_x; res.y = in_y; res.z = -FIX_ONE; res.q = FIX_ONE;
gf_mx_apply_vec_4x4(&st->visual->camera.unprojection, &res);
if (!res.q) goto l3d_exit;
start.x = gf_divfix(res.x, res.q);
start.y = gf_divfix(res.y, res.q);
start.z = gf_divfix(res.z, res.q);
res.x = in_x; res.y = in_y; res.z = FIX_ONE; res.q = FIX_ONE;
gf_mx_apply_vec_4x4(&st->visual->camera.unprojection, &res);
if (!res.q) goto l3d_exit;
end.x = gf_divfix(res.x, res.q);
end.y = gf_divfix(res.y, res.q);
end.z = gf_divfix(res.z, res.q);
tr_state->ray = gf_ray(start, end);
GF_LOG(GF_LOG_DEBUG, GF_LOG_COMPOSE, ("[Layer3D] Picking: cast ray\n\tOrigin %.4f %.4f %.4f - End %.4f %.4f %.4f\n\tDir %.4f %.4f %.4f\n",
FIX2FLT(tr_state->ray.orig.x), FIX2FLT(tr_state->ray.orig.y), FIX2FLT(tr_state->ray.orig.z),
FIX2FLT(end.x), FIX2FLT(end.y), FIX2FLT(end.z),
FIX2FLT(tr_state->ray.dir.x), FIX2FLT(tr_state->ray.dir.y), FIX2FLT(tr_state->ray.dir.z)));
group_3d_traverse(node, (GroupingNode *)st, tr_state);
tr_state->ray = prev_r;
/*store info if navigation allowed - we just override any layer3D picked first since we are picking 2D
objects*/
if (tr_state->camera->navigate_mode || (tr_state->camera->navigation_flags & NAV_ANY))
tr_state->layer3d = node;
tr_state->traversing_mode = TRAVERSE_PICK;
}
l3d_exit:
/*restore camera*/
tr_state->camera = prev_cam;
if (prev_cam) visual_3d_set_viewport(tr_state->visual, tr_state->camera->vp);
tr_state->visual = old_visual;
/*restore traversing state*/
tr_state->backgrounds = oldb;
tr_state->viewpoints = oldv;
tr_state->fogs = oldf;
tr_state->navigations = oldn;
tr_state->bbox = bbox_backup;
tr_state->is_layer = prev_layer;
gf_mx_copy(tr_state->model_matrix, model_backup);
gf_mx2d_copy(tr_state->transform, mx2d_backup);
/*in case we missed bindables*/
if (st->first) {
st->first = 0;
gf_node_dirty_set(node, 0, 0);
gf_sc_invalidate(tr_state->visual->compositor, NULL);
}
}
static void svg_traverse_svg(GF_Node *node, void *rs, Bool is_destroy)
{
Bool rootmost_svg, send_resize;
u32 viewport_color;
SVGsvgStack *stack;
GF_Matrix2D backup_matrix, vb_bck;
#ifndef GPAC_DISABLE_3D
GF_Matrix bck_mx;
#endif
Bool is_dirty;
GF_IRect top_clip;
SFVec2f prev_vp;
SVGPropertiesPointers backup_props, *prev_props;
u32 backup_flags;
Bool invalidate_flag;
u32 styling_size = sizeof(SVGPropertiesPointers);
GF_TraverseState *tr_state = (GF_TraverseState *) rs;
SVGAllAttributes all_atts;
stack = gf_node_get_private(node);
if (is_destroy) {
if (stack->svg_props) {
gf_svg_properties_reset_pointers(stack->svg_props);
gf_free(stack->svg_props);
}
gf_sc_check_focus_upon_destroy(node);
if (stack->vp_fill) drawable_del(stack->vp_fill);
gf_free(stack);
return;
}
prev_props = tr_state->svg_props;
/*SVG props not set: we are either the root-most <svg> of the compositor
or an <svg> inside an <animation>*/
if (!tr_state->svg_props) {
tr_state->svg_props = stack->svg_props;
if (!tr_state->svg_props) return;
}
gf_svg_flatten_attributes((SVG_Element *)node, &all_atts);
if (!compositor_svg_traverse_base(node, &all_atts, tr_state, &backup_props, &backup_flags)) {
tr_state->svg_props = prev_props;
return;
}
/*enable or disable navigation*/
tr_state->visual->compositor->navigation_disabled = (all_atts.zoomAndPan && *all_atts.zoomAndPan == SVG_ZOOMANDPAN_DISABLE) ? 1 : 0;
if (compositor_svg_is_display_off(tr_state->svg_props)) {
memcpy(tr_state->svg_props, &backup_props, styling_size);
tr_state->svg_flags = backup_flags;
return;
}
top_clip = tr_state->visual->top_clipper;
gf_mx2d_copy(backup_matrix, tr_state->transform);
gf_mx2d_copy(vb_bck, tr_state->vb_transform);
#ifndef GPAC_DISABLE_3D
if (tr_state->visual->type_3d) gf_mx_copy(bck_mx, tr_state->model_matrix);
#endif
invalidate_flag = tr_state->invalidate_all;
is_dirty = gf_node_dirty_get(node);
if (is_dirty & GF_SG_CHILD_DIRTY) drawable_reset_group_highlight(tr_state, node);
gf_node_dirty_clear(node, 0);
send_resize = 0;
if ((stack->parent_vp.x != tr_state->vp_size.x) || (stack->parent_vp.y != tr_state->vp_size.y)) {
is_dirty = 1;
send_resize = 1;
}
if (is_dirty || tr_state->visual->compositor->recompute_ar) {
svg_recompute_viewport_transformation(node, stack, tr_state, &all_atts);
}
gf_mx2d_copy(tr_state->vb_transform, stack->viewbox_mx);
rootmost_svg = (stack->root_svg && !tr_state->parent_anim_atts) ? 1 : 0;
if (tr_state->traversing_mode == TRAVERSE_SORT) {
SVG_Paint *vp_fill = NULL;
Fixed vp_opacity;
if (tr_state->parent_anim_atts) {
vp_fill = tr_state->parent_anim_atts->viewport_fill;
vp_opacity = tr_state->parent_anim_atts->viewport_fill_opacity ? tr_state->parent_anim_atts->viewport_fill_opacity->value : FIX_ONE;
} else {
vp_fill = tr_state->svg_props->viewport_fill;
vp_opacity = tr_state->svg_props->viewport_fill_opacity ? tr_state->svg_props->viewport_fill_opacity->value : FIX_ONE;
}
if (vp_fill && (vp_fill->type != SVG_PAINT_NONE) && vp_opacity) {
Bool col_dirty = 0;
viewport_color = GF_COL_ARGB_FIXED(vp_opacity, vp_fill->color.red, vp_fill->color.green, vp_fill->color.blue);
if (stack->prev_color != viewport_color) {
stack->prev_color = viewport_color;
col_dirty = 1;
}
if (!rootmost_svg) {
DrawableContext *ctx;
Fixed width = tr_state->parent_anim_atts->width->value;
Fixed height = tr_state->parent_anim_atts->height->value;
if (!stack->vp_fill) {
stack->vp_fill = drawable_new();
stack->vp_fill->node = node;
}
if ((width != stack->vp_fill->path->bbox.width) || (height != stack->vp_fill->path->bbox.height)) {
drawable_reset_path(stack->vp_fill);
gf_path_add_rect(stack->vp_fill->path, 0, 0, width, -height);
}
ctx = drawable_init_context_svg(stack->vp_fill, tr_state);
if (ctx) {
ctx->flags &= ~CTX_IS_TRANSPARENT;
ctx->aspect.pen_props.width = 0;
ctx->aspect.fill_color = viewport_color;
ctx->aspect.fill_texture = NULL;
if (col_dirty) ctx->flags |= CTX_APP_DIRTY;
drawable_finalize_sort(ctx, tr_state, NULL);
}
} else if (col_dirty) {
tr_state->visual->compositor->back_color = viewport_color;
/*invalidate the entire visual*/
tr_state->invalidate_all = 1;
}
}
}
if (!stack->root_svg && (all_atts.x || all_atts.y))
gf_mx2d_add_translation(&tr_state->vb_transform, all_atts.x->value, all_atts.y->value);
#ifndef GPAC_DISABLE_3D
if (tr_state->visual->type_3d) {
if (tr_state->traversing_mode==TRAVERSE_SORT) {
GF_Matrix tmp;
visual_3d_matrix_push(tr_state->visual);
gf_mx_from_mx2d(&tmp, &tr_state->vb_transform);
visual_3d_matrix_add(tr_state->visual, tmp.m);
} else {
gf_mx_add_matrix_2d(&tr_state->model_matrix, &tr_state->vb_transform);
}
} else
#endif
{
gf_mx2d_pre_multiply(&tr_state->transform, &tr_state->vb_transform);
}
/*store VP and move it to current VP (eg, the one used to compute the vb_transform)*/
prev_vp = tr_state->vp_size;
tr_state->vp_size = stack->vp;
/*the event may trigger scripts which may delete nodes / modify the scene. We therefore send the resize event
before traversing the scene*/
if (send_resize) {
GF_DOM_Event evt;
memset(&evt, 0, sizeof(GF_DOM_Event));
evt.bubbles = 1;
evt.type = GF_EVENT_RESIZE;
gf_dom_event_fire(node, &evt);
}
if ((stack->vp.x != prev_vp.x) || (stack->vp.y != prev_vp.y)) {
GF_Scene *scene = node->sgprivate->scenegraph->userpriv;
if (scene) {
GF_DOM_Event evt;
memset(&evt, 0, sizeof(GF_DOM_Event));
evt.bubbles = 0;
evt.screen_rect.width = stack->vpw;
evt.screen_rect.height = stack->vph;
evt.screen_rect.x = stack->dx;
evt.screen_rect.y = stack->dy;
evt.prev_translate.x = stack->vp.x;
evt.prev_translate.y = stack->vp.y;
evt.type = GF_EVENT_VP_RESIZE;
gf_scene_notify_event(scene, 0, NULL, &evt, GF_OK);
}
}
if (tr_state->traversing_mode == TRAVERSE_GET_BOUNDS) {
gf_sc_get_nodes_bounds(node, ((SVG_Element *)node)->children, tr_state, NULL);
} else {
compositor_svg_traverse_children(((SVG_Element *)node)->children, tr_state);
}
tr_state->vp_size = prev_vp;
#ifndef GPAC_DISABLE_3D
if (tr_state->visual->type_3d) {
if (tr_state->traversing_mode==TRAVERSE_SORT) visual_3d_matrix_pop(tr_state->visual);
gf_mx_copy(tr_state->model_matrix, bck_mx);
}
#endif
gf_mx2d_copy(tr_state->transform, backup_matrix);
gf_mx2d_copy(tr_state->vb_transform, vb_bck);
memcpy(tr_state->svg_props, &backup_props, styling_size);
tr_state->svg_flags = backup_flags;
tr_state->visual->top_clipper = top_clip;
if (!stack->root_svg) {
tr_state->invalidate_all = invalidate_flag;
}
tr_state->svg_props = prev_props;
}
static Bool OnCylinderSensor(GF_SensorHandler *sh, Bool is_over, Bool is_cancel, GF_Event *ev, GF_Compositor *compositor)
{
Bool is_mouse = (ev->type<=GF_EVENT_MOUSEWHEEL) ? 1 : 0;
M_CylinderSensor *cs = (M_CylinderSensor *)sh->sensor;
CylinderSensorStack *st = (CylinderSensorStack *) gf_node_get_private(sh->sensor);
if (cs->isActive && (!cs->enabled
|| /*mouse*/((ev->type==GF_EVENT_MOUSEUP) && (ev->mouse.button==GF_MOUSE_LEFT))
|| /*keyboar*/(!is_mouse && (!is_over|| ((ev->type==GF_EVENT_KEYDOWN) && (ev->key.key_code==GF_KEY_ENTER))))
) ) {
if (cs->autoOffset) {
cs->offset = cs->rotation_changed.q;
if (!is_cancel) gf_node_event_out(sh->sensor, 5/*"offset"*/);
}
cs->isActive = 0;
if (!is_cancel) gf_node_event_out(sh->sensor, 6/*"isActive"*/);
sh->grabbed = 0;
return is_cancel ? 0 : 1;
}
else if (is_mouse) {
if (!cs->isActive && (ev->type==GF_EVENT_MOUSEDOWN) && (ev->mouse.button==GF_MOUSE_LEFT)) {
GF_Ray r;
SFVec3f yaxis;
Fixed acute, reva;
SFVec3f bearing;
gf_mx_copy(st->init_matrix, compositor->hit_world_to_local);
/*get initial angle & check disk mode*/
r = compositor->hit_world_ray;
gf_vec_add(r.dir, r.orig, r.dir);
gf_mx_apply_vec(&compositor->hit_world_to_local, &r.orig);
gf_mx_apply_vec(&compositor->hit_world_to_local, &r.dir);
gf_vec_diff(bearing, r.orig, r.dir);
gf_vec_norm(&bearing);
yaxis.x = yaxis.z = 0;
yaxis.y = FIX_ONE;
acute = gf_vec_dot(bearing, yaxis);
if (acute < -FIX_ONE) acute = -FIX_ONE;
else if (acute > FIX_ONE) acute = FIX_ONE;
acute = gf_acos(acute);
reva = ABS(GF_PI - acute);
if (reva<acute) acute = reva;
st->disk_mode = (acute < cs->diskAngle) ? 1 : 0;
st->grab_start = compositor->hit_local_point;
/*cos we're lazy*/
st->yplane.d = 0;
st->yplane.normal.x = st->yplane.normal.z = st->yplane.normal.y = 0;
st->zplane = st->xplane = st->yplane;
st->xplane.normal.x = FIX_ONE;
st->yplane.normal.y = FIX_ONE;
st->zplane.normal.z = FIX_ONE;
cs->rotation_changed.x = 0;
cs->rotation_changed.y = FIX_ONE;
cs->rotation_changed.z = 0;
cs->isActive = 1;
gf_node_event_out(sh->sensor, 6/*"isActive"*/);
sh->grabbed = 1;
return 1;
}
else if (cs->isActive) {
GF_Ray r;
Fixed radius, rot;
SFVec3f dir1, dir2, cx;
if (is_over) {
cs->trackPoint_changed = compositor->hit_local_point;
gf_node_event_out(sh->sensor, 8/*"trackPoint_changed"*/);
} else {
GF_Plane project_to;
r = compositor->hit_world_ray;
gf_mx_apply_ray(&st->init_matrix, &r);
/*no intersection, use intersection with "main" fronting plane*/
if ( ABS(r.dir.z) > ABS(r.dir.y)) {
if (ABS(r.dir.z) > ABS(r.dir.x)) project_to = st->xplane;
else project_to = st->yplane;
} else {
if (ABS(r.dir.z) > ABS(r.dir.x)) project_to = st->xplane;
else project_to = st->zplane;
}
if (!gf_plane_intersect_line(&project_to, &r.orig, &r.dir, &compositor->hit_local_point)) return 0;
}
dir1.x = compositor->hit_local_point.x;
dir1.y = 0;
dir1.z = compositor->hit_local_point.z;
if (st->disk_mode) {
radius = FIX_ONE;
} else {
radius = gf_vec_len(dir1);
}
gf_vec_norm(&dir1);
dir2.x = st->grab_start.x;
dir2.y = 0;
dir2.z = st->grab_start.z;
gf_vec_norm(&dir2);
cx = gf_vec_cross(dir2, dir1);
gf_vec_norm(&cx);
if (gf_vec_len(cx)<FIX_EPSILON) return 0;
rot = gf_mulfix(radius, gf_acos(gf_vec_dot(dir2, dir1)) );
if (fabs(cx.y + FIX_ONE) < FIX_EPSILON) rot = -rot;
if (cs->autoOffset) rot += cs->offset;
if (cs->minAngle < cs->maxAngle) {
if (rot < cs->minAngle) rot = cs->minAngle;
else if (rot > cs->maxAngle) rot = cs->maxAngle;
}
cs->rotation_changed.q = rot;
gf_node_event_out(sh->sensor, 7/*"rotation_changed"*/);
return 1;
}
} else {
if (!cs->isActive && is_over && (ev->type==GF_EVENT_KEYDOWN) && (ev->key.key_code==GF_KEY_ENTER)) {
cs->isActive = 1;
cs->rotation_changed.q = cs->offset;
cs->rotation_changed.x = cs->rotation_changed.z = 0;
cs->rotation_changed.y = FIX_ONE;
gf_node_event_out(sh->sensor, 6/*"isActive"*/);
return 1;
}
else if (cs->isActive && (ev->type==GF_EVENT_KEYDOWN)) {
SFFloat res;
Fixed diff = (ev->key.flags & GF_KEY_MOD_SHIFT) ? GF_PI/8 : GF_PI/64;
res = cs->rotation_changed.q;
switch (ev->key.key_code) {
case GF_KEY_LEFT:
res -= diff;
break;
case GF_KEY_RIGHT:
res += diff;
break;
case GF_KEY_HOME:
res = cs->offset;
break;
default:
return 0;
}
/*clip*/
if (cs->minAngle <= cs->maxAngle) {
if (res < cs->minAngle) res = cs->minAngle;
if (res > cs->maxAngle) res = cs->maxAngle;
}
cs->rotation_changed.q = res;
gf_node_event_out(sh->sensor, 7/*"rotation_changed"*/);
return 1;
}
}
return 0;
}
static Bool OnPlaneSensor(GF_SensorHandler *sh, Bool is_over, Bool is_cancel, GF_Event *ev, GF_Compositor *compositor)
{
Bool is_mouse = (ev->type<=GF_EVENT_MOUSEWHEEL) ? 1 : 0;
M_PlaneSensor *ps = (M_PlaneSensor *)sh->sensor;
PSStack *stack = (PSStack *) gf_node_get_private(sh->sensor);
if (ps->isActive &&
( /*mouse*/((ev->type==GF_EVENT_MOUSEUP) && (ev->mouse.button==GF_MOUSE_LEFT))
|| /*keyboar*/(!is_mouse && (!is_over|| ((ev->type==GF_EVENT_KEYDOWN) && (ev->key.key_code==GF_KEY_ENTER))) )
) ) {
if (ps->autoOffset) {
ps->offset = ps->translation_changed;
if (!is_cancel) gf_node_event_out(sh->sensor, 4/*"offset"*/);
}
ps->isActive = 0;
if (!is_cancel) gf_node_event_out(sh->sensor, 5/*"isActive"*/);
sh->grabbed = 0;
return is_cancel ? 0 : 1;
}
/*mouse*/
else if (is_mouse) {
if (!ps->isActive && (ev->type==GF_EVENT_MOUSEDOWN) && (ev->mouse.button==GF_MOUSE_LEFT) ) {
gf_mx_copy(stack->initial_matrix, compositor->hit_local_to_world);
gf_vec_diff(stack->start_drag, compositor->hit_local_point, ps->offset);
stack->tracker.normal.x = stack->tracker.normal.y = 0;
stack->tracker.normal.z = FIX_ONE;
stack->tracker.d = - gf_vec_dot(stack->start_drag, stack->tracker.normal);
ps->isActive = 1;
gf_node_event_out(sh->sensor, 5/*"isActive"*/);
sh->grabbed = 1;
return 1;
}
else if (ps->isActive) {
GF_Ray loc_ray;
SFVec3f res;
loc_ray = compositor->hit_world_ray;
gf_mx_apply_ray(&stack->initial_matrix, &loc_ray);
gf_plane_intersect_line(&stack->tracker, &loc_ray.orig, &loc_ray.dir, &res);
ps->trackPoint_changed = res;
gf_node_event_out(sh->sensor, 6/*"trackPoint_changed"*/);
gf_vec_diff(res, res, stack->start_drag);
/*clip*/
if (ps->minPosition.x <= ps->maxPosition.x) {
if (res.x < ps->minPosition.x) res.x = ps->minPosition.x;
if (res.x > ps->maxPosition.x) res.x = ps->maxPosition.x;
}
if (ps->minPosition.y <= ps->maxPosition.y) {
if (res.y < ps->minPosition.y) res.y = ps->minPosition.y;
if (res.y > ps->maxPosition.y) res.y = ps->maxPosition.y;
}
ps->translation_changed = res;
gf_node_event_out(sh->sensor, 7/*"translation_changed"*/);
return 1;
}
} else {
if (!ps->isActive && is_over && (ev->type==GF_EVENT_KEYDOWN) && (ev->key.key_code==GF_KEY_ENTER)) {
ps->isActive = 1;
stack->start_drag = ps->offset;
gf_node_event_out(sh->sensor, 5/*"isActive"*/);
return 1;
}
else if (ps->isActive && (ev->type==GF_EVENT_KEYDOWN)) {
SFVec3f res;
Fixed diff = (ev->key.flags & GF_KEY_MOD_SHIFT) ? 5*FIX_ONE : FIX_ONE;
if (!gf_sg_use_pixel_metrics(gf_node_get_graph(sh->sensor)))
diff = gf_divfix(diff, INT2FIX(compositor->vp_width/2));
res = stack->start_drag;
switch (ev->key.key_code) {
case GF_KEY_LEFT:
res.x -= diff;
break;
case GF_KEY_RIGHT:
res.x += diff;
break;
case GF_KEY_UP:
res.y += diff;
break;
case GF_KEY_DOWN:
res.y -= diff;
break;
case GF_KEY_HOME:
res = ps->offset;
break;
default:
return 0;
}
/*clip*/
if (ps->minPosition.x <= ps->maxPosition.x) {
if (res.x < ps->minPosition.x) res.x = ps->minPosition.x;
if (res.x > ps->maxPosition.x) res.x = ps->maxPosition.x;
}
if (ps->minPosition.y <= ps->maxPosition.y) {
if (res.y < ps->minPosition.y) res.y = ps->minPosition.y;
if (res.y > ps->maxPosition.y) res.y = ps->maxPosition.y;
}
stack->start_drag = res;
ps->translation_changed = res;
gf_node_event_out(sh->sensor, 7/*"translation_changed"*/);
return 1;
}
}
return 0;
}
void TraverseProximitySensor(GF_Node *node, void *rs, Bool is_destroy)
{
SFVec3f user_pos, dist, up;
SFRotation ori;
GF_Matrix mx;
GF_TraverseState *tr_state = (GF_TraverseState *)rs;
M_ProximitySensor *ps = (M_ProximitySensor *)node;
if (is_destroy) return;
if (tr_state->traversing_mode==TRAVERSE_GET_BOUNDS) {
/*work with twice bigger bbox to get sure we're notify when culled out*/
gf_vec_add(tr_state->bbox.max_edge, ps->center, ps->size);
gf_vec_diff(tr_state->bbox.min_edge, ps->center, ps->size);
gf_bbox_refresh(&tr_state->bbox);
return;
} else if (!ps->enabled || (tr_state->traversing_mode != TRAVERSE_SORT) ) return;
/*TODO FIXME - find a way to cache inverted matrix*/
gf_mx_copy(mx, tr_state->model_matrix);
gf_mx_inverse(&mx);
/*get use pos in local coord system*/
user_pos = tr_state->camera->position;
gf_mx_apply_vec(&mx, &user_pos);
gf_vec_diff(dist, user_pos, ps->center);
if (dist.x<0) dist.x *= -1;
if (dist.y<0) dist.y *= -1;
if (dist.z<0) dist.z *= -1;
if ((2*dist.x <= ps->size.x)
&& (2*dist.y <= ps->size.y)
&& (2*dist.z <= ps->size.z) ) {
if (!ps->isActive) {
ps->isActive = 1;
gf_node_event_out(node, 3/*"isActive"*/);
ps->enterTime = gf_node_get_scene_time(node);
gf_node_event_out(node, 6/*"enterTime"*/);
}
if ((ps->position_changed.x != user_pos.x)
|| (ps->position_changed.y != user_pos.y)
|| (ps->position_changed.z != user_pos.z) )
{
ps->position_changed = user_pos;
gf_node_event_out(node, 4/*"position_changed"*/);
}
dist = tr_state->camera->target;
gf_mx_apply_vec(&mx, &dist);
up = tr_state->camera->up;
gf_mx_apply_vec(&mx, &up);
ori = camera_get_orientation(user_pos, dist, tr_state->camera->up);
if ((ori.q != ps->orientation_changed.q)
|| (ori.x != ps->orientation_changed.x)
|| (ori.y != ps->orientation_changed.y)
|| (ori.z != ps->orientation_changed.z) ) {
ps->orientation_changed = ori;
gf_node_event_out(node, 5/*"orientation_changed"*/);
}
} else if (ps->isActive) {
ps->isActive = 0;
gf_node_event_out(node, 3/*"isActive"*/);
ps->exitTime = gf_node_get_scene_time(node);
gf_node_event_out(node, 7/*"exitTime"*/);
}
}
static Bool OnPlaneSensor2D(GF_SensorHandler *sh, Bool is_over, Bool is_cancel, GF_Event *ev, GF_Compositor *compositor)
{
Bool is_mouse = (ev->type<=GF_EVENT_MOUSEWHEEL) ? 1 : 0;
M_PlaneSensor2D *ps = (M_PlaneSensor2D *)sh->sensor;
PS2DStack *stack = (PS2DStack *) gf_node_get_private(sh->sensor);
if (ps->isActive &&
(!ps->enabled
|| /*mouse*/((ev->type==GF_EVENT_MOUSEUP) && (ev->mouse.button==GF_MOUSE_LEFT))
|| /*keyboar*/(!is_mouse && (!is_over|| ((ev->type==GF_EVENT_KEYDOWN) && (ev->key.key_code==GF_KEY_ENTER))) )
) ) {
if (ps->autoOffset) {
ps->offset = ps->translation_changed;
if (!is_cancel) gf_node_event_out_str(sh->sensor, "offset");
}
ps->isActive = 0;
if (!is_cancel) gf_node_event_out_str(sh->sensor, "isActive");
sh->grabbed = 0;
return is_cancel ? 0 : 1;
} else if (is_mouse) {
if (!ps->isActive && (ev->type==GF_EVENT_MOUSEDOWN) && (ev->mouse.button==GF_MOUSE_LEFT)) {
gf_mx_copy(stack->initial_matrix, compositor->hit_local_to_world);
stack->start_drag.x = compositor->hit_local_point.x - ps->offset.x;
stack->start_drag.y = compositor->hit_local_point.y - ps->offset.y;
ps->isActive = 1;
gf_node_event_out_str(sh->sensor, "isActive");
sh->grabbed = 1;
/*fallthrough to fire mouse coords*/
//return 1;
}
if (ps->isActive) {
SFVec3f res;
GF_Ray loc_ray;
loc_ray = compositor->hit_world_ray;
gf_mx_apply_ray(&stack->initial_matrix, &loc_ray);
compositor_get_2d_plane_intersection(&loc_ray, &res);
ps->trackPoint_changed.x = res.x;
ps->trackPoint_changed.y = res.y;
gf_node_event_out_str(sh->sensor, "trackPoint_changed");
res.x -= stack->start_drag.x;
res.y -= stack->start_drag.y;
/*clip*/
if (ps->minPosition.x <= ps->maxPosition.x) {
if (res.x < ps->minPosition.x) res.x = ps->minPosition.x;
if (res.x > ps->maxPosition.x) res.x = ps->maxPosition.x;
}
if (ps->minPosition.y <= ps->maxPosition.y) {
if (res.y < ps->minPosition.y)
res.y = ps->minPosition.y;
if (res.y > ps->maxPosition.y)
res.y = ps->maxPosition.y;
}
ps->translation_changed.x = res.x;
ps->translation_changed.y = res.y;
gf_node_event_out_str(sh->sensor, "translation_changed");
return 1;
}
} else {
if (!ps->isActive && is_over && (ev->type==GF_EVENT_KEYDOWN) && (ev->key.key_code==GF_KEY_ENTER)) {
ps->isActive = 1;
stack->start_drag = ps->offset;
gf_node_event_out_str(sh->sensor, "isActive");
return 1;
}
else if (ps->isActive && (ev->type==GF_EVENT_KEYDOWN)) {
SFVec2f res;
Fixed diff = (ev->key.flags & GF_KEY_MOD_SHIFT) ? 5*FIX_ONE : FIX_ONE;
if (!gf_sg_use_pixel_metrics(gf_node_get_graph(sh->sensor)))
diff = gf_divfix(diff, compositor->vp_width/2);
res = stack->start_drag;
switch (ev->key.key_code) {
case GF_KEY_LEFT: res.x += -diff; break;
case GF_KEY_RIGHT: res.x += diff; break;
case GF_KEY_UP: res.y += diff; break;
case GF_KEY_DOWN: res.y += -diff; break;
case GF_KEY_HOME: res = ps->offset; break;
default:
return 0;
}
/*clip*/
if (ps->minPosition.x <= ps->maxPosition.x) {
if (res.x < ps->minPosition.x) res.x = ps->minPosition.x;
if (res.x > ps->maxPosition.x) res.x = ps->maxPosition.x;
}
if (ps->minPosition.y <= ps->maxPosition.y) {
if (res.y < ps->minPosition.y) res.y = ps->minPosition.y;
if (res.y > ps->maxPosition.y) res.y = ps->maxPosition.y;
}
ps->translation_changed = res;
gf_node_event_out_str(sh->sensor, "translation_changed");
ps->trackPoint_changed.x = res.x + stack->start_drag.x;
ps->trackPoint_changed.y = res.y + stack->start_drag.y;
gf_node_event_out_str(sh->sensor, "trackPoint_changed");
stack->start_drag = res;
return 1;
}
}
return 0;
}
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);
}
static void TraverseBillboard(GF_Node *n, void *rs, Bool is_destroy)
{
GF_Matrix gf_mx_bckup;
TransformStack *st = (TransformStack *)gf_node_get_private(n);
M_Billboard *bb = (M_Billboard *)n;
GF_TraverseState *tr_state = (GF_TraverseState *)rs;
if (is_destroy) {
DestroyTransform(n);
return;
}
if (! tr_state->camera) return;
/*can't cache the matrix here*/
gf_mx_init(st->mx);
if (tr_state->camera->is_3D) {
SFVec3f z, axis;
Fixed axis_len;
SFVec3f user_pos = tr_state->camera->position;
gf_mx_apply_vec(&tr_state->model_matrix, &user_pos);
gf_vec_norm(&user_pos);
axis = bb->axisOfRotation;
axis_len = gf_vec_len(axis);
if (axis_len<FIX_EPSILON) {
SFVec3f x, y, t;
/*get user's right in local coord*/
gf_vec_diff(t, tr_state->camera->position, tr_state->camera->target);
gf_vec_norm(&t);
x = gf_vec_cross(tr_state->camera->up, t);
gf_vec_norm(&x);
gf_mx_rotate_vector(&tr_state->model_matrix, &x);
gf_vec_norm(&x);
/*get user's up in local coord*/
y = tr_state->camera->up;
gf_mx_rotate_vector(&tr_state->model_matrix, &y);
gf_vec_norm(&y);
z = gf_vec_cross(x, y);
gf_vec_norm(&z);
gf_mx_rotation_matrix_from_vectors(&st->mx, x, y, z);
gf_mx_inverse(&st->mx);
} else {
SFVec3f tmp;
Fixed d, cosw, sinw, angle;
gf_vec_norm(&axis);
/*map eye & z into plane with normal axis through 0.0*/
d = -gf_vec_dot(axis, user_pos);
tmp = gf_vec_scale(axis, d);
gf_vec_add(user_pos, user_pos, tmp);
gf_vec_norm(&user_pos);
z.x = z.y = 0;
z.z = FIX_ONE;
d = -gf_vec_dot(axis, z);
tmp = gf_vec_scale(axis, d);
gf_vec_add(z, z, tmp);
gf_vec_norm(&z);
cosw = gf_vec_dot(user_pos, z);
tmp = gf_vec_cross(user_pos, z);
sinw = gf_vec_len(tmp);
angle = gf_acos(cosw);
gf_vec_norm(&tmp);
if ((sinw>0) && (gf_vec_dot(axis, tmp) > 0)) gf_vec_rev(axis);
gf_mx_add_rotation(&st->mx, angle, axis.x, axis.y, axis.z);
}
}
gf_mx_copy(gf_mx_bckup, tr_state->model_matrix);
gf_mx_add_matrix(&tr_state->model_matrix, &st->mx);
/*note we don't clear dirty flag, this is done in traversing*/
group_3d_traverse(n, (GroupingNode *) st, tr_state);
gf_mx_copy(tr_state->model_matrix, gf_mx_bckup);
if (tr_state->traversing_mode==TRAVERSE_GET_BOUNDS) gf_mx_apply_bbox(&st->mx, &tr_state->bbox);
}
static void TraverseSound(GF_Node *node, void *rs, Bool is_destroy)
{
GF_TraverseState *tr_state = (GF_TraverseState*) rs;
M_Sound *snd = (M_Sound *)node;
SoundStack *st = (SoundStack *)gf_node_get_private(node);
if (is_destroy) {
gf_free(st);
return;
}
if (!snd->source) return;
tr_state->sound_holder = &st->snd_ifce;
/*forward in case we're switched off*/
if (tr_state->switched_off) {
gf_node_traverse((GF_Node *) snd->source, tr_state);
}
else if (tr_state->traversing_mode==TRAVERSE_GET_BOUNDS) {
/*we can't cull sound since*/
tr_state->disable_cull = 1;
} else if (tr_state->traversing_mode==TRAVERSE_SORT) {
GF_Matrix mx;
SFVec3f usr, snd_dir, pos;
Fixed mag, ang;
/*this implies no DEF/USE for real location...*/
gf_mx_copy(st->mx, tr_state->model_matrix);
gf_mx_copy(mx, tr_state->model_matrix);
gf_mx_inverse(&mx);
snd_dir = snd->direction;
gf_vec_norm(&snd_dir);
/*get user location*/
usr = tr_state->camera->position;
gf_mx_apply_vec(&mx, &usr);
/*recenter to ellipse focal*/
gf_vec_diff(usr, usr, snd->location);
mag = gf_vec_len(usr);
if (!mag) mag = FIX_ONE/10;
ang = gf_divfix(gf_vec_dot(snd_dir, usr), mag);
usr.z = gf_mulfix(ang, mag);
usr.x = gf_sqrt(gf_mulfix(mag, mag) - gf_mulfix(usr.z, usr.z));
usr.y = 0;
if (!gf_vec_equal(usr, st->last_pos)) {
st->intensity = snd_compute_gain(snd->minBack, snd->minFront, snd->maxBack, snd->maxFront, usr);
st->intensity = gf_mulfix(st->intensity, snd->intensity);
st->last_pos = usr;
}
st->identity = (st->intensity==FIX_ONE) ? 1 : 0;
if (snd->spatialize) {
Fixed ang, sign;
SFVec3f cross;
pos = snd->location;
gf_mx_apply_vec(&tr_state->model_matrix, &pos);
gf_vec_diff(pos, pos, tr_state->camera->position);
gf_vec_diff(usr, tr_state->camera->target, tr_state->camera->position);
gf_vec_norm(&pos);
gf_vec_norm(&usr);
ang = gf_acos(gf_vec_dot(usr, pos));
/*get orientation*/
cross = gf_vec_cross(usr, pos);
sign = gf_vec_dot(cross, tr_state->camera->up);
if (sign>0) ang *= -1;
ang = (FIX_ONE + gf_sin(ang)) / 2;
st->lgain = (FIX_ONE - gf_mulfix(ang, ang));
st->rgain = FIX_ONE - gf_mulfix(FIX_ONE - ang, FIX_ONE - ang);
/*renorm between 0 and 1*/
st->lgain = gf_mulfix(st->lgain, 4*st->intensity/3);
st->rgain = gf_mulfix(st->rgain, 4*st->intensity/3);
if (st->identity && ((st->lgain!=FIX_ONE) || (st->rgain!=FIX_ONE))) st->identity = 0;
} else {
st->lgain = st->rgain = FIX_ONE;
}
gf_node_traverse((GF_Node *) snd->source, tr_state);
}
tr_state->sound_holder = NULL;
}
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 camera_update_stereo(GF_Camera *cam, GF_Matrix2D *user_transform, Bool center_coords, Fixed horizontal_shift, Fixed nominal_view_distance, Fixed view_distance_offset, u32 camera_layout)
{
Fixed vlen, h, w, ar;
SFVec3f corner, center;
GF_Matrix post_model_view;
if (! (cam->flags & CAM_IS_DIRTY)) return;
ar = gf_divfix(cam->width, cam->height);
gf_mx_init(post_model_view);
if (cam->is_3D) {
/*setup perspective*/
if (camera_layout==GF_3D_CAMERA_OFFAXIS) {
Fixed left, right, top, bottom, shift, wd2, ndfl, viewing_distance;
SFVec3f eye, pos, tar, disp;
viewing_distance = nominal_view_distance;
wd2 = gf_mulfix(cam->z_near, gf_tan(cam->fieldOfView/2));
ndfl = gf_divfix(cam->z_near, viewing_distance);
/*compute h displacement*/
shift = gf_mulfix(horizontal_shift, ndfl);
top = wd2;
bottom = -top;
left = -gf_mulfix(ar, wd2) - shift;
right = gf_mulfix(ar, wd2) - shift;
gf_mx_init(cam->projection);
cam->projection.m[0] = gf_divfix(2*cam->z_near, (right-left));
cam->projection.m[5] = gf_divfix(2*cam->z_near, (top-bottom));
cam->projection.m[8] = gf_divfix(right+left, right-left);
cam->projection.m[9] = gf_divfix(top+bottom, top-bottom);
cam->projection.m[10] = gf_divfix(cam->z_far+cam->z_near, cam->z_near-cam->z_far);
cam->projection.m[11] = -FIX_ONE;
cam->projection.m[14] = 2*gf_muldiv(cam->z_near, cam->z_far, cam->z_near-cam->z_far);
cam->projection.m[15] = 0;
gf_vec_diff(eye, cam->target, cam->position);
gf_vec_norm(&eye);
disp = gf_vec_cross(eye, cam->up);
gf_vec_norm(&disp);
gf_vec_diff(center, cam->world_bbox.center, cam->position);
vlen = gf_vec_len(center);
shift = gf_mulfix(horizontal_shift, gf_divfix(vlen, viewing_distance));
pos = gf_vec_scale(disp, shift);
gf_vec_add(pos, pos, cam->position);
gf_vec_add(tar, pos, eye);
/*setup modelview*/
gf_mx_lookat(&cam->modelview, pos, tar, cam->up);
} else {
gf_mx_perspective(&cam->projection, cam->fieldOfView, ar, cam->z_near, cam->z_far);
/*setup modelview*/
gf_mx_lookat(&cam->modelview, cam->position, cam->target, cam->up);
}
if (!center_coords) {
gf_mx_add_scale(&post_model_view, FIX_ONE, -FIX_ONE, FIX_ONE);
gf_mx_add_translation(&post_model_view, -cam->width / 2, -cam->height / 2, 0);
}
/*compute center and radius - CHECK ME!*/
vlen = cam->z_far - cam->z_near;
h = gf_mulfix(vlen , gf_tan(cam->fieldOfView / 2));
w = gf_mulfix(h, ar);
center.x = 0;
center.y = 0;
center.z = cam->z_near + vlen / 2;
corner.x = w;
corner.y = h;
corner.z = vlen;
gf_vec_diff(corner, corner, center);
cam->radius = gf_vec_len(corner);
gf_vec_diff(cam->center, cam->target, cam->position);
gf_vec_norm(&cam->center);
cam->center = gf_vec_scale(cam->center, cam->z_near + vlen/2);
gf_vec_add(cam->center, cam->center, cam->position);
} else {
GF_BBox b;
Fixed hw, hh;
hw = cam->width / 2;
hh = cam->height / 2;
cam->z_near = INT2FIX(NEAR_PLANE_2D);
cam->z_far = INT2FIX(FAR_PLANE_2D);
/*setup ortho*/
gf_mx_ortho(&cam->projection, -hw, hw, -hh, hh, cam->z_near, cam->z_far);
/*setup modelview*/
gf_mx_init(cam->modelview);
#ifdef FORCE_CAMERA_3D
if (! (cam->flags & CAM_NO_LOOKAT))
gf_mx_lookat(&cam->modelview, cam->position, cam->target, cam->up);
#endif
if (!center_coords) {
gf_mx_add_scale(&post_model_view, FIX_ONE, -FIX_ONE, FIX_ONE);
gf_mx_add_translation(&post_model_view, -hw, -hh, 0);
}
if (user_transform) {
#ifdef FORCE_CAMERA_3D
if (! (cam->flags & CAM_NO_LOOKAT)) {
GF_Matrix mx;
gf_mx_from_mx2d(&mx, user_transform);
mx.m[10] = mx.m[0];
gf_mx_add_matrix(&post_model_view, &mx);
} else
#endif
gf_mx_add_matrix_2d(&post_model_view, user_transform);
}
if (cam->end_zoom != FIX_ONE) gf_mx_add_scale(&post_model_view, cam->end_zoom, cam->end_zoom, cam->end_zoom);
if (cam->flags & CAM_HAS_VIEWPORT) gf_mx_add_matrix(&post_model_view, &cam->viewport);
/*compute center & radius*/
b.max_edge.x = hw;
b.max_edge.y = hh;
b.min_edge.x = -hw;
b.min_edge.y = -hh;
b.min_edge.z = b.max_edge.z = (cam->z_near+cam->z_far) / 2;
gf_bbox_refresh(&b);
cam->center = b.center;
cam->radius = b.radius;
if (camera_layout==GF_3D_CAMERA_OFFAXIS)
camera_layout=GF_3D_CAMERA_LINEAR;
}
if (camera_layout == GF_3D_CAMERA_CIRCULAR) {
GF_Matrix mx;
Fixed viewing_distance = nominal_view_distance;
SFVec3f pos, target;
Fixed angle;
gf_vec_diff(center, cam->world_bbox.center, cam->position);
vlen = gf_vec_len(center);
vlen += gf_mulfix(view_distance_offset, gf_divfix(vlen, nominal_view_distance));
gf_vec_diff(pos, cam->target, cam->position);
gf_vec_norm(&pos);
pos = gf_vec_scale(pos, vlen);
gf_vec_add(target, pos, cam->position);
gf_mx_init(mx);
gf_mx_add_translation(&mx, target.x, target.y, target.z);
angle = gf_atan2(horizontal_shift, viewing_distance);
gf_mx_add_rotation(&mx, angle, cam->up.x, cam->up.y, cam->up.z);
gf_mx_add_translation(&mx, -target.x, -target.y, -target.z);
pos = cam->position;
gf_mx_apply_vec(&mx, &pos);
gf_mx_lookat(&cam->modelview, pos, target, cam->up);
} else if (camera_layout == GF_3D_CAMERA_LINEAR) {
Fixed viewing_distance = nominal_view_distance + view_distance_offset;
GF_Vec eye, disp, pos, tar;
gf_vec_diff(center, cam->world_bbox.center, cam->position);
vlen = gf_vec_len(center);
vlen += gf_mulfix(view_distance_offset, gf_divfix(vlen, nominal_view_distance));
gf_vec_diff(eye, cam->target, cam->position);
gf_vec_norm(&eye);
tar = gf_vec_scale(eye, vlen);
gf_vec_add(tar, tar, cam->position);
disp = gf_vec_cross(eye, cam->up);
gf_vec_norm(&disp);
disp= gf_vec_scale(disp, gf_divfix(gf_mulfix(vlen, horizontal_shift), viewing_distance));
gf_vec_add(pos, cam->position, disp);
gf_mx_lookat(&cam->modelview, pos, tar, cam->up);
}
gf_mx_add_matrix(&cam->modelview, &post_model_view);
/*compute frustum planes*/
gf_mx_copy(cam->unprojection, cam->projection);
gf_mx_add_matrix_4x4(&cam->unprojection, &cam->modelview);
camera_frustum_from_matrix(cam, &cam->unprojection);
/*also compute reverse PM for unprojections*/
gf_mx_inverse_4x4(&cam->unprojection);
cam->flags &= ~CAM_IS_DIRTY;
}
static void TraverseLayer2D(GF_Node *node, void *rs, Bool is_destroy)
{
GF_List *oldb, *oldv;
GF_Node *viewport;
GF_Node *back;
Bool prev_layer;
GF_Matrix2D backup;
SFVec2f prev_vp;
#ifndef GPAC_DISABLE_3D
GF_Matrix mx3d;
GF_List *oldf, *oldn;
GF_List *node_list_backup;
GF_Rect prev_clipper;
Bool had_clip;
#endif
M_Layer2D *l = (M_Layer2D *)node;
Layer2DStack *st = (Layer2DStack *) gf_node_get_private(node);
GF_TraverseState *tr_state = (GF_TraverseState *) rs;
if (is_destroy) {
gf_list_del(st->backs);
gf_list_del(st->views);
group_2d_destroy(node, (GroupingNode2D*)st);
gf_free(st);
return;
}
/*layers can only be used in a 2D context*/
#ifndef GPAC_DISABLE_3D
if (tr_state->visual->type_3d && tr_state->camera->is_3D) return;
#endif
/*layer2D maintains its own stacks*/
oldb = tr_state->backgrounds;
oldv = tr_state->viewpoints;
tr_state->backgrounds = st->backs;
tr_state->viewpoints = st->views;
prev_layer = tr_state->is_layer;
tr_state->is_layer = 1;
#ifndef GPAC_DISABLE_3D
oldf = tr_state->fogs;
oldn = tr_state->navigations;
tr_state->fogs = tr_state->navigations = NULL;
#endif
l2d_CheckBindables(node, tr_state, st->first);
back = (GF_Node*)gf_list_get(st->backs, 0);
viewport = (GF_Node*)gf_list_get(st->views, 0);
if ((tr_state->traversing_mode == TRAVERSE_SORT) || (tr_state->traversing_mode == TRAVERSE_GET_BOUNDS)) {
/*override group bounds*/
visual_get_size_info(tr_state, &st->clip.width, &st->clip.height);
/*setup bounds in local coord system*/
if (l->size.x>=0) st->clip.width = l->size.x;
if (l->size.y>=0) st->clip.height = l->size.y;
st->clip = gf_rect_center(st->clip.width, st->clip.height);
st->bounds = st->clip;
}
prev_vp = tr_state->vp_size;
tr_state->vp_size.x = st->clip.width;
tr_state->vp_size.y = st->clip.height;
switch (tr_state->traversing_mode) {
case TRAVERSE_SORT:
#ifndef GPAC_DISABLE_3D
if (tr_state->visual->type_3d) {
tr_state->layer_clipper = compositor_2d_update_clipper(tr_state, st->clip, &had_clip, &prev_clipper, 1);
visual_3d_matrix_push(tr_state->visual);
gf_mx_copy(mx3d, tr_state->model_matrix);
/*setup clipping*/
visual_3d_set_clipper_2d(tr_state->visual, tr_state->layer_clipper);
/*apply background BEFORE viewport*/
if (back) {
tr_state->traversing_mode = TRAVERSE_BINDABLE;
gf_bbox_from_rect(&tr_state->bbox, &st->clip);
gf_node_traverse(back, tr_state);
}
/*sort all children without transform, and use current transform when flushing contexts*/
gf_mx_init(tr_state->model_matrix);
/*apply viewport*/
if (viewport) {
tr_state->traversing_mode = TRAVERSE_BINDABLE;
tr_state->bounds = st->clip;
gf_node_traverse(viewport, tr_state);
visual_3d_matrix_add(tr_state->visual, tr_state->model_matrix.m);
}
node_list_backup = tr_state->visual->alpha_nodes_to_draw;
tr_state->visual->alpha_nodes_to_draw = gf_list_new();
tr_state->traversing_mode = TRAVERSE_SORT;
/*reset cull flag*/
tr_state->cull_flag = 0;
group_2d_traverse(node, (GroupingNode2D *)st, tr_state);
visual_3d_flush_contexts(tr_state->visual, tr_state);
tr_state->traversing_mode = TRAVERSE_SORT;
assert(!gf_list_count(tr_state->visual->alpha_nodes_to_draw));
gf_list_del(tr_state->visual->alpha_nodes_to_draw);
tr_state->visual->alpha_nodes_to_draw = node_list_backup;
visual_3d_matrix_pop(tr_state->visual);
gf_mx_copy(tr_state->model_matrix, mx3d);
visual_3d_reset_clipper_2d(tr_state->visual);
tr_state->has_layer_clip = had_clip;
if (had_clip) {
tr_state->layer_clipper = prev_clipper;
visual_3d_set_clipper_2d(tr_state->visual, tr_state->layer_clipper);
}
} else
#endif
{
GF_IRect prev_clip;
GF_Rect rc;
gf_mx2d_copy(backup, tr_state->transform);
prev_clip = tr_state->visual->top_clipper;
rc = st->clip;
/*get clipper in world coordinate*/
gf_mx2d_apply_rect(&tr_state->transform, &rc);
if (viewport) {
tr_state->traversing_mode = TRAVERSE_BINDABLE;
tr_state->bounds = st->clip;
gf_node_traverse(viewport, tr_state);
#if VIEWPORT_CLIPS
/*move viewport box in world coordinate*/
gf_mx2d_apply_rect(&backup, &tr_state->bounds);
/*and intersect with layer clipper*/
rect_intersect(&rc, &tr_state->bounds);
#endif
}
tr_state->visual->top_clipper = gf_rect_pixelize(&rc);
gf_irect_intersect(&tr_state->visual->top_clipper, &prev_clip);
tr_state->traversing_mode = TRAVERSE_SORT;
if (tr_state->visual->top_clipper.width && tr_state->visual->top_clipper.height) {
if (back && Bindable_GetIsBound(back) ) {
DrawableContext *ctx;
ctx = b2d_get_context((M_Background2D*) back, st->backs);
gf_mx2d_init(ctx->transform);
ctx->bi->clip = tr_state->visual->top_clipper;
ctx->bi->unclip = rc;
if (tr_state->immediate_draw) {
tr_state->ctx = ctx;
tr_state->traversing_mode = TRAVERSE_DRAW_2D;
gf_node_traverse(back, tr_state);
tr_state->traversing_mode = TRAVERSE_SORT;
tr_state->ctx = NULL;
} else {
DrawableContext *back_ctx = visual_2d_get_drawable_context(tr_state->visual);
gf_node_traverse(back, tr_state);
back_ctx->flags = ctx->flags;
back_ctx->flags &= ~CTX_IS_TRANSPARENT;
back_ctx->flags |= CTX_IS_BACKGROUND;
back_ctx->aspect = ctx->aspect;
back_ctx->drawable = ctx->drawable;
drawable_check_bounds(back_ctx, tr_state->visual);
back_ctx->bi->clip = ctx->bi->clip;
back_ctx->bi->unclip = ctx->bi->unclip;
}
/*keep track of node drawn*/
if (!(ctx->drawable->flags & DRAWABLE_REGISTERED_WITH_VISUAL) ) {
struct _drawable_store *it;
GF_SAFEALLOC(it, struct _drawable_store);
it->drawable = ctx->drawable;
if (tr_state->visual->last_prev_entry) {
tr_state->visual->last_prev_entry->next = it;
tr_state->visual->last_prev_entry = it;
} else {
tr_state->visual->prev_nodes = tr_state->visual->last_prev_entry = it;
}
GF_LOG(GF_LOG_DEBUG, GF_LOG_COMPOSE, ("[Layer2D] Registering new drawn node %s on visual\n", gf_node_get_class_name(it->drawable->node)));
ctx->drawable->flags |= DRAWABLE_REGISTERED_WITH_VISUAL;
}
}
group_2d_traverse(node, (GroupingNode2D *)st, tr_state);
}
tr_state->visual->top_clipper = prev_clip;
gf_mx2d_copy(tr_state->transform, backup);
}
break;
/*check picking - we must fall in our 2D clipper*/
case TRAVERSE_PICK:
if (gf_sc_pick_in_clipper(tr_state, &st->clip)) {
#ifndef GPAC_DISABLE_3D
if (tr_state->visual->type_3d) {
/*apply viewport*/
if (viewport) {
gf_mx_copy(mx3d, tr_state->model_matrix);
tr_state->traversing_mode = TRAVERSE_BINDABLE;
tr_state->bounds = st->clip;
gf_node_traverse(viewport, tr_state);
tr_state->traversing_mode = TRAVERSE_PICK;
group_2d_traverse(node, (GroupingNode2D *)st, tr_state);
gf_mx_copy(tr_state->model_matrix, mx3d);
} else {
group_2d_traverse(node, (GroupingNode2D *)st, tr_state);
}
} else
#endif
{
if (viewport) {
gf_mx2d_copy(backup, tr_state->transform);
tr_state->traversing_mode = TRAVERSE_BINDABLE;
tr_state->bounds = st->clip;
gf_node_traverse(viewport, tr_state);
tr_state->traversing_mode = TRAVERSE_PICK;
group_2d_traverse(node, (GroupingNode2D *)st, tr_state);
gf_mx2d_copy(tr_state->transform, backup);
} else {
group_2d_traverse(node, (GroupingNode2D *)st, tr_state);
}
}
}
break;
case TRAVERSE_GET_BOUNDS:
if (tr_state->for_node) {
group_2d_traverse(node, (GroupingNode2D *)st, tr_state);
} else {
tr_state->bounds = st->clip;
#ifndef GPAC_DISABLE_3D
gf_bbox_from_rect(&tr_state->bbox, &st->clip);
#endif
}
break;
case TRAVERSE_DRAW_2D:
group_2d_traverse(node, (GroupingNode2D *)st, tr_state);
break;
#ifndef GPAC_DISABLE_3D
/*drawing a layer means drawing all sub-elements as a whole (no depth sorting with parents)*/
case TRAVERSE_DRAW_3D:
assert(0);
break;
#endif
}
/*restore traversing state*/
tr_state->vp_size = prev_vp;
tr_state->backgrounds = oldb;
tr_state->viewpoints = oldv;
tr_state->is_layer = prev_layer;
#ifndef GPAC_DISABLE_3D
tr_state->fogs = oldf;
tr_state->navigations = oldn;
#endif
/*in case we missed bindables*/
if (st->first) {
st->first = 0;
gf_sc_invalidate(tr_state->visual->compositor, NULL);
}
}
static void DrawBackground2D_3D(M_Background2D *bck, Background2DStack *st, GF_TraverseState *tr_state)
{
GF_Matrix mx, bck_mx, bck_mx_cam;
Bool use_texture;
use_texture = back_texture_enabled(bck, &st->txh);
visual_3d_set_background_state(tr_state->visual, 1);
gf_mx_copy(bck_mx_cam, tr_state->camera->modelview);
gf_mx_copy(bck_mx, tr_state->model_matrix);
/*little opt: if we clear the main visual clear it entirely */
if (! tr_state->is_layer) {
visual_3d_clear(tr_state->visual, bck->backColor, FIX_ONE);
if (!use_texture) {
visual_3d_set_background_state(tr_state->visual, 0);
return;
}
/*we need a hack here because main vp is always traversed before main background, and in the case of a
2D viewport it modifies the modelview matrix, which we don't want ...*/
gf_mx_init(tr_state->model_matrix);
gf_mx_init(tr_state->camera->modelview);
}
if (!use_texture || (!tr_state->is_layer && st->txh.transparent) ) visual_3d_set_material_2d(tr_state->visual, bck->backColor, FIX_ONE);
if (use_texture) {
visual_3d_set_state(tr_state->visual, V3D_STATE_COLOR, ! tr_state->is_layer);
tr_state->mesh_num_textures = gf_sc_texture_enable(&st->txh, NULL);
if (!tr_state->mesh_num_textures) visual_3d_set_material_2d(tr_state->visual, bck->backColor, FIX_ONE);
}
/*create mesh object if needed*/
if (!st->mesh) {
st->mesh = new_mesh();
mesh_set_vertex(st->mesh, -B2D_PLANE_HSIZE, -B2D_PLANE_HSIZE, 0, 0, 0, FIX_ONE, 0, 0);
mesh_set_vertex(st->mesh, B2D_PLANE_HSIZE, -B2D_PLANE_HSIZE, 0, 0, 0, FIX_ONE, FIX_ONE, 0);
mesh_set_vertex(st->mesh, B2D_PLANE_HSIZE, B2D_PLANE_HSIZE, 0, 0, 0, FIX_ONE, FIX_ONE, FIX_ONE);
mesh_set_vertex(st->mesh, -B2D_PLANE_HSIZE, B2D_PLANE_HSIZE, 0, 0, 0, FIX_ONE, 0, FIX_ONE);
mesh_set_triangle(st->mesh, 0, 1, 2);
mesh_set_triangle(st->mesh, 0, 2, 3);
st->mesh->flags |= MESH_IS_2D;
}
gf_mx_init(mx);
if (tr_state->camera->is_3D) {
Fixed sx, sy;
/*reset matrix*/
gf_mx_init(tr_state->model_matrix);
sx = sy = 2 * gf_mulfix(gf_tan(tr_state->camera->fieldOfView/2), tr_state->camera->z_far);
if (tr_state->camera->width > tr_state->camera->height) {
sx = gf_muldiv(sx, tr_state->camera->width, tr_state->camera->height);
} else {
sy = gf_muldiv(sy, tr_state->camera->height, tr_state->camera->width);
}
gf_mx_add_scale(&mx, sx, sy, FIX_ONE);
#ifdef GPAC_FIXED_POINT
gf_mx_add_translation(&mx, 0, 0, - (tr_state->camera->z_far/100)*99);
#else
gf_mx_add_translation(&mx, 0, 0, -0.995f*tr_state->camera->z_far);
#endif
} else {
gf_mx_add_scale(&mx, tr_state->bbox.max_edge.x - tr_state->bbox.min_edge.x,
tr_state->bbox.max_edge.y - tr_state->bbox.min_edge.y,
FIX_ONE);
/*when in layer2D, DON'T MOVE BACKGROUND TO ZFAR*/
if (!tr_state->is_layer) {
Fixed tr;
#ifdef GPAC_FIXED_POINT
tr = -(tr_state->camera->z_far/100)*99;
#else
tr = -0.999f*tr_state->camera->z_far;
#endif
if (!tr_state->camera->is_3D) tr = -tr;
gf_mx_add_translation(&mx, 0, 0, tr);
}
}
gf_mx_add_matrix(&tr_state->model_matrix, &mx);
visual_3d_mesh_paint(tr_state, st->mesh);
if (tr_state->mesh_num_textures) {
gf_sc_texture_disable(&st->txh);
tr_state->mesh_num_textures = 0;
}
gf_mx_copy(tr_state->model_matrix, bck_mx);
gf_mx_copy(tr_state->camera->modelview, bck_mx_cam);
visual_3d_set_background_state(tr_state->visual, 0);
}
