var update_asteroid_cb = function(obj, id, pulse) {
var asteroid = obj;
if (asteroid.active) {
// set new tranlation
var ast_obj = asteroid.ast_obj;
var asteroid_pos = m_trans.get_translation(ast_obj, _vec3_tmp);
var elapsed = m_ctl.get_sensor_value(obj, id, 0);
var diff_pos = m_vec3.scale(asteroid.velosity, elapsed, _vec3_tmp2);
m_vec3.add(asteroid_pos, diff_pos, asteroid_pos);
m_trans.set_translation_v(ast_obj, asteroid_pos);
// set new rotation
var angle = m_quat.slerp(QUAT4_IDENT,
asteroid.angular_velosity, elapsed, _quat_tmp);
var aster_quat = m_trans.get_rotation(ast_obj, _quat_tmp2);
var new_aster_quat = m_quat.multiply(aster_quat, angle, _quat_tmp);
m_quat.normalize(new_aster_quat, new_aster_quat);
m_trans.set_rotation_v(ast_obj, new_aster_quat);
var ast_copy_obj = asteroid.ast_copy_obj;
if (ast_copy_obj) {
m_trans.set_translation_v(ast_copy_obj, asteroid_pos);
m_trans.set_rotation_v(ast_copy_obj, new_aster_quat);
}
if (asteroid_pos[2] > 20)
init_asteroid_transform(asteroid);
}
}
function rotate_object(obj, angle) {
var obj_parent = m_obj.get_parent(obj);
if (obj_parent && m_obj.is_armature(obj_parent)) {
// rotate the parent (armature) of the animated object
var obj_quat = m_trans.get_rotation(obj_parent, _vec4_tmp);
m_quat.rotateZ(obj_quat, angle, obj_quat);
m_trans.set_rotation_v(obj_parent, obj_quat);
} else {
var obj_quat = m_trans.get_rotation(obj, _vec4_tmp);
m_quat.rotateZ(obj_quat, angle, obj_quat);
m_trans.set_rotation_v(obj, obj_quat);
}
limit_object_position(obj);
}
function rotate_to_dest(golem_wrapper, elapsed) {
var golem_empty = golem_wrapper.empty;
var dest_pos = golem_wrapper.dest_pos;
var trans = _vec3_tmp;
var cur_dir = _vec3_tmp_2;
var dir_to_dest = _vec3_tmp_3;
var cur_rot_q = _quat4_tmp;
var new_rot_q = _quat4_tmp2;
m_trans.get_translation(golem_empty, trans);
m_trans.get_rotation(golem_empty, cur_rot_q);
m_vec3.transformQuat(m_util.AXIS_MY, cur_rot_q, cur_dir);
m_vec3.subtract(dest_pos, trans, dir_to_dest);
m_vec3.normalize(dir_to_dest, dir_to_dest);
m_quat.rotationTo(cur_dir, dir_to_dest, new_rot_q);
m_quat.multiply(new_rot_q, cur_rot_q, new_rot_q);
var vec_dot = m_vec3.dot(cur_dir, dir_to_dest);
vec_dot = vec_dot > 1? 1: vec_dot < -1? -1: vec_dot;
var angle_to_turn = Math.acos(vec_dot);
var angle_ratio = Math.abs(angle_to_turn) / Math.PI;
var slerp = elapsed / angle_ratio * m_conf.GOLEM_ROT_SPEED;
m_quat.slerp(cur_rot_q, new_rot_q, Math.min(slerp, 1), new_rot_q);
m_trans.set_rotation_v(golem_empty, new_rot_q);
return angle_to_turn
}
function set_rocket_rotation(x, y) {
var rocket_trans = m_trans.get_translation(_current_rocket,
_vec3_tmp);
var rocket_quat = m_trans.get_rotation(_current_rocket, _quat_tmp);
var rocket_rail_trans = m_trans.get_translation(_current_rail,
_vec3_tmp2);
var rocket_rail_quat = m_trans.get_rotation(_current_rail, _quat_tmp2);
var project_point = m_cam.project_point(_cam, rocket_rail_trans,
_vec3_tmp3);
var delta_x = x - project_point[0];
var delta_y = y - project_point[1];
var delta = Math.sqrt(delta_x * delta_x + delta_y * delta_y);
if (delta < ROCKET_ROTATE_DIST)
_in_area = true;
else {
_in_area = false;
delta = ROCKET_ROTATE_DIST;
}
var new_rocket_quat = rotate_to(rocket_rail_trans, rocket_trans,
rocket_quat);
var delta_rocket_quat = m_quat.slerp(rocket_rail_quat, new_rocket_quat,
delta/ROCKET_ROTATE_DIST, _quat_tmp3);
m_trans.set_rotation_v(_current_rocket, delta_rocket_quat);
}
function kill(golem_wrapper) {
var golem = golem_wrapper.empty;
var golem_death_empty = m_scs.get_object_by_name(m_conf.GOLEMS_DEATH_EMPTY);
var golem_death = m_scs.get_object_by_dupli_name(m_conf.GOLEMS_DEATH_EMPTY,
m_conf.GOLEMS_DEATH_RIG);
var golem_death_blow = m_scs.get_object_by_dupli_name(m_conf.GOLEMS_DEATH_EMPTY,
m_conf.GOLEMS_DEATH_BLOW);
var trans = _vec3_tmp;
var quat = _quat4_tmp;
m_trans.get_translation(golem, trans);
m_trans.get_rotation(golem, quat);
m_trans.set_translation_v(golem_death_empty, trans);
m_trans.set_rotation_v(golem_death_empty, quat);
m_anim.apply(golem_death, "golem_death");
m_anim.set_behavior(golem_death, m_anim.AB_FINISH_STOP);
m_anim.play(golem_death);
m_anim.play(golem_death_blow);
m_sfx.stop(golem_wrapper.walk_speaker);
m_trans.set_translation_v(golem, m_conf.DEFAULT_POS);
m_gems.spawn(trans);
golem_wrapper.island_id = -1;
golem_wrapper.hp = 100;
set_state(golem_wrapper, m_conf.GS_NONE)
m_obelisks.change_gems_num(golem_wrapper.island_id, 0);
}
var crosshair_cb = function(obj, id, pulse) {
var cam_pos = m_trans.get_translation(cam_obj, _vec3_tmp);
m_trans.set_translation_v(obj, cam_pos);
var view = m_trans.get_rotation(cam_obj, _quat_tmp);
var cross_view = m_trans.get_rotation(obj, _quat_tmp2);
var elapsed = m_ctl.get_sensor_value(obj, id, 0);
var new_cross_view = m_quat.lerp(cross_view, view,
CROSSHAIR_DELAY * elapsed, _quat_tmp);
m_trans.set_rotation_v(obj, new_cross_view);
}
m_anim.play(_residual_smoke, function(){
_is_smoke = false;
m_trans.set_tsr(_cam, _camera_point_tsr);
var cam_quat = m_trans.get_rotation(_cam, _quat_tmp);
var new_cam_quat = m_quat.rotateX(cam_quat, Math.PI,
_quat_tmp2);
m_trans.set_rotation_v(_cam, new_cam_quat);
run_firework();
});
var rotate_cb = function(obj, id, pulse) {
if (pulse > 0) {
var curr_angles = m_ctl.get_sensor_payload(obj, id, 0);
if (m_cam.is_eye_camera(obj)) {
var alpha = curr_angles[2];
var beta = curr_angles[1];
var gamma = curr_angles[0];
var quaternion = _quat_tmp;
var c1 = Math.cos(alpha / 2);
var c2 = Math.cos(beta / 2);
var c3 = Math.cos(gamma / 2);
var s1 = Math.sin(alpha / 2);
var s2 = Math.sin(beta / 2);
var s3 = Math.sin(gamma / 2);
quaternion[0] = c1 * s2 * c3 - s1 * c2 * s3;
quaternion[1] = c1 * c2 * s3 + s1 * s2 * c3;
quaternion[2] = s1 * c2 * c3 + c1 * s2 * s3;
quaternion[3] = c1 * c2 * c3 - s1 * s2 * s3;
var orientation = Math.PI * window.orientation / 180;
var screen_quat = m_quat.setAxisAngle(m_util.AXIS_Z,
-orientation, _quat_tmp2);
quaternion = m_quat.multiply(quaternion, screen_quat, _quat_tmp);
var quat = m_quat.setAxisAngle(m_util.AXIS_X, Math.PI / 2,
_quat_tmp2);
quaternion = m_quat.multiply(quaternion, quat, _quat_tmp);
if (save_angles) {
m_quat.copy(quaternion, _last_gyro_quat);
save_angles = false;
} else {
var last_gyro_inv_quat = m_quat.invert(_last_gyro_quat, _last_gyro_quat);
var cam_quat = m_trans.get_rotation(obj, _quat_tmp2);
var clear_cam_quat = m_quat.multiply(cam_quat, last_gyro_inv_quat, _quat_tmp2);
var new_cam_quat = m_quat.multiply(clear_cam_quat, quaternion, _quat_tmp2);
var up_axis = m_vec3.transformQuat(m_util.AXIS_MZ,
new_cam_quat, _vec3_tmp);
m_cam.set_vertical_axis(obj, up_axis);
m_trans.set_rotation_v(obj, new_cam_quat);
m_quat.copy(quaternion, _last_gyro_quat);
}
}
}
}
function spawn(golem_wrapper, island_id, spawn_points, spawn_quats) {
var golem_empty = golem_wrapper.empty;
var num_spawns = spawn_points.length / m_conf.NUM_ISLANDS;
var spawn_id = Math.floor(Math.random() * num_spawns);
var spawn_pt_id = num_spawns * island_id + spawn_id;
var spawn_point = spawn_points[spawn_pt_id];
var spawn_quat = spawn_quats[spawn_pt_id];
m_trans.set_translation_v(golem_empty, spawn_point);
m_trans.set_rotation_v(golem_empty, spawn_quat);
set_state(golem_wrapper, m_conf.GS_GETTING_OUT)
m_sfx.play_def(golem_wrapper.getout_speaker);
golem_wrapper.island_id = island_id;
golem_wrapper.dest_pos.set(spawn_point);
}
exports.disable_hmd = function() {
m_ctl.remove_sensor_manifold(null, "HMD_ROTATE_CAMERA");
// set up non-vr mode
var hmd_params = {};
hmd_params.enable_hmd_stereo = false;
m_scenes.set_hmd_params(hmd_params);
// resize screen to canvas resolution (non-vr mode)
var canvas_container_elem = m_cont.get_container();
var ccw = canvas_container_elem.clientWidth;
var cch = canvas_container_elem.clientHeight;
m_cont.resize(ccw, cch, true);
// correct up camera (non-vr mode)
var cam_obj = m_scenes.get_active_camera();
m_cam.set_vertical_axis(cam_obj, m_util.AXIS_Y);
// TODO: update_transform
var cam_quat = m_trans.get_rotation(cam_obj, _quat_tmp);
m_trans.set_rotation_v(cam_obj, cam_quat);
}
var ray_test_cb = function(id, hit_fract, obj_hit, hit_time, hit_pos, hit_norm) {
var decal = m_obj.copy(decal_src, "decal" + String(++decal_num), false);
m_scenes.append_object(decal);
m_tsr.set_trans(hit_pos, decal_tsr);
m_quat.rotationTo(m_util.AXIS_Y, hit_norm, decal_rot);
m_trans.set_rotation_v(decal, decal_rot);
m_tsr.set_quat(decal_rot, decal_tsr);
if (obj_hit && m_anim.is_animated(obj_hit)) {
m_trans.get_tsr(obj_hit, obj_tsr);
m_tsr.invert(obj_tsr, obj_tsr);
m_tsr.multiply(obj_tsr, decal_tsr, decal_tsr);
var offset = m_tsr.get_trans_view(decal_tsr);
var rot_offset = m_tsr.get_quat_view(decal_tsr);
m_cons.append_stiff(decal, obj_hit, offset, rot_offset);
}
m_trans.set_tsr(decal, decal_tsr);
}
function rotate_to_dir(obj, dir_to_dest, elapsed) {
var cur_dir = _vec3_tmp1;
var cur_rot_q = _vec4_tmp;
var new_rot_q = _vec4_tmp2;
m_trans.get_rotation(obj, cur_rot_q);
m_vec3.transformQuat(m_util.AXIS_MY, cur_rot_q, cur_dir);
dir_to_dest[2] = 0;
m_vec3.normalize(dir_to_dest, dir_to_dest);
m_quat.rotationTo(cur_dir, dir_to_dest, new_rot_q);
m_quat.multiply(new_rot_q, cur_rot_q, new_rot_q);
var vec_dot = m_vec3.dot(cur_dir, dir_to_dest);
vec_dot = vec_dot > 1 ? 1 : vec_dot < -1 ? -1 : vec_dot;
var angle_to_turn = Math.acos(vec_dot);
var slerp = elapsed * (_gs.speed / _gs.dist_err) / Math.abs(angle_to_turn)*Math.PI/2;
slerp = Math.min(slerp, 1);
m_quat.slerp(cur_rot_q, new_rot_q, slerp, new_rot_q);
m_trans.set_rotation_v(obj, new_rot_q);
return angle_to_turn - angle_to_turn * slerp;
}
var move_cam_cb = function(obj, id, pulse) {
var cam_obj = m_scenes.get_active_camera();
if (!cam_obj)
return;
if (pulse > 0) {
// NOTE: init part
if (!updated_eye_data) {
var hmd_left_fov = get_fov("left", _vec4_tmp);
var hmd_right_fov = get_fov("right", _vec4_tmp2);
if (hmd_left_fov && hmd_left_fov)
m_cam.set_hmd_fov(cam_obj, hmd_left_fov, hmd_right_fov);
var eye_distance = get_eye_distance();
if (eye_distance)
m_cam.set_eye_distance(cam_obj, eye_distance);
var hmd_params = {};
if (_hmd_device.deviceName.toLowerCase().indexOf("oculus") !== -1)
var hmd_name = "oculus";
else
var hmd_name = "default";
hmd_params.distortion_coefs = [
_devices_params[hmd_name]["distortion_coefs"][0],
_devices_params[hmd_name]["distortion_coefs"][1]
];
hmd_params.chromatic_aberration_coefs = [
_devices_params[hmd_name]["chromatic_aberration_coefs"][0],
_devices_params[hmd_name]["chromatic_aberration_coefs"][1],
_devices_params[hmd_name]["chromatic_aberration_coefs"][2],
_devices_params[hmd_name]["chromatic_aberration_coefs"][3]
];
hmd_params.distortion_scale = _devices_params[hmd_name]["distortion_scale"];
// TODO: set distortion_offset
hmd_params.distortion_offset = 0.0;
hmd_params.enable_hmd_stereo = true;
m_scenes.set_hmd_params(hmd_params);
var canvas_container_elem = m_cont.get_container();
var ccw = canvas_container_elem.clientWidth;
var cch = canvas_container_elem.clientHeight;
m_cont.resize(ccw, cch, true);
updated_eye_data = true;
_last_cam_quat = m_trans.get_rotation(cam_obj, _last_cam_quat);
reset_hmd();
}
// NOTE: It is executed every frame.
// uses _vec3_tmp, _vec3_tmp2, _vec3_tmp3, _quat_tmp, _quat_tmp2
if (m_cam.is_eye_camera(cam_obj)) {
if (control_type == HMD_ALL_AXES_MOUSE_NONE) {
var hmd_quat = get_sensor_orientation(_quat_tmp);
if (hmd_quat) {
var quat = m_quat.setAxisAngle(m_util.AXIS_X, Math.PI / 2, _quat_tmp2);
m_quat.normalize(quat, quat);
hmd_quat = m_quat.multiply(hmd_quat, quat, _quat_tmp);
var up_axis = m_vec3.transformQuat(m_util.AXIS_Z, hmd_quat, _vec3_tmp);
m_cam.set_vertical_axis(cam_obj, up_axis);
m_trans.set_rotation_v(cam_obj, hmd_quat);
}
} else if (control_type == HMD_ROLL_PITCH_MOUSE_YAW ||
control_type == HMD_ALL_AXES_MOUSE_YAW) {
var hmd_quat = get_sensor_orientation(_quat_tmp);
if (hmd_quat) {
// NOTE: hmd_quat to WEBGL axis orientation
var quat = m_quat.setAxisAngle(m_util.AXIS_X, Math.PI / 2,
_quat_tmp2);
m_quat.normalize(quat, quat);
hmd_quat = m_quat.multiply(hmd_quat, quat, _quat_tmp);
var cam_quat = m_trans.get_rotation(cam_obj,
_quat_tmp2);
var inv_cam_quat = m_quat.invert(cam_quat,
_quat_tmp2);
var diff_cam_quat = m_quat.multiply(_last_cam_quat,
inv_cam_quat, _quat_tmp2);
var cur_vertical_axis = m_cam.get_vertical_axis(cam_obj,
_vec3_tmp);
if (Math.abs(cur_vertical_axis[2]) < Math.PI / 4)
var first_horiz_vec = m_vec3.cross(cur_vertical_axis,
m_util.AXIS_Z, _vec3_tmp2);
else if (Math.abs(cur_vertical_axis[1]) < Math.PI / 4)
var first_horiz_vec = m_vec3.cross(cur_vertical_axis,
m_util.AXIS_Y, _vec3_tmp2);
m_vec3.normalize(first_horiz_vec, first_horiz_vec);
var rotated_first_horiz_vec = m_vec3.transformQuat(
first_horiz_vec, diff_cam_quat, _vec3_tmp3);
var vertical_coef = m_vec3.dot(cur_vertical_axis,
rotated_first_horiz_vec);
var second_horiz_vec = m_vec3.scaleAndAdd(rotated_first_horiz_vec,
cur_vertical_axis, -vertical_coef, _vec3_tmp3);
m_vec3.normalize(second_horiz_vec, second_horiz_vec);
var sign_horiz_vec = m_vec3.cross(cur_vertical_axis,
first_horiz_vec, _vec3_tmp);
var abs_yaw_angle = Math.acos(m_util.clamp(
m_vec3.dot(first_horiz_vec, second_horiz_vec),
0, 1));
var sign_yaw_angle = m_util.sign(m_vec3.dot(
second_horiz_vec, sign_horiz_vec));
var diff_yaw_cam_angle = abs_yaw_angle * sign_yaw_angle;
_yaw_cam_angle += diff_yaw_cam_angle;
var yaw_cam_quat = m_quat.setAxisAngle(m_util.AXIS_Y,
-_yaw_cam_angle, _quat_tmp2);
if (control_type == HMD_ALL_AXES_MOUSE_YAW) {
var new_cam_quat = m_quat.multiply(yaw_cam_quat,
hmd_quat, _quat_tmp);
} else {
var yaw_hmd_quat = m_util.quat_project(hmd_quat, m_util.AXIS_MY,
m_util.AXIS_Y, m_util.AXIS_MZ, _quat_tmp3);
var yaw_hmd_inv_quat = m_quat.invert(yaw_hmd_quat, _quat_tmp3);
var vertical_hmd_quat = m_quat.multiply(
yaw_hmd_inv_quat, hmd_quat, _quat_tmp3);
var new_cam_quat = m_quat.multiply(yaw_cam_quat,
vertical_hmd_quat, _quat_tmp);
}
var up_axis = m_vec3.transformQuat(m_util.AXIS_Z,
new_cam_quat, _vec3_tmp);
m_cam.set_vertical_axis(cam_obj, up_axis);
m_trans.set_rotation_v(cam_obj, new_cam_quat);
m_quat.copy(new_cam_quat, _last_cam_quat)
}
}
}
}
}
var sensor_cb = function(obj, id, pulse) {
var left_vert_axis = m_ctl.get_sensor_value(obj, id, 3);
var left_hor_axis = m_ctl.get_sensor_value(obj, id, 4);
var ellapsed = m_ctl.get_sensor_value(obj, id, 5);
var troll_quat = m_trans.get_rotation(obj, _quat_tmp);
var troll_view_vec = m_vec3.transformQuat(m_util.AXIS_Z, troll_quat, _vec3_tmp);
m_vec3.scale(troll_view_vec, STEP, troll_view_vec);
var troll_trans = m_trans.get_translation(obj, _vec3_tmp2);
switch (id) {
case "UP":
var up = m_ctl.get_sensor_value(obj, id, 0)
|| m_ctl.get_sensor_value(obj, id, 1)
|| m_ctl.get_sensor_value(obj, id, 2);
var vert = left_vert_axis > AXIS_THRESHOLD ? left_vert_axis : 0;
if (up)
m_vec3.scaleAndAdd(troll_trans, troll_view_vec, ellapsed, troll_trans);
if (vert) {
m_vec3.scaleAndAdd(troll_trans, troll_view_vec, -vert * STEP *ellapsed, troll_trans);
m_anim.set_speed(obj, ANIM_SPEED * vert, m_anim.SLOT_0);
}
break;
case "DOWN":
var down = m_ctl.get_sensor_value(obj, id, 0)
|| m_ctl.get_sensor_value(obj, id, 1)
|| m_ctl.get_sensor_value(obj, id, 2);
var vert = left_vert_axis < -AXIS_THRESHOLD ? left_vert_axis : 0;
if (down)
m_vec3.scaleAndAdd(troll_trans, troll_view_vec, -ellapsed, troll_trans);
if (vert) {
m_anim.set_speed(obj, -ANIM_SPEED * vert, m_anim.SLOT_0);
m_vec3.scaleAndAdd(troll_trans, troll_view_vec, -vert * STEP *ellapsed, troll_trans);
}
break;
case "LEFT":
var left = m_ctl.get_sensor_value(obj, id, 0)
|| m_ctl.get_sensor_value(obj, id, 1)
|| m_ctl.get_sensor_value(obj, id, 2);
var hor = left_hor_axis > AXIS_THRESHOLD ? left_hor_axis : 0;
if (left)
m_quat.rotateY(troll_quat, ROT_ANGLE * ellapsed, troll_quat);
if (hor)
m_quat.rotateY(troll_quat, -hor * ROT_ANGLE * ellapsed, troll_quat);
break;
case "RIGHT":
var right = m_ctl.get_sensor_value(obj, id, 0)
|| m_ctl.get_sensor_value(obj, id, 1)
|| m_ctl.get_sensor_value(obj, id, 2);
var hor = left_hor_axis < -AXIS_THRESHOLD ? left_hor_axis : 0;
if (right)
m_quat.rotateY(troll_quat, -ROT_ANGLE * ellapsed, troll_quat);
if (hor)
m_quat.rotateY(troll_quat, -hor * ROT_ANGLE * ellapsed, troll_quat);
break;
};
if ((up || down || vert) && chech_dist_from_middle(troll_trans))
m_trans.set_translation_v(obj, troll_trans);
if (right || left || hor)
m_trans.set_rotation_v(obj, troll_quat);
}
var trans_interp_cb = function(obj, id, pulse) {
if (Math.abs(_dest_x_trans) > EPSILON_DISTANCE ||
Math.abs(_dest_y_trans) > EPSILON_DISTANCE) {
var value = m_ctl.get_sensor_value(obj, id, 0);
var delta_x = m_util.smooth(_dest_x_trans, 0, value, 1);
var delta_y = m_util.smooth(_dest_y_trans, 0, value, 1);
_dest_x_trans -= delta_x;
_dest_y_trans -= delta_y;
var trans = m_trans.get_translation(obj, _vec3_tmp);
trans[0] += delta_x;
trans[1] += delta_y;
m_trans.set_translation_v(obj, trans);
var cam_obj = m_scs.get_active_camera();
m_trans.set_translation_v(cam_obj, trans);
m_trans.set_translation_v(camera_asteroids_obj, trans);
trans[0] -= _dest_x_trans / 2;
trans[1] -= _dest_y_trans / 2;
m_trans.set_translation_v(environment_empty, trans);
var roll_angle = m_util.clamp(_dest_x_trans * COCKPIT_ROT_FACTOR,
-Math.PI * COCKPIT_ROT_FACTOR, Math.PI * COCKPIT_ROT_FACTOR);
var roll_quat = m_quat.setAxisAngle(m_util.AXIS_MZ, roll_angle, _quat_tmp);
var pitch_angle = - m_util.clamp(_dest_y_trans * COCKPIT_ROT_FACTOR,
-Math.PI * COCKPIT_ROT_FACTOR,
Math.PI * COCKPIT_ROT_FACTOR) / 4;
var pitch_quat = m_quat.setAxisAngle(m_util.AXIS_MX, pitch_angle, _quat_tmp2);
var cockpit_quat = m_quat.multiply(roll_quat, pitch_quat, _quat_tmp);
m_trans.set_rotation_v(obj, cockpit_quat);
var environment_sphere_obj = _cockpit.environment_sphere_obj;
if (environment_sphere_obj) {
var cur_sphere_quat = m_trans.get_rotation(environment_sphere_obj, _quat_tmp);
var pitch_angle = m_util.clamp(_dest_y_trans * COCKPIT_ROT_FACTOR,
-Math.PI * COCKPIT_ROT_FACTOR,
Math.PI * COCKPIT_ROT_FACTOR) * ENV_SPHERE_ROT_FACTOR;
var pitch_quat = m_quat.setAxisAngle(m_util.AXIS_MX, pitch_angle, _quat_tmp2);
var new_sphere_quat = m_quat.multiply(cur_sphere_quat,
pitch_quat, _quat_tmp);
var yaw_angle = - roll_angle * ENV_SPHERE_ROT_FACTOR;
var yaw_quat = m_quat.setAxisAngle(m_util.AXIS_MY,
yaw_angle, _quat_tmp2);
new_sphere_quat = m_quat.multiply(cur_sphere_quat,
yaw_quat, _quat_tmp);
m_trans.set_rotation_v(environment_sphere_obj, new_sphere_quat);
}
// bend environment
var init_bending_pos = m_tsr.get_trans_view(init_bending_tsr);
var new_bending_pos = m_vec3.copy(init_bending_pos, _vec3_tmp);
new_bending_pos[0] += _dest_x_trans;
new_bending_pos[1] += _dest_y_trans;
var new_bending_tsr = m_tsr.copy(init_bending_tsr, _tsr_tmp);
new_bending_tsr = m_tsr.set_trans(new_bending_pos, new_bending_tsr);
m_armat.set_bone_tsr(environment_arm, "move", new_bending_tsr);
}
}
function rotate_object(obj, angle) {
var obj_quat = m_trans.get_rotation(obj, _vec4_tmp);
m_quat.rotateY(obj_quat, angle, obj_quat);
m_trans.set_rotation_v(obj, obj_quat);
limit_object_position(obj);
}