static void view_orbit_y(GF_Compositor *compositor, GF_Camera *cam, Fixed dy)
{
GF_Matrix mx;
SFVec3f axis;
if (!dy) return;
axis = camera_get_right_dir(cam);
gf_mx_rotation_matrix(&mx, cam->target, axis, dy);
gf_mx_apply_vec(&mx, &cam->position);
/*update up vector*/
cam->up = gf_vec_cross(camera_get_pos_dir(cam), axis);
gf_vec_norm(&cam->up);
camera_changed(compositor, cam);
}
static void NLD_Apply(M_NonLinearDeformer *nld, GF_Mesh *mesh)
{
u32 i;
GF_Matrix mx;
SFVec3f n;
Fixed param, z_min, z_max, v_min, v_max, f_min, f_max, frac, val, a_cos, a_sin;
Bool needs_transform = NLD_GetMatrix(nld, &mx);
param = nld->param;
if (!param) param = 1;
if (mesh->bounds.min_edge.z == mesh->bounds.max_edge.z) return;
z_min = FIX_MAX;
z_max = -FIX_MAX;
if (needs_transform) {
for (i=0; i<mesh->v_count; i++) {
gf_mx_apply_vec(&mx, &mesh->vertices[i].pos);
MESH_GET_NORMAL(n, mesh->vertices[i]);
gf_mx_rotate_vector(&mx, &n);
MESH_SET_NORMAL(mesh->vertices[i], n);
if (mesh->vertices[i].pos.z<z_min) z_min = mesh->vertices[i].pos.z;
if (mesh->vertices[i].pos.z>z_max) z_max = mesh->vertices[i].pos.z;
}
} else {
z_min = mesh->bounds.min_edge.z;
z_max = mesh->bounds.max_edge.z;
}
for (i=0; i<mesh->v_count; i++) {
SFVec3f old = mesh->vertices[i].pos;
frac = gf_divfix(old.z - z_min, z_max - z_min);
NLD_GetKey(nld, frac, &f_min, &v_min, &f_max, &v_max);
if (f_max == f_min) {
val = v_min;
} else {
frac = gf_divfix(frac-f_min, f_max - f_min);
val = gf_mulfix(v_max - v_min, frac) + v_min;
}
val = gf_mulfix(val, param);
switch (nld->type) {
/*taper*/
case 0:
mesh->vertices[i].pos.x = gf_mulfix(mesh->vertices[i].pos.x, val);
mesh->vertices[i].pos.y = gf_mulfix(mesh->vertices[i].pos.y, val);
MESH_GET_NORMAL(old, mesh->vertices[i]);
n=old;
n.x = gf_mulfix(n.x, val);
n.y = gf_mulfix(n.y, val);
gf_vec_norm(&n);
MESH_SET_NORMAL(mesh->vertices[i], n);
break;
/*twist*/
case 1:
a_cos = gf_cos(val);
a_sin = gf_sin(val);
mesh->vertices[i].pos.x = gf_mulfix(a_cos, old.x) - gf_mulfix(a_sin, old.y);
mesh->vertices[i].pos.y = gf_mulfix(a_sin, old.x) + gf_mulfix(a_cos, old.y);
MESH_GET_NORMAL(old, mesh->vertices[i]);
n=old;
n.x = gf_mulfix(a_cos, old.x) - gf_mulfix(a_sin, old.y);
n.y = gf_mulfix(a_sin, old.x) + gf_mulfix(a_cos, old.y);
gf_vec_norm(&n);
MESH_SET_NORMAL(mesh->vertices[i], n);
break;
/*bend*/
case 2:
a_cos = gf_cos(val);
a_sin = gf_sin(val);
mesh->vertices[i].pos.x = gf_mulfix(a_sin, old.z) + gf_mulfix(a_cos, old.x);
mesh->vertices[i].pos.z = gf_mulfix(a_cos, old.z) - gf_mulfix(a_sin, old.x);
MESH_GET_NORMAL(old, mesh->vertices[i]);
n=old;
n.x = gf_mulfix(a_sin, old.z) + gf_mulfix(a_cos, old.x);
n.z = gf_mulfix(a_cos, old.z) - gf_mulfix(a_sin, old.x);
gf_vec_norm(&n);
MESH_SET_NORMAL(mesh->vertices[i], n);
break;
/*pinch, not standard (taper on X dim only)*/
case 3:
mesh->vertices[i].pos.x = gf_mulfix(mesh->vertices[i].pos.x, val);
MESH_GET_NORMAL(old, mesh->vertices[i]);
n=old;
n.x = gf_mulfix(n.x, val);
gf_vec_norm(&n);
MESH_SET_NORMAL(mesh->vertices[i], n);
break;
}
}
if (needs_transform) {
gf_mx_inverse(&mx);
for (i=0; i<mesh->v_count; i++) {
gf_mx_apply_vec(&mx, &mesh->vertices[i].pos);
MESH_GET_NORMAL(n, mesh->vertices[i]);
gf_mx_rotate_vector(&mx, &n);
MESH_SET_NORMAL(mesh->vertices[i], n);
}
}
mesh_update_bounds(mesh);
gf_mesh_build_aabbtree(mesh);
}
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 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;
}
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 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);
}
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;
}
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;
}
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 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 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 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;
}
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 OnSphereSensor(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_SphereSensor *sphere = (M_SphereSensor *)sh->sensor;
SphereSensorStack *st = (SphereSensorStack *) gf_node_get_private(sh->sensor);
if (sphere->isActive && (!sphere->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 (sphere->autoOffset) {
sphere->offset = sphere->rotation_changed;
if (!is_cancel) gf_node_event_out(sh->sensor, 2/*"offset"*/);
}
sphere->isActive = 0;
if (!is_cancel) gf_node_event_out(sh->sensor, 3/*"isActive"*/);
sh->grabbed = 0;
return is_cancel ? 0 : 1;
}
else if (is_mouse) {
if (!sphere->isActive && (ev->type==GF_EVENT_MOUSEDOWN) && (ev->mouse.button==GF_MOUSE_LEFT)) {
st->center.x = st->center.y = st->center.z = 0;
gf_mx_apply_vec(&compositor->hit_local_to_world, &st->center);
st->radius = gf_vec_len(compositor->hit_local_point);
if (!st->radius) st->radius = FIX_ONE;
st->grab_vec = gf_vec_scale(compositor->hit_local_point, gf_invfix(st->radius));
sphere->isActive = 1;
gf_node_event_out(sh->sensor, 3/*"isActive"*/);
sh->grabbed = 1;
return 1;
}
else if (sphere->isActive) {
SFVec3f vec, axis;
SFVec4f q1, q2;
SFRotation r;
Fixed cl;
if (is_over) {
sphere->trackPoint_changed = compositor->hit_local_point;
gf_node_event_out(sh->sensor, 5/*"trackPoint_changed"*/);
} else {
GF_Ray r;
r = compositor->hit_world_ray;
gf_mx_apply_ray(&compositor->hit_world_to_local, &r);
if (!gf_ray_hit_sphere(&r, NULL, st->radius, &compositor->hit_local_point)) {
vec.x = vec.y = vec.z = 0;
/*doesn't work properly...*/
compositor->hit_local_point = gf_closest_point_to_line(r.orig, r.dir, vec);
}
}
vec = gf_vec_scale(compositor->hit_local_point, gf_invfix(st->radius));
axis = gf_vec_cross(st->grab_vec, vec);
cl = gf_vec_len(axis);
if (cl < -FIX_ONE) cl = -FIX_ONE;
else if (cl > FIX_ONE) cl = FIX_ONE;
r.q = gf_asin(cl);
if (gf_vec_dot(st->grab_vec, vec) < 0) r.q += GF_PI / 2;
gf_vec_norm(&axis);
r.x = axis.x;
r.y = axis.y;
r.z = axis.z;
q1 = gf_quat_from_rotation(r);
if (sphere->autoOffset) {
q2 = gf_quat_from_rotation(sphere->offset);
q1 = gf_quat_multiply(&q1, &q2);
}
sphere->rotation_changed = gf_quat_to_rotation(&q1);
gf_node_event_out(sh->sensor, 4/*"rotation_changed"*/);
return 1;
}
} else {
if (!sphere->isActive && is_over && (ev->type==GF_EVENT_KEYDOWN) && (ev->key.key_code==GF_KEY_ENTER)) {
sphere->isActive = 1;
sphere->rotation_changed = sphere->offset;
gf_node_event_out(sh->sensor, 3/*"isActive"*/);
return 1;
}
else if (sphere->isActive && (ev->type==GF_EVENT_KEYDOWN)) {
SFVec4f res, rot;
Fixed diff = GF_PI/64;
res = sphere->rotation_changed;
switch (ev->key.key_code) {
case GF_KEY_LEFT:
diff = -diff;
case GF_KEY_RIGHT:
rot.x = 0;
rot.y = FIX_ONE;
rot.z = 0;
rot.q = diff;
res = gf_quat_from_rotation(res);
rot = gf_quat_from_rotation(rot);
rot = gf_quat_multiply(&rot, &res);
res = gf_quat_to_rotation(&rot);
break;
case GF_KEY_DOWN:
diff = -diff;
case GF_KEY_UP:
if (ev->key.flags & GF_KEY_MOD_SHIFT) {
rot.x = 0;
rot.z = FIX_ONE;
} else {
rot.x = FIX_ONE;
rot.z = 0;
}
rot.y = 0;
rot.q = diff;
res = gf_quat_from_rotation(res);
rot = gf_quat_from_rotation(rot);
rot = gf_quat_multiply(&rot, &res);
res = gf_quat_to_rotation(&rot);
break;
case GF_KEY_HOME:
res = sphere->offset;
break;
default:
return 0;
}
sphere->rotation_changed = res;
gf_node_event_out(sh->sensor, 4/*"rotation_changed"*/);
return 1;
}
}
return 0;
}
static void OnSphereSensor(SensorHandler *sh, Bool is_over, GF_Event *ev, RayHitInfo *hit_info)
{
M_SphereSensor *sphere = (M_SphereSensor *)sh->owner;
SphereSensorStack *st = (SphereSensorStack *) gf_node_get_private(sh->owner);
if (sphere->isActive && (!sphere->enabled || ((ev->type==GF_EVENT_MOUSEUP) && (ev->mouse.button==GF_MOUSE_LEFT)) ) ) {
if (sphere->autoOffset) {
sphere->offset = sphere->rotation_changed;
gf_node_event_out_str(sh->owner, "offset");
}
sphere->isActive = 0;
gf_node_event_out_str(sh->owner, "isActive");
R3D_SetGrabbed(st->compositor, 0);
}
else if (!sphere->isActive && (ev->type==GF_EVENT_MOUSEDOWN) && (ev->mouse.button==GF_MOUSE_LEFT)) {
st->center.x = st->center.y = st->center.z = 0;
gf_mx_apply_vec(&hit_info->local_to_world, &st->center);
st->radius = gf_vec_len(hit_info->local_point);
if (!st->radius) st->radius = FIX_ONE;
st->grab_vec = gf_vec_scale(hit_info->local_point, gf_invfix(st->radius));
sphere->isActive = 1;
gf_node_event_out_str(sh->owner, "isActive");
R3D_SetGrabbed(st->compositor, 1);
}
else if (sphere->isActive) {
SFVec3f vec, axis;
SFVec4f q1, q2;
SFRotation r;
Fixed cl;
if (is_over) {
sphere->trackPoint_changed = hit_info->local_point;
gf_node_event_out_str(sh->owner, "trackPoint_changed");
} else {
GF_Ray r;
r = hit_info->world_ray;
gf_mx_apply_ray(&hit_info->world_to_local, &r);
if (!gf_ray_hit_sphere(&r, NULL, st->radius, &hit_info->local_point)) {
vec.x = vec.y = vec.z = 0;
/*doesn't work properly...*/
hit_info->local_point = gf_closest_point_to_line(r.orig, r.dir, vec);
}
}
vec = gf_vec_scale(hit_info->local_point, gf_invfix(st->radius));
axis = gf_vec_cross(st->grab_vec, vec);
cl = gf_vec_len(axis);
if (cl < -FIX_ONE) cl = -FIX_ONE;
else if (cl > FIX_ONE) cl = FIX_ONE;
r.q = gf_asin(cl);
if (gf_vec_dot(st->grab_vec, vec) < 0) r.q += GF_PI / 2;
gf_vec_norm(&axis);
r.x = axis.x; r.y = axis.y; r.z = axis.z;
q1 = gf_quat_from_rotation(r);
if (sphere->autoOffset) {
q2 = gf_quat_from_rotation(sphere->offset);
q1 = gf_quat_multiply(&q1, &q2);
}
sphere->rotation_changed = gf_quat_to_rotation(&q1);
gf_node_event_out_str(sh->owner, "rotation_changed");
}
}
static void OnCylinderSensor(SensorHandler *sh, Bool is_over, GF_Event *ev, RayHitInfo *hit_info)
{
M_CylinderSensor *cs = (M_CylinderSensor *)sh->owner;
CylinderSensorStack *st = (CylinderSensorStack *) gf_node_get_private(sh->owner);
if (cs->isActive && (!cs->enabled || ((ev->type==GF_EVENT_MOUSEUP) && (ev->mouse.button==GF_MOUSE_LEFT))) ) {
if (cs->autoOffset) {
cs->offset = cs->rotation_changed.q;
gf_node_event_out_str(sh->owner, "offset");
}
cs->isActive = 0;
gf_node_event_out_str(sh->owner, "isActive");
R3D_SetGrabbed(st->compositor, 0);
}
else 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, hit_info->world_to_local);
/*get initial angle & check disk mode*/
r = hit_info->world_ray;
gf_vec_add(r.dir, r.orig, r.dir);
gf_mx_apply_vec(&hit_info->world_to_local, &r.orig);
gf_mx_apply_vec(&hit_info->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 = hit_info->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_str(sh->owner, "isActive");
R3D_SetGrabbed(st->compositor, 1);
}
else if (cs->isActive) {
GF_Ray r;
Fixed radius, rot;
SFVec3f dir1, dir2, cx;
if (is_over) {
cs->trackPoint_changed = hit_info->local_point;
gf_node_event_out_str(sh->owner, "trackPoint_changed");
} else {
GF_Plane project_to;
r = hit_info->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.x) > ABS(r.dir.x)) project_to = st->xplane;
else project_to = st->zplane;
} else project_to = st->yplane;
if (!gf_plane_intersect_line(&project_to, &r.orig, &r.dir, &hit_info->local_point)) return;
}
dir1.x = hit_info->local_point.x; dir1.y = 0; dir1.z = hit_info->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;
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_str(sh->owner, "rotation_changed");
}
}
