Source: addons/hmd.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_input_fact from "../extern/input.js";
  6. import * as m_quat from "../libs/gl_matrix/quat.js";
  7. import m_scenes_fact from "../extern/scenes.js";
  8. import m_screen_fact from "../extern/screen.js";
  9. import m_trans_fact from "../extern/transform.js";
  10. import m_util_fact from "../extern/util.js";
  11. import * as m_vec3 from "../libs/gl_matrix/vec3.js";
  13. /**
  14.  * Head Mounted Devices add-on.
  15.  * Provides support for HMD/VR devices using {@link https://w3c.github.io/webvr/|WebVR API}.
  16.  * <p>For more info about stereo rendering check out the {@link https://www.blend4web.com/doc/en/stereo_rendering.html|user manual}.
  17.  * @module hmd
  18.  */
  20. function HMD(ns, exports) {
  22. var m_cam    = m_cam_fact(ns);
  23. var m_ctl    = m_ctl_fact(ns);
  24. var m_input  = m_input_fact(ns);
  25. var m_scenes = m_scenes_fact(ns);
  26. var m_screen = m_screen_fact(ns);
  27. var m_trans  = m_trans_fact(ns);
  28. var m_util   = m_util_fact(ns);
  30. var _last_cam_quat = m_quat.create();
  31. var _yaw_cam_angle = 0;
  32. var _was_target_camera = false;
  33. var _was_hover_camera = false;
  34. var _was_static_camera = false;
  36. var _vec3_tmp  = m_vec3.create();
  37. var _vec3_tmp2 = m_vec3.create();
  38. var _vec3_tmp3 = m_vec3.create();
  39. var _quat_tmp  = m_quat.create();
  40. var _quat_tmp2 = m_quat.create();
  41. var _quat_tmp3 = m_quat.create();
  42. var _quat_tmp4 = m_quat.create();
  44. var _offset_quat = m_quat.create();
  45. var _offset_pos = m_vec3.create();
  46. var _empty_params = {pivot: m_vec3.create()};
  48. /**
  49.  * HMD behavior enum.
  50.  * @see {@link module:hmd.HMD_NONE_MOUSE_ALL_AXES},
  51.  * {@link module:hmd.HMD_ALL_AXES_MOUSE_NONE},
  52.  * {@link module:hmd.HMD_ROLL_PITCH_MOUSE_YAW},
  53.  * {@link module:hmd.HMD_ALL_AXES_MOUSE_YAW}
  54.  * @typedef {number} HMDBehavior
  55.  */
  57. /**
  58.  * HMD behavior: HMD does not affect camera orientation,
  59.  * mouse controls camera rotation.
  60.  * @const {HMDBehavior} module:hmd.HMD_NONE_MOUSE_ALL_AXES
  61.  */
  62. var HMD_NONE_MOUSE_ALL_AXES = 0;
  63. exports.HMD_NONE_MOUSE_ALL_AXES = HMD_NONE_MOUSE_ALL_AXES;
  65. /**
  66.  * HMD behavior: HMD controls camera rotation,
  67.  * mouse does not affect camera orientation.
  68.  * @const {HMDBehavior} module:hmd.HMD_ALL_AXES_MOUSE_NONE
  69.  */
  70. var HMD_ALL_AXES_MOUSE_NONE = 1;
  71. exports.HMD_ALL_AXES_MOUSE_NONE = HMD_ALL_AXES_MOUSE_NONE;
  73. /**
  74.  * HMD behavior: HMD controls roll and pitch rotation,
  75.  * mouse controls yaw rotation.
  76.  * @const {HMDBehavior} module:hmd.HMD_ROLL_PITCH_MOUSE_YAW
  77.  */
  78. var HMD_ROLL_PITCH_MOUSE_YAW = 2;
  79. exports.HMD_ROLL_PITCH_MOUSE_YAW = HMD_ROLL_PITCH_MOUSE_YAW;
  81. /**
  82.  * HMD behavior: HMD affects camera rotation,
  83.  * mouse affect yaw rotation.
  84.  * @const {HMDBehavior} module:hmd.HMD_ALL_AXES_MOUSE_YAW
  85.  */
  86. var HMD_ALL_AXES_MOUSE_YAW = 3;
  87. exports.HMD_ALL_AXES_MOUSE_YAW = HMD_ALL_AXES_MOUSE_YAW;
  89. /**
  90.  * Enable HMD.
  91.  * @method module:hmd.enable_hmd
  92.  * @param {HMDBehavior} control_type Camera rotation type.
  93.  */
  94. exports.enable_hmd = function(control_type) {
  95.     var sensor = null;
  96.     var device = m_input.get_device_by_type_element(m_input.DEVICE_HMD);
  97.     if (device) {
  98.         if (m_input.get_value_param(device, m_input.HMD_WEBVR_TYPE) &
  99.                 (m_input.HMD_WEBVR_MOBILE | m_input.HMD_WEBVR_DESKTOP | m_input.HMD_WEBVR1))
  100.             // use state of the WebVR device
  101.             sensor = m_ctl.create_hmd_quat_sensor();
  102.         else
  103.             // use gyroscope state
  104.             sensor = m_ctl.create_gyro_quat_sensor();
  105.         process_hmd(control_type, sensor);
  106.     }
  107. }
  109. /**
  110.  * Check if the browser supports WebVR API or it is a mobile version of the browser.
  111.  * @method module:hmd.check_browser_support
  112.  * @return {boolean} Checking result.
  113.  */
  114. exports.check_browser_support = function() {
  115.     return Boolean(m_input.can_use_device(m_input.DEVICE_HMD));
  116. }
  118. /**
  119.  * Enable VR controllers.
  120.  * @method module:hmd.enable_controllers
  121.  * @param {Object3D} [gamepad_1] Object presenting controller.
  122.  * @param {Object3D} [gamepad_2] Object presenting controller.
  123.  * @example
  124.  * var m_hmd = require("hmd");
  125.  * var m_scenes = require("scenes");
  126.  *
  127.  * var gamepad_1 = m_scenes.get_object_by_name("my_gamepad_1");
  128.  * var gamepad_2 = m_scenes.get_object_by_name("my_gamepad_2");
  129.  * m_hmd.enable_controllers(gamepad_1, gamepad_2);
  130.  */
  131. exports.enable_controllers = function(gamepad_1, gamepad_2) {
  132.     // TODO: add default models for gamepad_1, gamepad_2
  133.     disable_controllers();
  135.     if (!gamepad_1 && !gamepad_2)
  136.         return;
  138.     var gamepad_id = m_input.get_vr_controller_id(0);
  139.     var gm_pos_sensor = m_ctl.create_gamepad_position_sensor(gamepad_id);
  140.     var gm_ori_sensor = m_ctl.create_gamepad_orientation_sensor(gamepad_id);
  142.     var gamepad_id2 = m_input.get_vr_controller_id(1);
  143.     var gm_pos_sensor2 = m_ctl.create_gamepad_position_sensor(gamepad_id2);
  144.     var gm_ori_sensor2 = m_ctl.create_gamepad_orientation_sensor(gamepad_id2);
  146.     function position_cb(obj, id, pulse) {
  147.         if (gamepad_1) {
  148.             var gmpos1 = m_ctl.get_sensor_payload(obj, id, 0);
  149.             var gmori1 = m_ctl.get_sensor_payload(obj, id, 2);
  151.             m_vec3.add(_offset_pos, gmpos1, gmpos1);
  152.             m_trans.set_translation_v(gamepad_1, gmpos1);
  153.             m_trans.set_rotation_v(gamepad_1, gmori1);
  154.         }
  156.         if (gamepad_2) {
  157.             var gmpos2 = m_ctl.get_sensor_payload(obj, id, 1);
  158.             var gmori2 = m_ctl.get_sensor_payload(obj, id, 3);
  160.             m_vec3.add(_offset_pos, gmpos2, gmpos2);
  161.             m_trans.set_translation_v(gamepad_2, gmpos2);
  162.             m_trans.set_rotation_v(gamepad_2, gmori2);
  163.         }
  164.     }
  165.     m_ctl.create_sensor_manifold(null, "VR_CONTROLLERS", m_ctl.CT_CONTINUOUS,
  166.             [gm_pos_sensor, gm_pos_sensor2, gm_ori_sensor, gm_ori_sensor2],
  167.             null, position_cb);
  168. }
  170. /**
  171.  * Disable VR controllers.
  172.  * @method module:hmd.disable_controllers
  173.  * @example
  174.  * var m_hmd = require("hmd");
  175.  *
  176.  * m_hmd.disable_controllers();
  177.  */
  178. exports.disable_controllers = disable_controllers;
  179. function disable_controllers() {
  180.     m_ctl.remove_sensor_manifold(null, "VR_CONTROLLERS");
  181. }
  183. function process_hmd(control_type, sensor) {
  184.     if (!sensor)
  185.         return;
  187.     var cam_obj = m_scenes.get_active_camera();
  188.     if (!cam_obj)
  189.         return;
  191.     m_screen.request_split_screen(function() {
  192.         if (!m_cam.is_eye_camera(cam_obj)) {
  193.             _was_target_camera = m_cam.is_target_camera(cam_obj);
  194.             _was_hover_camera = m_cam.is_hover_camera(cam_obj);
  195.             _was_static_camera = m_cam.is_static_camera(cam_obj);
  197.             m_cam.eye_setup(cam_obj);
  198.         }
  200.         var elapsed = m_ctl.create_elapsed_sensor();
  201.         var pos_sensor = m_ctl.create_hmd_position_sensor();
  203.         _last_cam_quat = m_trans.get_rotation(cam_obj, _last_cam_quat);
  204.         m_ctl.create_sensor_manifold(null, "HMD_ROTATE_CAMERA", m_ctl.CT_CONTINUOUS,
  205.                 [elapsed, sensor, pos_sensor], null, move_cam_cb);
  206.     });
  208.     function move_cam_cb(obj, id, pulse) {
  209.         if (pulse > 0) {
  210.             var cam_obj = m_scenes.get_active_camera();
  211.             if (!cam_obj)
  212.                 return;
  214.             // NOTE: It is executed every frame.
  215.             // uses _vec3_tmp, _vec3_tmp2, _vec3_tmp3, _quat_tmp, _quat_tmp2
  216.             if (m_cam.is_eye_camera(cam_obj)) {
  217.                 var hmd_quat = m_ctl.get_sensor_payload(obj, id, 1);
  218.                 var hmd_pos = m_ctl.get_sensor_payload(obj, id, 2);
  220.                 var position = m_vec3.add(hmd_pos, _offset_pos, _vec3_tmp);
  221.                 m_trans.set_translation_v(cam_obj, position);
  223.                 if (hmd_quat) {
  224.                     if (control_type == HMD_ALL_AXES_MOUSE_NONE) {
  225.                         hmd_quat = m_quat.multiply(_offset_quat, hmd_quat, _quat_tmp4);
  226.                         var up_axis = m_vec3.transformQuat(m_util.AXIS_MY, hmd_quat, _vec3_tmp);
  227.                         m_cam.set_vertical_axis(cam_obj, up_axis);
  228.                         m_trans.set_rotation_v(cam_obj, hmd_quat);
  229.                     } else if (control_type == HMD_ROLL_PITCH_MOUSE_YAW ||
  230.                             control_type == HMD_ALL_AXES_MOUSE_YAW) {
  231.                         var cam_quat = m_trans.get_rotation(cam_obj,
  232.                                 _quat_tmp2);
  233.                         var inv_cam_quat = m_quat.invert(cam_quat,
  234.                                 _quat_tmp2);
  235.                         var diff_cam_quat = m_quat.multiply(_last_cam_quat,
  236.                                 inv_cam_quat, _quat_tmp2);
  238.                         var cur_vertical_axis = m_cam.get_vertical_axis(cam_obj,
  239.                                 _vec3_tmp);
  240.                         if (Math.abs(cur_vertical_axis[2]) < Math.PI / 4)
  241.                             var first_horiz_vec = m_vec3.cross(cur_vertical_axis,
  242.                                     m_util.AXIS_MY, _vec3_tmp2);
  243.                         else if (Math.abs(cur_vertical_axis[1]) < Math.PI / 4)
  244.                             var first_horiz_vec = m_vec3.cross(cur_vertical_axis,
  245.                                     m_util.AXIS_Z, _vec3_tmp2);
  247.                         m_vec3.normalize(first_horiz_vec, first_horiz_vec);
  249.                         var rotated_first_horiz_vec = m_vec3.transformQuat(
  250.                                 first_horiz_vec, diff_cam_quat, _vec3_tmp3);
  252.                         var vertical_coef = m_vec3.dot(cur_vertical_axis,
  253.                                 rotated_first_horiz_vec);
  254.                         var second_horiz_vec = m_vec3.scaleAndAdd(rotated_first_horiz_vec,
  255.                                 cur_vertical_axis, -vertical_coef, _vec3_tmp3);
  256.                         m_vec3.normalize(second_horiz_vec, second_horiz_vec);
  258.                         var sign_horiz_vec = m_vec3.cross(cur_vertical_axis,
  259.                                 first_horiz_vec, _vec3_tmp);
  260.                         var abs_yaw_angle = Math.acos(m_util.clamp(
  261.                                 m_vec3.dot(first_horiz_vec, second_horiz_vec),
  262.                                 0, 1));
  263.                         var sign_yaw_angle = m_util.sign(m_vec3.dot(
  264.                                 second_horiz_vec, sign_horiz_vec));
  265.                         var diff_yaw_cam_angle = abs_yaw_angle * sign_yaw_angle;
  267.                         _yaw_cam_angle += diff_yaw_cam_angle;
  268.                         var yaw_cam_quat = m_quat.setAxisAngle(m_util.AXIS_Z,
  269.                                 -_yaw_cam_angle, _quat_tmp2);
  271.                         if (control_type == HMD_ALL_AXES_MOUSE_YAW) {
  272.                             var new_cam_quat = m_quat.multiply(yaw_cam_quat,
  273.                                     hmd_quat, _quat_tmp);
  274.                         } else {
  275.                             var yaw_hmd_quat = m_util.quat_project(hmd_quat, m_util.AXIS_MZ,
  276.                                     m_util.AXIS_Z, m_util.AXIS_Y, _quat_tmp3);
  277.                             var yaw_hmd_inv_quat = m_quat.invert(yaw_hmd_quat, _quat_tmp3);
  278.                             var vertical_hmd_quat = m_quat.multiply(
  279.                                     yaw_hmd_inv_quat, hmd_quat, _quat_tmp3);
  281.                             var new_cam_quat = m_quat.multiply(yaw_cam_quat,
  282.                                     vertical_hmd_quat, _quat_tmp);
  283.                         }
  284.                         var up_axis = m_vec3.transformQuat(m_util.AXIS_MY,
  285.                                 new_cam_quat, _vec3_tmp);
  286.                         m_cam.set_vertical_axis(cam_obj, up_axis);
  288.                         m_trans.set_rotation_v(cam_obj, new_cam_quat);
  289.                         m_quat.copy(new_cam_quat, _last_cam_quat);
  290.                     }
  291.                 }
  292.             }
  293.         }
  294.     }
  295. }
  297. /**
  298.  * Disable HMD.
  299.  * @method module:hmd.disable_hmd
  300.  */
  301. exports.disable_hmd = function() {
  302.     if (!m_ctl.check_sensor_manifold(null, "HMD_ROTATE_CAMERA"))
  303.         return;
  305.     m_ctl.remove_sensor_manifold(null, "HMD_ROTATE_CAMERA");
  307.     m_screen.exit_split_screen();
  309.     var cam_obj = m_scenes.get_active_camera();
  310.     // TODO: add restoring camera's params
  311.     if (_was_target_camera)
  312.         m_cam.target_setup(cam_obj, _empty_params);
  313.     else if (_was_hover_camera)
  314.         m_cam.hover_setup(cam_obj, _empty_params);
  315.     else if (_was_static_camera)
  316.         m_cam.static_setup(cam_obj, _empty_params);
  318.     // correct up camera (non-vr mode)
  319.     m_cam.set_vertical_axis(cam_obj, m_util.AXIS_Z);
  320.     // TODO: update_transform
  321.     var cam_quat = m_trans.get_rotation(cam_obj, _quat_tmp);
  322.     m_trans.set_rotation_v(cam_obj, cam_quat);
  323. }
  324. /**
  325.  * Set hmd initial rotation quat.
  326.  * @method module:hmd.set_rotate_quat
  327.  * @param {Quat} quat Initial rotation quaternion.
  328.  * @example
  329.  * var m_hmd = require("hmd");
  330.  *
  331.  * m_hmd.set_rotate_quat([0,0,0,1]);
  332.  */
  333. exports.set_rotate_quat = function(quat) {
  334.     m_quat.copy(quat, _offset_quat);
  335. }
  336. /**
  337.  * Get hmd initial rotation quat.
  338.  * @method module:hmd.get_rotate_quat
  339.  * @param {Quat} dest Initial rotation quaternion.
  340.  * @return {Quat} dest.
  341.  * @example
  342.  * var m_hmd = require("hmd");
  343.  * var m_quat = require("quat");
  344.  * var _quat_tmp = m_quat.create();
  345.  *
  346.  * var quat = m_hmd.get_rotate_quat(_quat_tmp);
  347.  */
  348. exports.get_rotate_quat = function(dest) {
  349.     m_quat.copy(_offset_quat, dest);
  350.     return dest;
  351. }
  352. /**
  353.  * Set hmd initial position.
  354.  * @method module:hmd.set_position
  355.  * @param {Vec3} position Initial position.
  356.  * @example
  357.  * var m_hmd = require("hmd");
  358.  *
  359.  * m_hmd.set_position([0,0,0]);
  360.  */
  361. exports.set_position = function(position) {
  362.     m_quat.copy(position, _offset_pos);
  363. }
  364. /**
  365.  * Get hmd initial position.
  366.  * @method module:hmd.get_position
  367.  * @param {Vec3} dest Initial position.
  368.  * @return {Vec3} dest.
  369.  * @example
  370.  * var m_hmd = require("hmd");
  371.  * var m_vec3 = require("vec3");
  372.  * var _vec3_tmp = m_vec3.create();
  373.  *
  374.  * var pos = m_hmd.get_position(_vec3_tmp);
  375.  */
  376. exports.get_position = function(dest) {
  377.     m_quat.copy(_offset_pos, dest);
  378.     return dest;
  379. }
  381. };
  383. var hmd_factory = register("hmd", HMD);
  385. export default hmd_factory;