SFVec3f camera_get_right_dir(GF_Camera *cam)
{
SFVec3f v, pos;
pos = camera_get_pos_dir(cam);
v = gf_vec_cross(cam->up, pos );
gf_vec_norm(&v);
return v;
}
/*based on Copyright (C) 1995 Stephen Chenney ([email protected])*/ SFRotation camera_get_orientation(SFVec3f pos, SFVec3f target, SFVec3f up) { SFVec3f dir, tmp, v, axis, new_y; SFVec4f norm, inv_norm, y_quat, ny_quat, rot_y, rot; gf_vec_diff(dir, target, pos); gf_vec_norm(&dir); tmp = gf_vec_scale(dir, gf_vec_dot(up, dir)); gf_vec_diff(v, up, tmp); gf_vec_norm(&v); axis.x = dir.y; axis.y = -dir.x; axis.z = 0; if (gf_vec_dot(axis, axis) < FIX_EPSILON) { if (dir.z> 0) { norm.x = 0; norm.y = FIX_ONE; norm.z = 0; norm.q = 0; } else { norm.x = 0; norm.y = 0; norm.z = 0; norm.q = FIX_ONE; } } else { gf_vec_norm(&axis); norm = gf_quat_from_axis_cos(axis, -dir.z); } /* Find the inverse rotation. */ inv_norm.x = -norm.x; inv_norm.y = -norm.y; inv_norm.z = -norm.z; inv_norm.q = norm.q; /* Rotate the y. */ y_quat.x = y_quat.z = y_quat.q = 0; y_quat.y = FIX_ONE; ny_quat = gf_quat_multiply(&norm, &y_quat); ny_quat = gf_quat_multiply(&ny_quat, &inv_norm); new_y.x = ny_quat.x; new_y.y = ny_quat.y; new_y.z = ny_quat.z; tmp = gf_vec_cross(new_y, v); if (gf_vec_dot(tmp, tmp) < FIX_EPSILON) { /* The old and new may be pointing in the same or opposite. Need ** to generate a vector perpendicular to the old or new y. */ tmp.x = 0; tmp.y = -v.z; tmp.z = v.y; if (gf_vec_dot(tmp, tmp) < FIX_EPSILON) { tmp.x = v.z; tmp.y = 0; tmp.z = -v.x; } } gf_vec_norm(&tmp); rot_y = gf_quat_from_axis_cos(tmp, gf_vec_dot(new_y, v)); /* rot_y holds the rotation about the initial camera direction needed ** to align the up vectors in the final position. */ /* Put the 2 rotations together. */ rot = gf_quat_multiply(&rot_y, &norm); return gf_quat_to_rotation(&rot); }
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 update_pan_up(GF_Compositor *compositor, GF_Camera *cam)
{
SFVec3f axis, dir;
/*update up vector so that right is always horizontal (no y component)*/
dir = camera_get_pos_dir(cam);
axis = camera_get_right_dir(cam);
axis.y = 0;
gf_vec_norm(&axis);
cam->up = gf_vec_cross(dir, axis);
gf_vec_norm(&cam->up);
camera_changed(compositor, cam);
}
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);
}
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 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 TraverseTriangleSet2D(GF_Node *node, void *rs, Bool is_destroy)
{
DrawableContext *ctx;
Drawable *stack = (Drawable *)gf_node_get_private(node);
GF_TraverseState *tr_state = (GF_TraverseState *)rs;
if (is_destroy) {
drawable_node_del(node);
return;
}
triangleset2d_check_changes(node, stack, tr_state);
switch (tr_state->traversing_mode) {
#ifndef GPAC_DISABLE_3D
case TRAVERSE_DRAW_3D:
if (!stack->mesh) {
SFColorRGBA col;
u32 i, count, idx;
GF_Vertex v1, v2, v3;
X_TriangleSet2D *p = (X_TriangleSet2D *)node;
stack->mesh = new_mesh();
stack->mesh->mesh_type = MESH_TRIANGLES;
col.red = col.green = col.blue = 0;
col.alpha = FIX_ONE;
v1.color = MESH_MAKE_COL(col);
v1.normal.x = v1.normal.y = 0;
v1.normal.z = MESH_NORMAL_UNIT;
v1.pos.z = 0;
v3 = v2 = v1;
count = p->vertices.count;
while (count%3) count--;
for (i=0; i<count; i+=3) {
idx = stack->mesh->v_count;
v1.pos.x = p->vertices.vals[i].x;
v1.pos.y = p->vertices.vals[i].y;
v2.pos.x = p->vertices.vals[i+1].x;
v2.pos.y = p->vertices.vals[i+1].y;
v3.pos.x = p->vertices.vals[i+2].x;
v3.pos.y = p->vertices.vals[i+2].y;
mesh_set_vertex_vx(stack->mesh, &v1);
mesh_set_vertex_vx(stack->mesh, &v2);
mesh_set_vertex_vx(stack->mesh, &v3);
gf_vec_diff(v2.pos, v2.pos, v1.pos);
gf_vec_diff(v3.pos, v3.pos, v1.pos);
v1.pos = gf_vec_cross(v2.pos, v3.pos);
if (v1.pos.z<0) {
mesh_set_triangle(stack->mesh, idx, idx+2, idx+1);
} else {
mesh_set_triangle(stack->mesh, idx, idx+1, idx+2);
}
}
stack->mesh->flags |= MESH_IS_2D;
mesh_update_bounds(stack->mesh);
}
visual_3d_draw_2d(stack, tr_state);
return;
#endif
case TRAVERSE_GET_BOUNDS:
gf_path_get_bounds(stack->path, &tr_state->bounds);
return;
case TRAVERSE_PICK:
vrml_drawable_pick(stack, tr_state);
return;
case TRAVERSE_SORT:
#ifndef GPAC_DISABLE_3D
if (tr_state->visual->type_3d) return;
#endif
ctx = drawable_init_context_mpeg4(stack, tr_state);
if (!ctx) return;
drawable_finalize_sort(ctx, tr_state, NULL);
return;
}
}
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 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");
}
}
