Source: addons/gyroscope.js

  1. import register from "../util/register.js";
  3. import m_cam_fact from "../extern/camera.js";
  4. import m_ctl_fact from "../extern/controls.js";
  5. import m_scenes_fact from "../extern/scenes.js";
  6. import m_trans_fact from "../extern/transform.js";
  7. import m_util_fact from "../extern/util.js";
  8. import * as m_vec3 from "../libs/gl_matrix/vec3.js";
  10. /**
  11.  * Gyroscope actions add-on.
  12.  * Provides support for gyroscope on mobile devices.
  13.  * @see http://www.w3.org/TR/orientation-event/
  14.  * @module gyroscope
  15.  */
  17. function Gyroscope(ns, exports) {
  19. var m_cam        = m_cam_fact(ns);
  20. var m_ctl        = m_ctl_fact(ns);
  21. var m_scenes     = m_scenes_fact(ns);
  22. var m_trans      = m_trans_fact(ns);
  23. var m_util       = m_util_fact(ns);
  25. var _begin_angles = new Float32Array(3);
  26. var _curr_angles = new Float32Array(3);
  28. var _vec3_tmp = m_vec3.create();
  30. var VERTICAL_BETA_ANGLE_THRESHOLD_UP = m_util.deg_to_rad(110);
  31. var VERTICAL_BETA_ANGLE_THRESHOLD_DOWN = m_util.deg_to_rad(70);
  32. var VERTICAL_GAMMA_ANGLE_THRESHOLD_UP = m_util.deg_to_rad(70);
  33. var VERTICAL_GAMMA_ANGLE_THRESHOLD_DOWN = - m_util.deg_to_rad(70);
  35. /**
  36.  * Enable camera rotation according to orientation of mobile device.
  37.  * @method module:gyroscope.enable_camera_rotation
  38.  */
  39. exports.enable_camera_rotation = function() {
  40.     var cam_obj = m_scenes.get_active_camera();
  41.     create_camera_rotation_sensors(cam_obj);
  42. }
  44. function create_camera_rotation_sensors(obj) {
  45.     var g_a_sensor = m_ctl.create_gyro_angles_sensor();
  46.     var g_q_sensor = m_ctl.create_gyro_quat_sensor();
  47.     var save_angles = true;
  49.     var cam_rotate_cb = function(obj, id, pulse) {
  50.         if (pulse > 0) {
  51.             if (m_cam.is_eye_camera(obj)) {
  52.                 var hmd_quat = m_ctl.get_sensor_payload(obj, id, 1);
  53.                 var up_axis = m_vec3.transformQuat(m_util.AXIS_MY, hmd_quat, _vec3_tmp);
  54.                 m_cam.set_vertical_axis(obj, up_axis);
  55.                 m_trans.set_rotation_v(obj, hmd_quat);
  56.             } else {
  57.                 _curr_angles = m_ctl.get_sensor_payload(obj, id, 0);
  59.                 if (save_angles) {
  60.                     _begin_angles[0] = _curr_angles[0];
  61.                     _begin_angles[1] = _curr_angles[1];
  62.                     _begin_angles[2] = _curr_angles[2];
  63.                     save_angles = false;
  64.                 }
  65.                 var delta_beta = 0;
  66.                 var delta_gamma = 0;
  68.                 if (window.orientation == 0) {
  69.                     delta_beta = (_curr_angles[1] - _begin_angles[1]);
  70.                     delta_gamma = (_curr_angles[0] - _begin_angles[0]);
  71.                     if (_curr_angles[1] > VERTICAL_BETA_ANGLE_THRESHOLD_DOWN &&
  72.                             _curr_angles[1] < VERTICAL_BETA_ANGLE_THRESHOLD_UP)
  73.                         delta_gamma = 0;
  74.                 }
  76.                 if (window.orientation == 180) {
  77.                     delta_beta = (_curr_angles[1] - _begin_angles[1]);
  78.                     if (_curr_angles[1] < 0)
  79.                         delta_beta = -delta_beta;
  80.                     delta_gamma = (_begin_angles[0] - _curr_angles[0]);
  81.                     if (delta_beta > Math.PI / 2 || delta_beta < - Math.PI / 2)
  82.                         delta_beta = 0;
  83.                     if (_curr_angles[1] > - VERTICAL_BETA_ANGLE_THRESHOLD_UP &&
  84.                             _curr_angles[1] < - VERTICAL_BETA_ANGLE_THRESHOLD_DOWN)
  85.                         delta_gamma = 0;
  86.                 }
  88.                 if (window.orientation == -90) {
  89.                     delta_beta = (_curr_angles[0] - _begin_angles[0]);
  90.                     if (delta_beta > Math.PI / 2 || delta_beta < - Math.PI / 2)
  91.                         delta_beta = 0;
  92.                     delta_gamma = (_begin_angles[1] - _curr_angles[1]);
  93.                     if (_curr_angles[0] > VERTICAL_GAMMA_ANGLE_THRESHOLD_UP ||
  94.                             _curr_angles[0] < VERTICAL_GAMMA_ANGLE_THRESHOLD_DOWN)
  95.                         delta_gamma = 0;
  96.                 }
  98.                 if (window.orientation == 90) {
  99.                     delta_beta = (_begin_angles[0] - _curr_angles[0]);
  100.                     if (delta_beta > Math.PI / 2 || delta_beta < - Math.PI / 2)
  101.                         delta_beta = 0;
  102.                     delta_gamma = (_curr_angles[1] - _begin_angles[1]);
  103.                     if (_curr_angles[0] > VERTICAL_GAMMA_ANGLE_THRESHOLD_UP ||
  104.                             _curr_angles[0] < VERTICAL_GAMMA_ANGLE_THRESHOLD_DOWN)
  105.                         delta_gamma = 0;
  106.                 }
  108.                 m_cam.rotate_camera(obj, delta_gamma, delta_beta);
  109.                 _begin_angles[0] = _curr_angles[0];
  110.                 _begin_angles[1] = _curr_angles[1];
  111.                 _begin_angles[2] = _curr_angles[2];
  112.             }
  113.         }
  114.     }
  115.     m_ctl.create_sensor_manifold(obj, "CAMERA_ROTATE_GYRO",
  116.             m_ctl.CT_CONTINUOUS, [g_a_sensor, g_q_sensor], null,
  117.             cam_rotate_cb);
  118. }
  120. /**
  121.  * Disable camera rotation according to orientation of mobile device.
  122.  * @method module:gyroscope.disable_camera_rotation
  123.  */
  124. exports.disable_camera_rotation = function() {
  125.     var cam_obj = m_scenes.get_active_camera();
  126.     m_ctl.remove_sensor_manifold(cam_obj, "CAMERA_ROTATE_GYRO");
  127. }
  129. };
  131. var gyroscope_factory = register("gyroscope", Gyroscope);
  133. export default gyroscope_factory;