void camera_set_vectors(GF_Camera *cam, SFVec3f pos, SFRotation ori, Fixed fov) { Fixed sin_a, cos_a, icos_a, tmp; cam->fieldOfView = fov; cam->last_pos = cam->position; cam->position = pos; /*compute up & target vectors in local system*/ sin_a = gf_sin(ori.q); cos_a = gf_cos(ori.q); icos_a = FIX_ONE - cos_a; tmp = gf_mulfix(icos_a, ori.z); cam->target.x = gf_mulfix(ori.x, tmp) + gf_mulfix(sin_a, ori.y); cam->target.y = gf_mulfix(ori.y, tmp) - gf_mulfix(sin_a, ori.x); cam->target.z = gf_mulfix(ori.z, tmp) + cos_a; gf_vec_norm(&cam->target); cam->target = gf_vec_scale(cam->target, -cam->vp_dist); gf_vec_add(cam->target, cam->target, pos); tmp = gf_mulfix(icos_a, ori.y); cam->up.x = gf_mulfix(ori.x, tmp) - gf_mulfix(sin_a, ori.z); cam->up.y = gf_mulfix(ori.y, tmp) + cos_a; cam->up.z = gf_mulfix(ori.z, tmp) + gf_mulfix(sin_a, ori.x); gf_vec_norm(&cam->up); cam->flags |= CAM_IS_DIRTY; }
static void camera_frustum_from_matrix(GF_Camera *cam, GF_Matrix *mx) { u32 i; cam->planes[FRUS_LEFT_PLANE].normal.x = mx->m[3] + mx->m[0]; cam->planes[FRUS_LEFT_PLANE].normal.y = mx->m[7] + mx->m[4]; cam->planes[FRUS_LEFT_PLANE].normal.z = mx->m[11] + mx->m[8]; cam->planes[FRUS_LEFT_PLANE].d = mx->m[15] + mx->m[12]; cam->planes[FRUS_RIGHT_PLANE].normal.x = mx->m[3] - mx->m[0]; cam->planes[FRUS_RIGHT_PLANE].normal.y = mx->m[7] - mx->m[4]; cam->planes[FRUS_RIGHT_PLANE].normal.z = mx->m[11] - mx->m[8]; cam->planes[FRUS_RIGHT_PLANE].d = mx->m[15] - mx->m[12]; cam->planes[FRUS_BOTTOM_PLANE].normal.x = mx->m[3] + mx->m[1]; cam->planes[FRUS_BOTTOM_PLANE].normal.y = mx->m[7] + mx->m[5]; cam->planes[FRUS_BOTTOM_PLANE].normal.z = mx->m[11] + mx->m[9]; cam->planes[FRUS_BOTTOM_PLANE].d = mx->m[15] + mx->m[13]; cam->planes[FRUS_TOP_PLANE].normal.x = mx->m[3] - mx->m[1]; cam->planes[FRUS_TOP_PLANE].normal.y = mx->m[7] - mx->m[5]; cam->planes[FRUS_TOP_PLANE].normal.z = mx->m[11] - mx->m[9]; cam->planes[FRUS_TOP_PLANE].d = mx->m[15] - mx->m[13]; cam->planes[FRUS_FAR_PLANE].normal.x = mx->m[3] - mx->m[2]; cam->planes[FRUS_FAR_PLANE].normal.y = mx->m[7] - mx->m[6]; cam->planes[FRUS_FAR_PLANE].normal.z = mx->m[11] - mx->m[10]; cam->planes[FRUS_FAR_PLANE].d = mx->m[15] - mx->m[14]; cam->planes[FRUS_NEAR_PLANE].normal.x = mx->m[3] + mx->m[2]; cam->planes[FRUS_NEAR_PLANE].normal.y = mx->m[7] + mx->m[6]; cam->planes[FRUS_NEAR_PLANE].normal.z = mx->m[11] + mx->m[10]; cam->planes[FRUS_NEAR_PLANE].d = mx->m[15] + mx->m[14]; for (i=0; i<6; ++i) { #ifdef GPAC_FIXED_POINT /*after some testing, it's just safer to move back to float here, the smallest drift will result in completely wrong culling...*/ Float vx, vy, vz, nor; vx = FIX2FLT(cam->planes[i].normal.x); vy = FIX2FLT(cam->planes[i].normal.y); vz = FIX2FLT(cam->planes[i].normal.z); nor = (Float) sqrt(vx*vx + vy*vy + vz*vz); vx /= nor; vy /= nor; vz /= nor; cam->planes[i].d = FLT2FIX (FIX2FLT(cam->planes[i].d) / nor); cam->planes[i].normal.x = FLT2FIX(vx); cam->planes[i].normal.y = FLT2FIX(vy); cam->planes[i].normal.z = FLT2FIX(vz); #else Float len = (Float)(1.0f / gf_vec_len(cam->planes[i].normal)); cam->planes[i].normal = gf_vec_scale(cam->planes[i].normal, len); cam->planes[i].d *= len; #endif /*compute p-vertex idx*/ cam->p_idx[i] = gf_plane_get_p_vertex_idx(&cam->planes[i]); } }
static void view_translate_y(GF_Compositor *compositor, GF_Camera *cam, Fixed dy) { SFVec3f v; if (!dy) return; if (cam->jumping) dy *= JUMP_SCALE_FACTOR; v = gf_vec_scale(cam->up, dy); gf_vec_add(cam->target, cam->target, v); gf_vec_add(cam->position, cam->position, v); camera_changed(compositor, cam); }
static void view_translate_x(GF_Compositor *compositor, GF_Camera *cam, Fixed dx) { SFVec3f v; if (!dx) return; if (cam->jumping) dx *= JUMP_SCALE_FACTOR; v = gf_vec_scale(camera_get_right_dir(cam), dx); gf_vec_add(cam->target, cam->target, v); gf_vec_add(cam->position, cam->position, v); camera_changed(compositor, cam); }
static void view_translate_z(GF_Compositor *compositor, GF_Camera *cam, Fixed dz) { SFVec3f v; if (!dz) return; if (cam->jumping) dz *= JUMP_SCALE_FACTOR; dz = gf_mulfix(dz, cam->speed); v = gf_vec_scale(camera_get_target_dir(cam), dz); gf_vec_add(cam->target, cam->target, v); gf_vec_add(cam->position, cam->position, v); camera_changed(compositor, cam); }
/*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); }
void RenderVisibilitySensor(GF_Node *node, void *rs, Bool is_destroy) { RenderEffect3D *eff = (RenderEffect3D *)rs; M_VisibilitySensor *vs = (M_VisibilitySensor *)node; if (is_destroy || !vs->enabled) return; if (eff->traversing_mode==TRAVERSE_GET_BOUNDS) { /*work with twice bigger bbox to get sure we're notify when culled out*/ gf_vec_add(eff->bbox.max_edge, vs->center, vs->size); gf_vec_diff(eff->bbox.min_edge, vs->center, vs->size); gf_bbox_refresh(&eff->bbox); } else if (eff->traversing_mode==TRAVERSE_SORT) { Bool visible; u32 cull_flag; GF_BBox bbox; SFVec3f s; s = gf_vec_scale(vs->size, FIX_ONE/2); /*cull with normal bbox*/ gf_vec_add(bbox.max_edge, vs->center, s); gf_vec_diff(bbox.min_edge, vs->center, s); gf_bbox_refresh(&bbox); cull_flag = eff->cull_flag; eff->cull_flag = CULL_INTERSECTS; visible = node_cull(eff, &bbox, 0); eff->cull_flag = cull_flag; if (visible && !vs->isActive) { vs->isActive = 1; gf_node_event_out_str(node, "isActive"); vs->enterTime = gf_node_get_scene_time(node); gf_node_event_out_str(node, "enterTime"); } else if (!visible && vs->isActive) { vs->isActive = 0; gf_node_event_out_str(node, "isActive"); vs->exitTime = gf_node_get_scene_time(node); gf_node_event_out_str(node, "exitTime"); } } }
void TraverseVisibilitySensor(GF_Node *node, void *rs, Bool is_destroy) { GF_TraverseState *tr_state = (GF_TraverseState *)rs; M_VisibilitySensor *vs = (M_VisibilitySensor *)node; if (is_destroy || !vs->enabled) 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, vs->center, vs->size); gf_vec_diff(tr_state->bbox.min_edge, vs->center, vs->size); gf_bbox_refresh(&tr_state->bbox); } else if (tr_state->traversing_mode==TRAVERSE_SORT) { Bool visible; u32 cull_flag; GF_BBox bbox; SFVec3f s; s = gf_vec_scale(vs->size, FIX_ONE/2); /*cull with normal bbox*/ gf_vec_add(bbox.max_edge, vs->center, s); gf_vec_diff(bbox.min_edge, vs->center, s); gf_bbox_refresh(&bbox); cull_flag = tr_state->cull_flag; tr_state->cull_flag = CULL_INTERSECTS; visible = visual_3d_node_cull(tr_state, &bbox, 0); tr_state->cull_flag = cull_flag; if (visible && !vs->isActive) { vs->isActive = 1; gf_node_event_out(node, 5/*"isActive"*/); vs->enterTime = gf_node_get_scene_time(node); gf_node_event_out(node, 3/*"enterTime"*/); } else if (!visible && vs->isActive) { vs->isActive = 0; gf_node_event_out(node, 5/*"isActive"*/); vs->exitTime = gf_node_get_scene_time(node); gf_node_event_out(node, 4/*"exitTime"*/); } } }
Bool compositor_get_2d_plane_intersection(GF_Ray *ray, SFVec3f *res) { GF_Plane p; Fixed t, t2; if (!ray->dir.x && !ray->dir.y) { res->x = ray->orig.x; res->y = ray->orig.y; res->z = 0; return 1; } p.normal.x = p.normal.y = 0; p.normal.z = FIX_ONE; p.d = 0; t2 = gf_vec_dot(p.normal, ray->dir); if (t2 == 0) return 0; t = - gf_divfix(gf_vec_dot(p.normal, ray->orig) + p.d, t2); if (t<0) return 0; *res = gf_vec_scale(ray->dir, t); gf_vec_add(*res, ray->orig, *res); return 1; }
Bool gf_sc_fit_world_to_screen(GF_Compositor *compositor) { GF_TraverseState tr_state; SFVec3f pos, diff; Fixed dist, d; GF_Camera *cam; GF_Node *top; #ifndef GPAC_DISABLE_VRML // if (gf_list_count(compositor->visual->back_stack)) return; if (gf_list_count(compositor->visual->view_stack)) return 0; #endif gf_mx_p(compositor->mx); top = gf_sg_get_root_node(compositor->scene); if (!top) { gf_mx_v(compositor->mx); return 0; } memset(&tr_state, 0, sizeof(GF_TraverseState)); gf_mx_init(tr_state.model_matrix); tr_state.traversing_mode = TRAVERSE_GET_BOUNDS; tr_state.visual = compositor->visual; gf_node_traverse(top, &tr_state); if (gf_node_dirty_get(top)) { tr_state.bbox.is_set = 0; } if (!tr_state.bbox.is_set) { gf_mx_v(compositor->mx); /*empty world ...*/ if (tr_state.bbox.radius==-1) return 1; /*2D world with 3D camera forced*/ if (tr_state.bounds.width&&tr_state.bounds.height) return 1; return 0; } cam = &compositor->visual->camera; cam->world_bbox = tr_state.bbox; /*fit is based on bounding sphere*/ dist = gf_divfix(tr_state.bbox.radius, gf_sin(cam->fieldOfView/2) ); gf_vec_diff(diff, cam->center, tr_state.bbox.center); /*do not update if camera is outside the scene bounding sphere and dist is too close*/ if (gf_vec_len(diff) > tr_state.bbox.radius + cam->radius) { gf_vec_diff(diff, cam->vp_position, tr_state.bbox.center); d = gf_vec_len(diff); if (d<dist) { gf_mx_v(compositor->mx); return 1; } } diff = gf_vec_scale(camera_get_pos_dir(cam), dist); gf_vec_add(pos, tr_state.bbox.center, diff); diff = cam->position; camera_set_vectors(cam, pos, cam->vp_orientation, cam->fieldOfView); cam->position = diff; camera_move_to(cam, pos, cam->target, cam->up); cam->examine_center = tr_state.bbox.center; cam->flags |= CF_STORE_VP; if (cam->z_far < dist) cam->z_far = 10*dist; camera_changed(compositor, cam); gf_mx_v(compositor->mx); return 1; }
Bool camera_animate(GF_Camera *cam) { u32 now; Fixed frac; if (!cam->anim_len) return GF_FALSE; if (cam->jumping) { if (!cam->anim_start) { cam->anim_start = gf_sys_clock(); cam->dheight = 0; return GF_TRUE; } cam->position.y -= cam->dheight; cam->target.y -= cam->dheight; now = gf_sys_clock() - cam->anim_start; if (now > cam->anim_len) { cam->anim_len = 0; cam->jumping = GF_FALSE; cam->flags |= CAM_IS_DIRTY; return GF_TRUE; } frac = FLT2FIX ( ((Float) now) / cam->anim_len); if (frac>FIX_ONE / 2) frac = FIX_ONE - frac; cam->dheight = gf_mulfix(cam->avatar_size.y, frac); cam->position.y += cam->dheight; cam->target.y += cam->dheight; cam->flags |= CAM_IS_DIRTY; return GF_TRUE; } if (!cam->anim_start) { cam->anim_start = gf_sys_clock(); now = 0; frac = 0; } else { now = gf_sys_clock() - cam->anim_start; if (now > cam->anim_len) { cam->anim_len = 0; #ifndef FORCE_CAMERA_3D if (cam->is_3D) #endif { camera_set_vectors(cam, cam->end_pos, cam->end_ori, cam->end_fov); cam->end_zoom = FIX_ONE; } #ifndef FORCE_CAMERA_3D else { cam->flags |= CAM_IS_DIRTY; } #endif if (cam->flags & CF_STORE_VP) { cam->flags &= ~CF_STORE_VP; cam->vp_position = cam->position; cam->vp_fov = cam->fieldOfView; cam->vp_orientation = camera_get_orientation(cam->position, cam->target, cam->up); } return GF_TRUE; } else { frac = FLT2FIX( ((Float) now) / cam->anim_len); } } #ifndef FORCE_CAMERA_3D if (cam->is_3D) #endif { SFVec3f pos, dif; SFRotation rot; Fixed fov; rot = gf_sg_sfrotation_interpolate(cam->start_ori, cam->end_ori, frac); gf_vec_diff(dif, cam->end_pos, cam->start_pos); dif = gf_vec_scale(dif, frac); gf_vec_add(pos, cam->start_pos, dif); fov = gf_mulfix(cam->end_fov - cam->start_fov, frac) + cam->start_fov; cam->end_zoom = frac + gf_mulfix((FIX_ONE-frac), cam->start_zoom); camera_set_vectors(cam, pos, rot, fov); } return GF_TRUE; }
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 BuildTriangleStripSet(GF_Mesh *mesh, GF_Node *_coords, GF_Node *_color, GF_Node *_txcoords, GF_Node *_normal, MFInt32 *stripList, MFInt32 *indices, Bool normalPerVertex, Bool ccw, Bool solid) { u32 strip, i, cur_idx, generate_tx; GF_Vertex vx; GenMFField *cols; MFVec3f *norms; MFVec2f *txcoords; Bool rgba_col; SFColorRGBA rgba; X_Coordinate *c = (X_Coordinate *) _coords; mesh_reset(mesh); cols = NULL; rgba_col = 0; if (_color) { if (gf_node_get_tag(_color)==TAG_X3D_ColorRGBA) { rgba_col = 1; cols = (GenMFField *) & ((X_ColorRGBA *) _color)->color; } else { cols = (GenMFField *) & ((M_Color *) _color)->color; } } norms = NULL; if (_normal) norms = & ((M_Normal *)_normal)->vector; txcoords = NULL; generate_tx = 0; /*FIXME - this can't work with multitexturing*/ if (_txcoords) { switch (gf_node_get_tag(_txcoords)) { case TAG_X3D_TextureCoordinate: case TAG_MPEG4_TextureCoordinate: txcoords = & ((M_TextureCoordinate *)_txcoords)->point; break; case TAG_X3D_TextureCoordinateGenerator: generate_tx = 1; break; } } memset(&vx, 0, sizeof(GF_Vertex)); cur_idx = 0; for (strip= 0; strip<stripList->count; strip++) { u32 start_idx = mesh->v_count; if (stripList->vals[strip] < 3) continue; for (i=0; i<(u32) stripList->vals[strip]; i++) { u32 idx; if (indices) { if (indices->count<=cur_idx) return; if (indices->vals[cur_idx] == -1) { GF_LOG(GF_LOG_ERROR, GF_LOG_COMPOSE, ("[X3D] bad formatted X3D triangle strip\n")); return; } idx = indices->vals[cur_idx]; } else { idx = cur_idx; } vx.pos = c->point.vals[idx]; if (cols && (cols->count>idx)) { if (rgba_col) { rgba = ((MFColorRGBA *)cols)->vals[idx]; } else { rgba = gf_sg_sfcolor_to_rgba( ((MFColor *)cols)->vals[idx]); } vx.color = MESH_MAKE_COL(rgba); } /*according to X3D spec, if normal field is set, it is ALWAYS as normal per vertex*/ if (norms && (norms->count>idx)) { SFVec3f n = norms->vals[idx]; gf_vec_norm(&n); MESH_SET_NORMAL(vx, n); } if (txcoords) { if (txcoords->count>idx) vx.texcoords = txcoords->vals[idx]; } /*X3D says nothing about default texture mapping here...*/ else if (!generate_tx) { switch (idx%3) { case 2: vx.texcoords.x = FIX_ONE; vx.texcoords.y = 0; break; case 1: vx.texcoords.x = FIX_ONE/2; vx.texcoords.y = FIX_ONE; break; case 0: vx.texcoords.x = 0; vx.texcoords.y = 0; break; } } if (i>2) { /*duplicate last 2 vertices (we really need independent vertices to handle normals per face)*/ mesh_set_vertex_vx(mesh, &mesh->vertices[mesh->v_count-2]); mesh_set_vertex_vx(mesh, &mesh->vertices[mesh->v_count-2]); } mesh_set_vertex_vx(mesh, &vx); cur_idx ++; if (indices) { if (cur_idx>=indices->count) break; } else if (cur_idx==c->point.count) break; } for (i=start_idx; i<mesh->v_count; i+=3) { mesh_set_triangle(mesh, i, i+1, i+2); } /*get rid of -1*/ if (indices && (cur_idx<indices->count) && (indices->vals[cur_idx]==-1)) cur_idx++; } if (generate_tx) mesh_generate_tex_coords(mesh, _txcoords); if (cols) mesh->flags |= MESH_HAS_COLOR; if (rgba_col) mesh->flags |= MESH_HAS_ALPHA; if (_normal) { if (!ccw) mesh->flags |= MESH_IS_CW; } /*reorder everything to CCW*/ else { u32 cur_face = 0; mesh_recompute_normals(mesh); for (i=0; i<mesh->i_count; i+= 3) { if ((ccw && (cur_face%2)) || (!ccw && !(cur_face%2))) { SFVec3f v; u32 idx; MESH_GET_NORMAL(v, mesh->vertices[mesh->indices[i]]); v = gf_vec_scale(v,-1); MESH_SET_NORMAL(mesh->vertices[mesh->indices[i]], v); mesh->vertices[mesh->indices[i+1]].normal = mesh->vertices[mesh->indices[i]].normal; mesh->vertices[mesh->indices[i+2]].normal = mesh->vertices[mesh->indices[i]].normal; idx = mesh->indices[i+2]; mesh->indices[i+2] = mesh->indices[i+1]; mesh->indices[i+1] = idx; } cur_face++; } if (normalPerVertex) { cur_face = 0; for (strip=0; strip<stripList->count; strip++) { SFVec3f n_0, n_1, n_2, n_avg; u32 nb_face; if (stripList->vals[strip] < 3) continue; if (stripList->vals[strip] <= 3) { cur_face ++; continue; } /*first face normal*/ MESH_GET_NORMAL(n_0, mesh->vertices[mesh->indices[3*cur_face]]); /*second face normal*/ MESH_GET_NORMAL(n_1, mesh->vertices[mesh->indices[3*(cur_face+1)]]); gf_vec_add(n_avg, n_0, n_1); gf_vec_norm(&n_avg); /*assign to second point of first face and first of second face*/ MESH_SET_NORMAL(mesh->vertices[mesh->indices[3*cur_face+1]], n_avg); MESH_SET_NORMAL(mesh->vertices[mesh->indices[3*(cur_face+1)]], n_avg); nb_face = stripList->vals[strip] - 2; cur_face++; for (i=1; i<nb_face-1; i++) { /*get normal (use second pt of current face since first has been updated)*/ MESH_GET_NORMAL(n_2, mesh->vertices[mesh->indices[3*cur_face + 1]]); gf_vec_add(n_avg, n_0, n_1); gf_vec_add(n_avg, n_avg, n_2); gf_vec_norm(&n_avg); /*last of prev face*/ MESH_SET_NORMAL(mesh->vertices[mesh->indices[3*cur_face - 1]], n_avg); /*second of current face*/ mesh->vertices[mesh->indices[3*cur_face + 1]].normal = mesh->vertices[mesh->indices[3*cur_face - 1]].normal; /*first of next face*/ mesh->vertices[mesh->indices[3*cur_face + 3]].normal = mesh->vertices[mesh->indices[3*cur_face - 1]].normal; n_0 = n_1; n_1 = n_2; cur_face++; } } } } if (solid) mesh->flags |= MESH_IS_SOLID; mesh_update_bounds(mesh); gf_mesh_build_aabbtree(mesh); }
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 back_build_dome(GF_Mesh *mesh, MFFloat *angles, MFColor *color, Bool ground_dome) { u32 i, j, last_idx, ang_idx, new_idx; Bool pad; u32 step_div_h; GF_Vertex vx; SFColorRGBA start_col, end_col, fcol; Fixed start_angle, next_angle, angle, r, frac, first_angle; start_angle = 0; mesh_reset(mesh); start_col.red = start_col.green = start_col.blue = 0; end_col = start_col; if (color->count) { COL_TO_RGBA(start_col, color->vals[0]); end_col = start_col; if (color->count>1) COL_TO_RGBA(end_col, color->vals[1]); } start_col.alpha = end_col.alpha = FIX_ONE; vx.texcoords.x = vx.texcoords.y = 0; vx.color = MESH_MAKE_COL(start_col); vx.pos.x = vx.pos.z = 0; vx.pos.y = FIX_ONE; vx.normal.x = vx.normal.z = 0; vx.normal.y = -MESH_NORMAL_UNIT; mesh_set_vertex_vx(mesh, &vx); last_idx = 0; ang_idx = 0; pad = 1; next_angle = first_angle = 0; if (angles->count) { next_angle = angles->vals[0]; first_angle = 7*next_angle/8; pad = 0; } step_div_h = DOME_STEP_H; i=0; if (ground_dome) { step_div_h *= 2; i=1; } for (; i<DOME_STEP_V; i++) { if (ground_dome) { angle = first_angle + (i * (GF_PI2-first_angle) / DOME_STEP_V); } else { angle = (i * GF_PI / DOME_STEP_V); } /*switch cols*/ if (angle >= next_angle) { if (ang_idx+1<=angles->count) { start_angle = next_angle; next_angle = angles->vals[ang_idx+1]; if (next_angle>GF_PI) next_angle=GF_PI; start_col = end_col; ang_idx++; if (ang_idx+1<color->count) { COL_TO_RGBA(end_col, color->vals[ang_idx+1]); } else { pad = 1; } } else { if (ground_dome) break; pad = 1; } } if (pad) { fcol = end_col; } else { frac = gf_divfix(angle - start_angle, next_angle - start_angle) ; fcol.red = gf_mulfix(end_col.red - start_col.red, frac) + start_col.red; fcol.green = gf_mulfix(end_col.green - start_col.green, frac) + start_col.green; fcol.blue = gf_mulfix(end_col.blue - start_col.blue, frac) + start_col.blue; fcol.alpha = FIX_ONE; } vx.color = MESH_MAKE_COL(fcol); vx.pos.y = gf_sin(GF_PI2 - angle); r = gf_sqrt(FIX_ONE - gf_mulfix(vx.pos.y, vx.pos.y)); new_idx = mesh->v_count; for (j = 0; j < step_div_h; j++) { SFVec3f n; Fixed lon = 2 * GF_PI * j / step_div_h; vx.pos.x = gf_mulfix(gf_sin(lon), r); vx.pos.z = gf_mulfix(gf_cos(lon), r); n = gf_vec_scale(vx.pos, FIX_ONE /*-FIX_ONE*/); gf_vec_norm(&n); MESH_SET_NORMAL(vx, n); mesh_set_vertex_vx(mesh, &vx); if (j) { if (i>1) { mesh_set_triangle(mesh, last_idx+j, new_idx+j, new_idx+j-1); mesh_set_triangle(mesh, last_idx+j, new_idx+j-1, last_idx+j-1); } else { mesh_set_triangle(mesh, 0, new_idx+j, new_idx+j-1); } } } if (i>1) { mesh_set_triangle(mesh, last_idx, new_idx, new_idx+step_div_h-1); mesh_set_triangle(mesh, last_idx, new_idx+step_div_h-1, last_idx+step_div_h-1); } else { mesh_set_triangle(mesh, 0, new_idx, new_idx+step_div_h-1); } last_idx = new_idx; } if (!ground_dome) { new_idx = mesh->v_count; vx.pos.x = vx.pos.z = 0; vx.pos.y = -FIX_ONE; vx.normal.x = vx.normal.z = 0; vx.normal.y = MESH_NORMAL_UNIT; mesh_set_vertex_vx(mesh, &vx); for (j=1; j < step_div_h; j++) { mesh_set_triangle(mesh, last_idx+j-1, last_idx+j, new_idx); } mesh_set_triangle(mesh, last_idx+step_div_h-1, last_idx, new_idx); } mesh->flags |= MESH_HAS_COLOR | MESH_NO_TEXTURE; mesh_update_bounds(mesh); }
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 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"); } }