Source: addons/fps.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_phy_fact from "../extern/physics.js";
  6. import m_scs_fact from "../extern/scenes.js";
  7. import m_util_fact from "../extern/util.js";
  8. import m_main_fact from "../extern/main.js";
  9. import m_cont_fact from "../extern/container.js";
  10. import m_input_fact from "../extern/input.js";
  11. import m_screen_fact from "../extern/screen.js";
  12. import m_trans_fact from "../extern/transform.js";
  13. import m_const_fact from "../extern/constraints.js";
  14. import * as m_vec3 from "../libs/gl_matrix/vec3.js";
  15. import m_hmd_fact from "./hmd.js";
  16. import m_print_fact from "../intern/print.js";
  18. /**
  19.  * Add-on for first person applications.
  20.  * It makes creating FPS applications, binding controls and
  21.  * controlling character movement easier.
  22.  * @module fps
  23.  * @local ChangeStateCallback
  24.  * @local PlockCallback
  25.  * @local CharMotionCallback
  26.  */
  28. function FPS(ns, exports) {
  30. /**
  31.  * Function which is called when the given ID state is changed.
  32.  * @callback ChangeStateCallback
  33.  * @param {number} old_state_id Previous state ID.
  34.  * @param {number} new_state_id New state ID.
  35.  */
  37. /**
  38.  * Function which is called when pointerlock state was changed.
  39.  * @callback PlockCallback
  40.  * @param {HTMLElement} elem HTML element, which required pointerlock
  41.  */
  43. /**
  44.  * Function which is called when character changes his movement direction.
  45.  * @callback CharMotionCallback
  46.  * @param {number} forw_back Forward/backward direction (can be -1, 1 or 0).
  47.  * @param {number} right_left Right/left direction (can be -1, 1 or 0).
  48.  */
  50. /**
  51.  * Callback for characters/camera rotation
  52.  * @callback CharRotationCallback
  53.  * @param {Object3D} character Character
  54.  * @param {number} x rotation around X-axis in radians
  55.  * @param {number} y rotation around Y-axis in radians
  56.  */
  58. var m_cam    = m_cam_fact(ns);
  59. var m_ctl    = m_ctl_fact(ns);
  60. var m_phy    = m_phy_fact(ns);
  61. var m_scs    = m_scs_fact(ns);
  62. var m_util   = m_util_fact(ns);
  63. var m_main   = m_main_fact(ns);
  64. var m_cont   = m_cont_fact(ns);
  65. var m_input  = m_input_fact(ns);
  66. var m_screen = m_screen_fact(ns);
  67. var m_trans  = m_trans_fact(ns);
  68. var m_const  = m_const_fact(ns);
  69. var m_hmd    = m_hmd_fact(ns);
  70. var m_print  = m_print_fact(ns);
  72. var AT_PRESSED = 1;
  73. var AT_RELEASED = 2;
  74. var AT_CONTINUOUS = 3;
  76. var CS_STAY = 0;
  77. var CS_WALK = 1;
  78. var CS_RUN = 2;
  79. var CS_FLY = 3;
  80. var CS_CLIMB = 4;
  82. var MOBILE_FORWARD_BTN_ID = "B4W_DEFAULT_BTN_1";
  83. var MOBILE_BACKWARD_BTN_ID = "B4W_DEFAULT_BTN_2";
  85. var FORWARD_SVG = 'url(data:image/svg+xml;base64,PD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0iVVRGLTgiIHN0YW5kYWxvbmU9Im5vIj8+PHN2ZyBpZD0ic3ZnMzQwMCIgeG1sbnM6cmRmPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5LzAyLzIyLXJkZi1zeW50YXgtbnMjIiB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIGhlaWdodD0iMTQuMTExbW0iIHdpZHRoPSIxNC4xMTFtbSIgdmVyc2lvbj0iMS4xIiB4bWxuczpjYz0iaHR0cDovL2NyZWF0aXZlY29tbW9ucy5vcmcvbnMjIiB4bWxuczpkYz0iaHR0cDovL3B1cmwub3JnL2RjL2VsZW1lbnRzLzEuMS8iIHZpZXdCb3g9IjAgMCA0OS45OTk5OTggNDkuOTk5OTk5Ij4gPG1ldGFkYXRhIGlkPSJtZXRhZGF0YTM0MDUiPjxyZGY6UkRGPjxjYzpXb3JrIHJkZjphYm91dD0iIj48ZGM6Zm9ybWF0PmltYWdlL3N2Zyt4bWw8L2RjOmZvcm1hdD48ZGM6dHlwZSByZGY6cmVzb3VyY2U9Imh0dHA6Ly9wdXJsLm9yZy9kYy9kY21pdHlwZS9TdGlsbEltYWdlIi8+PGRjOnRpdGxlLz48L2NjOldvcms+PC9yZGY6UkRGPiA8L21ldGFkYXRhPiA8ZyBpZD0ibGF5ZXIxIiB0cmFuc2Zvcm09InRyYW5zbGF0ZSgwIC0xMDAyLjQpIj48cmVjdCBpZD0icmVjdDI0MTI2IiBvcGFjaXR5PSIwLjU0MyIgZmlsbC1vcGFjaXR5PSIuODM2MTEiIGhlaWdodD0iNTAiIHdpZHRoPSI1MCIgeT0iMTAwMi40IiB4PSIwIiBmaWxsPSIjZmZmIi8+PHBhdGggaWQ9InBhdGgyNDEyOCIgc3Ryb2tlLWxpbmVqb2luPSJyb3VuZCIgZD0ibTM5LjE0MiAxMDMzLjUtMTQuMTQyLTE0LjE0Mi0xNC4xNDIgMTQuMTQyIiBzdHJva2U9IiM2ZTZlNmUiIHN0cm9rZS1saW5lY2FwPSJyb3VuZCIgc3Ryb2tlLXdpZHRoPSIyIiBmaWxsPSJub25lIi8+IDwvZz48L3N2Zz4=);';
  87. var DRAG_TOUCH_DELTA_MULT = 4;
  88. var DRAG_MOUSE_DELTA_MULT = 2;
  89. var CAM_SMOOTH_CHARACTER_COEFF = 0.2
  90. var AXIS_THRESHOLD = 0.05;
  91. var ROT_STEP = 2.5;
  92. var MIN_VERT_ANG = (-Math.PI + 0.1) / 2;
  93. var MAX_VERT_ANG = (Math.PI - 0.1) / 2;
  94. var MULT_SCALE = 200000;
  95. var GMPD_BTNS_OFFSET = 300;
  96. var GMPD_AXIS_OFFSET = 326;
  98. var _move_delta = new Float32Array(2);
  99. var _smooth_factor = 1;
  100. var _fps_camera_mult = 0.0004;
  101. var _manifold_counter = 0;
  102. var _character_sm = null;
  103. var _plock_sensor = null;
  104. var _plock_cb = {
  105.     enable_cb  : null,
  106.     disable_cb : null
  107. };
  108. var _rotation_cb = function() {};
  109. var _curr_gamepad_id = 0;
  110. var _state_counter = 4;
  111. var _is_freezed = false;
  113. var _vec2_tmp = new Float32Array(2);
  114. var _vec3_tmp = new Float32Array(3);
  115. var _vec3_tmp2 = new Float32Array(3);
  117. function default_rotation_cb(character, rot_x, rot_y) {
  118.     var camera = m_scs.get_active_camera();
  119.     m_cam.rotate_camera(camera, rot_x, rot_y);
  120.     var angles = m_cam.get_camera_angles_char(camera, _vec2_tmp);
  121.     m_phy.set_character_rotation_h(character, angles[0]);
  122.     m_phy.set_character_vert_move_dir_angle(character, angles[1]);
  123. }
  125. function smooth_cb(obj, id, pulse, rot_callback) {
  126.     if (Math.abs(_move_delta[0]) > 0.01 || Math.abs(_move_delta[1]) > 0.01) {
  127.         var elapsed = m_ctl.get_sensor_value(obj, id, 0);
  128.         var rot_x = m_util.smooth(_move_delta[0], 0, elapsed, smooth_coeff());
  129.         var rot_y = m_util.smooth(_move_delta[1], 0, elapsed, smooth_coeff());
  131.         _move_delta[0] -= rot_x;
  132.         _move_delta[1] -= rot_y;
  134.         rot_callback(obj, -rot_x * _fps_camera_mult, -rot_y * _fps_camera_mult);
  135.     }
  136. }
  138. function set_smooth_factor(value) {
  139.     _smooth_factor = value;
  140. }
  142. function smooth_coeff() {
  143.     return CAM_SMOOTH_CHARACTER_COEFF * _smooth_factor;
  144. }
  146. function create_mobile_controls(character, parent_elem) {
  147.     var forward_btn = document.createElement("div");
  149.     forward_btn.style.cssText =
  150.         "position: absolute;" +
  151.         "left: 10px;" +
  152.         "bottom: 70px;" +
  153.         "width: 53px;" +
  154.         "height: 53px;" +
  155.         "background-image: " + FORWARD_SVG;
  156.     forward_btn.setAttribute("id", MOBILE_FORWARD_BTN_ID);
  159.     var backwards_btn = document.createElement("div");
  160.     backwards_btn.style.cssText =
  161.         "position: absolute;" +
  162.         "left: 10px;" +
  163.         "bottom: 10px;" +
  164.         "width: 53px;" +
  165.         "height: 53px;" +
  166.         "background-image: " + FORWARD_SVG +
  167.         "transform: rotate(180deg);" +
  168.         "transform-origin: center;";
  169.     backwards_btn.setAttribute("id", MOBILE_BACKWARD_BTN_ID);
  171.     parent_elem.appendChild(forward_btn);
  172.     parent_elem.appendChild(backwards_btn);
  173. }
  175. function check_pointerlock(elem) {
  176.     var request_plock = elem.requestPointerLock ||
  177.             elem.webkitRequestPointerLock || elem.mozRequestPointerLock;
  178.     return typeof request_plock === "function";
  179. }
  181. function rotate_cam_by_axis(obj, camobj, id, elapsed) {
  182.     var h_axis = m_ctl.get_sensor_value(obj, id, 1);
  183.     var v_axis = m_ctl.get_sensor_value(obj, id, 2);
  184.     var rot_step_value = elapsed * ROT_STEP;
  185.     var vert_axis_val = Math.abs(v_axis) < AXIS_THRESHOLD ? 0 : v_axis;
  186.     var vert_ang = - vert_axis_val * rot_step_value;
  187.     var hor_axis_val = Math.abs(h_axis) < AXIS_THRESHOLD ? 0 : h_axis;
  188.     var hor_ang = - hor_axis_val * rot_step_value;
  189.     vert_ang = m_util.clamp(vert_ang, MIN_VERT_ANG, MAX_VERT_ANG);
  190.     m_cam.rotate_camera(camobj, hor_ang, vert_ang);
  191.     var cam_angls = m_cam.get_camera_angles(camobj, _vec2_tmp);
  192.     m_phy.set_character_rotation_h(obj, cam_angls[0] + Math.PI);
  193. }
  195. function disable_rotation(elem, character) {
  196.     if (m_ctl.check_sensor_manifolds(character, "FPS_PLOCK"))
  197.         m_ctl.remove_sensor_manifold(character, "FPS_PLOCK");
  199.     if (m_ctl.check_sensor_manifolds(null, "FPS_ACTIVATE_PLOCK"))
  200.         m_ctl.remove_sensor_manifold(null, "FPS_ACTIVATE_PLOCK");
  202.     if (m_ctl.check_sensor_manifolds(character, "FPS_CAM_ROT"))
  203.         m_ctl.remove_sensor_manifold(character, "FPS_CAM_ROT");
  205.     if (m_ctl.check_sensor_manifolds(null, "FPS_DRAG_PRESS"))
  206.         m_ctl.remove_sensor_manifold(null, "FPS_DRAG_PRESS");
  208.     if (m_ctl.check_sensor_manifolds(null, "FPS_DRAG_MOVE"))
  209.         m_ctl.remove_sensor_manifold(null, "FPS_DRAG_MOVE");
  211.     if (m_ctl.check_sensor_manifolds(character, "FPS_SMOOTH_DRAG"))
  212.         m_ctl.remove_sensor_manifold(character, "FPS_SMOOTH_DRAG");
  213. }
  215. function enable_rotation(elem, character) {
  216.     if (check_pointerlock(elem) && !m_main.detect_mobile()) {
  217.         var plock_mouse_sen = m_ctl.create_plock_mouse_sensor(elem);
  218.         var plock_sen = _plock_sensor ? _plock_sensor : m_ctl.create_plock_sensor(elem);
  219.         _plock_sensor = plock_sen;
  221.         var fps_plock_logic_func = function(s) {
  222.             return s[0] && s[1];
  223.         }
  225.         var fps_plock_sensors_cb = function(obj, id, pulse) {
  226.             if (pulse > 0) {
  227.                 var payload = m_ctl.get_sensor_payload(obj, id, 0);
  228.                 _rotation_cb(obj, -payload.coords[0] * _fps_camera_mult,
  229.                         -payload.coords[1] * _fps_camera_mult);
  230.             }
  231.         }
  232.         m_ctl.create_sensor_manifold(character, "FPS_PLOCK", 
  233.                 m_ctl.CT_CONTINUOUS, [plock_mouse_sen, plock_sen],
  234.                 fps_plock_logic_func, fps_plock_sensors_cb);
  236.         var fps_act_logic_func = function(s) {
  237.             return s[0];
  238.         }
  240.         var fps_act_sensor_cb = function(obj, id, pulse) {
  241.             if (pulse > 0) {
  242.                 if (_plock_cb.enable_cb)
  243.                     _plock_cb.enable_cb(elem);
  244.             } else
  245.                 if (_plock_cb.disable_cb)
  246.                     _plock_cb.disable_cb(elem);
  247.         }
  248.         m_ctl.create_sensor_manifold(null, "FPS_ACTIVATE_PLOCK", 
  249.                 m_ctl.CT_TRIGGER, [plock_sen],
  250.                 fps_act_logic_func, fps_act_sensor_cb);
  251.     } else {
  253.         if (m_main.detect_mobile()) {
  254.             var move_sen = m_ctl.create_touch_move_sensor("XY", elem);
  255.             var click_sen = m_ctl.create_touch_click_sensor(elem);
  256.             var drag_mult = DRAG_TOUCH_DELTA_MULT;
  257.         } else {
  258.             var move_sen = m_ctl.create_mouse_move_sensor("XY", elem);
  259.             var click_sen = m_ctl.create_mouse_click_sensor(elem);
  260.             var drag_mult = DRAG_MOUSE_DELTA_MULT;
  262.             var camera = m_scs.get_active_camera();
  263.             var cam_rot_sensor_cb = function(obj, id, pulse) {
  264.                 if (pulse > 0) {
  265.                     var elapsed = m_ctl.get_sensor_value(obj, id, 0);
  266.                     rotate_cam_by_axis(obj, camera, id, elapsed);
  267.                 }
  268.             }
  269.             var logic_func = function(s) {
  270.                 return Math.abs(s[1]) > AXIS_THRESHOLD || Math.abs(s[2]) > AXIS_THRESHOLD;
  271.             };
  272.             var e_s = m_ctl.create_elapsed_sensor();
  273.             var h_axis = m_ctl.create_gamepad_axis_sensor(m_input.GMPD_AXIS_2);
  274.             var v_axis = m_ctl.create_gamepad_axis_sensor(m_input.GMPD_AXIS_3);
  275.             m_ctl.create_sensor_manifold(character, "FPS_CAM_ROT", m_ctl.CT_CONTINUOUS,
  276.                     [e_s, h_axis, v_axis], logic_func, cam_rot_sensor_cb);
  277.         }
  279.         var move_x = 0;
  280.         var move_y = 0;
  282.         var press_logic_func = function(s) {
  283.             return s[0];
  284.         }
  285.         var press_sensor_cb = function(obj, id, pulse) {
  286.             if (pulse == 1) {
  287.                 var payload = m_ctl.get_sensor_payload(obj, id, 0);
  288.                 var coords = payload.coords;
  289.                 move_x = coords[0];
  290.                 move_y = coords[1];
  291.             }
  292.         }
  293.         m_ctl.create_sensor_manifold(null, "FPS_DRAG_PRESS", 
  294.                 m_ctl.CT_SHOT, [click_sen],
  295.                 press_logic_func, press_sensor_cb);
  297.         var move_logic_func = function(s) {
  298.             return s[0] && s[1];
  299.         }
  300.         var move_sensor_cb = function(obj, id, pulse) {
  301.             if (pulse == 1) {
  302.                 var payload = m_ctl.get_sensor_payload(obj, id, 0);
  303.                 var coords = payload.coords;
  304.                 _move_delta[0] += (coords[0] - move_x) * drag_mult;
  305.                 _move_delta[1] += (coords[1] - move_y) * drag_mult;
  307.                 move_x = coords[0];
  308.                 move_y = coords[1];
  309.             }
  310.         }
  311.         m_ctl.create_sensor_manifold(null, "FPS_DRAG_MOVE", 
  312.                 m_ctl.CT_CONTINUOUS, [move_sen, click_sen],
  313.                 move_logic_func, move_sensor_cb);
  315.         var elapsed = m_ctl.create_elapsed_sensor();
  317.         m_ctl.create_sensor_manifold(character, "FPS_SMOOTH_DRAG", m_ctl.CT_CONTINUOUS,
  318.             [elapsed], null, smooth_cb, _rotation_cb);
  319.     }
  320. }
  322. function set_characters_camera(character, lock_camera) {
  323.     var cam_obj = m_scs.get_active_camera();
  324.     if (lock_camera) {
  325.         var cam_trans = m_trans.get_translation(cam_obj, _vec3_tmp);
  326.         var char_trans = m_trans.get_translation(character, _vec3_tmp2);
  327.         m_vec3.subtract(cam_trans, char_trans, cam_trans);
  328.         m_const.append_stiff_trans(cam_obj, character, cam_trans);
  329.     }
  330.     var angles = m_cam.get_camera_angles_char(cam_obj, _vec2_tmp);
  331.     m_phy.set_character_rotation_h(character, angles[0]);
  332.     m_phy.set_character_vert_move_dir_angle(character, angles[1]);
  333. }
  335. var _enable_vr_cb = null;
  336. var _disable_vr_cb = null;
  338. // TODO: remove next function
  339. exports.append_switch_vr_cbs = function(enable_cb, disable_cb) {
  340.     _enable_vr_cb = enable_cb;
  341.     _disable_vr_cb = _disable_vr_cb;
  342. }
  344. function register_hmd(elem, character) {
  345.     m_input.add_click_listener(elem, function() {
  346.         m_screen.request_fullscreen_hmd(elem,
  347.             function() {
  348.                 disable_rotation(elem, character);
  350.                 // camera rotation is enabled with HMD
  351.                 m_hmd.enable_hmd(m_hmd.HMD_ALL_AXES_MOUSE_NONE);
  353.                 create_character_vr_rotate_sensor(character);
  354.                 if (_enable_vr_cb)
  355.                     _enable_vr_cb();
  356.             },
  357.             function() {
  358.                 remove_character_vr_rotate_sensor(character);
  359.                 m_hmd.disable_hmd();
  361.                 enable_rotation(elem, character);
  362.                 if (_disable_vr_cb)
  363.                     _disable_vr_cb();
  364.             }
  365.         );
  366.     });
  367. }
  369. function create_character_vr_rotate_sensor(character) {
  371.     var e_s = m_ctl.create_elapsed_sensor();
  372.     var camobj = m_scs.get_active_camera();
  374.     var sensor_cb = function(obj, id, pulse) {
  375.         var hor_angle = m_cam.get_camera_angles_char(camobj, _vec2_tmp)[0];
  376.         m_phy.set_character_rotation_h(obj, hor_angle /*+ Math.PI*/);
  377.     }
  378.     m_ctl.create_sensor_manifold(character, "FPS_CHARECTER_VR_ROT", m_ctl.CT_CONTINUOUS,
  379.                 [e_s], null, sensor_cb);
  380. }
  382. function remove_character_vr_rotate_sensor(character) {
  383.     m_ctl.remove_sensor_manifold(character, "FPS_CHARECTER_VR_ROT");
  384. }
  386. function check_vr_support() {
  387.     var support = m_hmd.check_browser_support() && !m_main.detect_mobile();
  388.     var device = m_input.get_device_by_type_element(m_input.DEVICE_HMD);
  389.     if (device)
  390.         support = support && m_input.get_value_param(device, m_input.HMD_WEBVR_TYPE) &
  391.                         m_input.HMD_WEBVR1;
  392.     return support;
  393. }
  395. function enable_camera_rotation(elem, character) {
  396.     if (check_vr_support()) {
  397.         register_hmd(elem, character);
  398.     }
  400.     enable_rotation(elem, character);
  401. }
  403. function enable_movements(elem, character, motion_cb, settings) {
  404.     if (m_main.detect_mobile()) {
  405.         var parent_elem = elem.parentElement ? elem.parentElement : elem;
  406.         create_mobile_controls(character, parent_elem);
  407.     }
  408.     var sm = init_character_states(character);
  409.     var move_state = {
  410.         left: 0,
  411.         right: 0,
  412.         forw: 0,
  413.         back: 0
  414.     }
  415.     var movestyle = -1;
  417.     var move_dir_cd = settings.move_dir_cd;
  419.     var check_character_look = function() {
  420.         if (_is_freezed) {
  421.             move_state.left = 0;
  422.             move_state.right = 0;
  423.             move_state.forw = 0;
  424.             move_state.back = 0;
  425.             return false;
  426.         }
  427.         return true;
  428.     }
  430.     var set_char_state = function(for_back, right_left) {
  431.         var curr_state = get_state_machine_state(sm).id;
  432.         if (!for_back && !right_left && curr_state != CS_CLIMB)
  433.             state_machine_switch_state(sm, CS_STAY);
  434.         else if (curr_state == CS_STAY) {
  435.             if (movestyle > 0)
  436.                 state_machine_switch_state(sm, CS_RUN);
  437.             else
  438.                 state_machine_switch_state(sm, CS_WALK);
  439.         }
  440.     }
  442.     var move_forward_cb = function(value) {
  443.         if (!check_character_look())
  444.             return;
  445.         var for_back_pr = move_state.forw + move_state.back;
  446.         move_state.forw = value;
  447.         var for_back = move_state.forw + move_state.back;
  448.         var right_left = move_state.left + move_state.right;
  449.         m_phy.set_character_move_dir(character, for_back, right_left);
  450.         if (motion_cb)
  451.             motion_cb(for_back, right_left);
  452.         set_char_state(for_back, right_left);
  453.         if (move_dir_cd && for_back_pr != for_back)
  454.             move_dir_cd(for_back, right_left, 0);
  455.     }
  456.     var move_backward_cb = function(value) {
  457.         if (!check_character_look())
  458.             return;
  459.         value = value > 0.0 ? 1.0 : value;
  460.         value = value < 0.0 ? -1.0 : value;
  461.         var for_back_pr = move_state.forw + move_state.back;
  462.         move_state.back = -value;
  463.         var for_back = move_state.forw + move_state.back;
  464.         var right_left = move_state.left + move_state.right;
  465.         m_phy.set_character_move_dir(character, for_back, right_left);
  466.         if (motion_cb)
  467.             motion_cb(for_back, right_left);
  468.         set_char_state(for_back, right_left);
  469.         if (move_dir_cd && for_back_pr != for_back)
  470.             move_dir_cd(for_back, right_left, 0);
  471.     }
  472.     var move_right_cb = function(value) {
  473.         if (!check_character_look())
  474.             return;
  475.         var curr_state = get_state_machine_state(sm).id;
  476.         if (curr_state == CS_CLIMB)
  477.             value = 0;
  478.         value = value > 0.0 ? 1.0 : value;
  479.         value = value < 0.0 ? -1.0 : value;
  480.         var right_left_pr = move_state.left + move_state.right;
  481.         move_state.right = -value;
  482.         var for_back = move_state.forw + move_state.back;
  483.         var right_left = move_state.left + move_state.right;
  484.         m_phy.set_character_move_dir(character, for_back, right_left);
  485.         if (motion_cb)
  486.             motion_cb(for_back, right_left);
  487.         set_char_state(for_back, right_left);
  488.         if (move_dir_cd && right_left_pr != right_left)
  489.             move_dir_cd(for_back, right_left, 0);
  490.     }
  491.     var move_left_cb = function(value) {
  492.         if (!check_character_look())
  493.             return;
  494.         var curr_state = get_state_machine_state(sm).id;
  495.         if (curr_state == CS_CLIMB)
  496.             value = 0;
  497.         var right_left_pr = move_state.left + move_state.right;
  498.         move_state.left = value;
  499.         var for_back = move_state.forw + move_state.back;
  500.         var right_left = move_state.left + move_state.right;
  501.         m_phy.set_character_move_dir(character, for_back, right_left);
  502.         if (motion_cb)
  503.             motion_cb(for_back, right_left);
  504.         set_char_state(for_back, right_left);
  505.         if (move_dir_cd && right_left_pr != right_left)
  506.             move_dir_cd(for_back, right_left, 0);
  507.     }
  509.     var jump_cb = function(value) {
  510.         if (!check_character_look())
  511.             return;
  512.         if (value > 0.0) {
  513.             m_phy.character_jump(character);
  514.             if (move_dir_cd)
  515.                 move_dir_cd(move_state.forw + move_state.back,
  516.                         move_state.left + move_state.right, 1);
  517.         }
  518.     }
  519.     var change_movestyle = function(value) {
  520.         movestyle = value;
  521.         if (Math.abs(move_state.forw + move_state.back) +
  522.                 Math.abs(move_state.left + move_state.right)) {
  523.             if (value > 0.0)
  524.                 state_machine_switch_state(sm, CS_RUN);
  525.             else
  526.                 state_machine_switch_state(sm, CS_WALK);
  527.             if (move_dir_cd)
  528.                 move_dir_cd(move_state.forw + move_state.back,
  529.                         move_state.left + move_state.right, 0);
  530.         } else
  531.             state_machine_switch_state(sm, CS_STAY);
  532.     }
  534.     var change_flystyle = function(value) {
  535.         if (value > 0.0) {
  536.             var state = get_state_machine_state(_character_sm).id;
  537.             if (state == CS_WALK || state == CS_STAY)
  538.                 state_machine_switch_state(sm, CS_FLY);
  539.             else
  540.                 state_machine_switch_state(sm, CS_WALK);
  541.         }
  542.     }
  543.     var forward_sens_arr = settings.forward_sens_arr;
  544.     var backward_sens_arr = settings.backward_sens_arr;
  545.     var right_sens_arr = settings.right_sens_arr;
  546.     var left_sens_arr = settings.left_sens_arr;
  547.     var jump_sens_arr = settings.jump_sens_arr;
  548.     var run_sens_arr = settings.run_sens_arr;
  549.     var fly_sens_arr = settings.fly_sens_arr;
  551.     bind_action(AT_PRESSED, forward_sens_arr, move_forward_cb);
  552.     bind_action(AT_PRESSED, backward_sens_arr, move_backward_cb);
  553.     bind_action(AT_PRESSED, right_sens_arr, move_right_cb);
  554.     bind_action(AT_PRESSED, left_sens_arr, move_left_cb);
  555.     bind_action(AT_PRESSED, jump_sens_arr, jump_cb);
  557.     bind_action(AT_CONTINUOUS, [m_input.GMPD_AXIS_0], move_right_cb);
  558.     bind_action(AT_CONTINUOUS, [m_input.GMPD_AXIS_1], move_backward_cb);
  560.     bind_action(AT_PRESSED, run_sens_arr, change_movestyle);
  561.     bind_action(AT_PRESSED, fly_sens_arr, change_flystyle);
  562. }
  564. function get_state_machine() {
  565.     if (!_character_sm)
  566.         _character_sm = {
  567.             nodes: [],
  568.             current_node: null,
  569.             lock: false,
  570.             last_state: null
  571.         };
  572.     return _character_sm;
  573. }
  575. function state_machine_add_state(state_machine, id, allowed_ids, call_switch,
  576.         call_before_switch, call_after_switch) {
  577.     state_machine.nodes.push({
  578.         id: id,
  579.         allowed_ids: allowed_ids,
  580.         call_switch: call_switch,
  581.         call_before_switch: call_before_switch,
  582.         call_after_switch: call_after_switch
  583.     });
  584. }
  586. function check_state_machine_validation(state_machine) {
  587.     var names = [];
  588.     for (var i = 0; i < state_machine.nodes; i++) {
  589.         var id = state_machine.nodes[i].id;
  590.         if (names.indexOf(id) >= 0)
  591.             return false;
  592.         else
  593.             names.push(id);
  594.     }
  595.     for (var i = 0; i < state_machine.nodes; i++) {
  596.         var node = state_machine.nodes[i];
  597.         for (var j = 0; j < node.allowed_ids.length; j++) {
  598.             if (names.indexOf(node.allowed_ids[j]) < 0)
  599.                 return false;
  600.         }
  601.     }
  602.     return true;
  603. }
  605. function get_state_machine_node(state_machine, node_id) {
  606.     var node = null;
  607.     for (var i = 0; i < state_machine.nodes.length; i++) {
  608.         if (state_machine.nodes[i].id == node_id) {
  609.             node = state_machine.nodes[i];
  610.             break;
  611.         }
  612.     }
  613.     return node;
  614. }
  616. function set_state_machine_start_node(state_machine, node_id) {
  617.     var node = get_state_machine_node(state_machine, node_id);
  618.     state_machine.current_node = node;
  619.     return node;
  620. }
  622. function get_state_machine_state(state_machine) {
  623.     return state_machine.current_node;
  624. }
  626. function set_state_machine_node_after_cb(state_machine, state_id, callback) {
  627.     var node = get_state_machine_node(state_machine, state_id);
  628.     node.call_after_switch = callback;
  629. }
  631. function set_state_machine_node_before_cb(state_machine, state_id, callback) {
  632.     var node = get_state_machine_node(state_machine, state_id);
  633.     node.call_before_switch = callback;
  634. }
  636. function state_machine_switch_state(state_machine, new_state_id) {
  638.     state_machine.last_state = new_state_id;
  639.     if (state_machine.lock) {
  640.         return false;
  641.     }
  642.     var cur_state = get_state_machine_state(state_machine);
  643.     var old_state_id = cur_state.id;
  644.     if (cur_state.allowed_ids.indexOf(new_state_id) >= 0) {
  645.         var before = true;
  646.         if (cur_state.call_before_switch) {
  647.             before = cur_state.call_before_switch(old_state_id, new_state_id)
  648.         }
  649.         if (before) {
  650.             set_state_machine_start_node(state_machine, new_state_id);
  651.             if (cur_state.call_switch)
  652.                 cur_state.call_switch(old_state_id, new_state_id);
  653.             if (cur_state.call_after_switch)
  654.                 cur_state.call_after_switch(old_state_id, new_state_id);
  655.             return true
  656.         }
  657.     }
  658.     return false
  659. }
  661. function init_character_states(character) {
  663.     var sm = get_state_machine();
  665.     var change_state_cb = function(old_state_id, new_state_id) {
  666.         switch(new_state_id) {
  667.         case CS_STAY:
  668.         case CS_WALK:
  669.             m_phy.set_character_move_type(character, m_phy.CM_WALK);
  670.             break;
  671.         case CS_RUN:
  672.             m_phy.set_character_move_type(character, m_phy.CM_RUN);
  673.             break;
  674.         case CS_FLY:
  675.             m_phy.set_character_move_type(character, m_phy.CM_FLY);
  676.             break;
  677.         case CS_CLIMB:
  678.             m_phy.set_character_move_type(character, m_phy.CM_CLIMB);
  679.             break;
  680.         };
  681.     }
  682.     state_machine_add_state(sm, CS_STAY, [CS_WALK, CS_FLY, CS_RUN, CS_CLIMB], change_state_cb, 
  683.             null, null);
  684.     state_machine_add_state(sm, CS_WALK, [CS_RUN, CS_FLY, CS_CLIMB, CS_STAY], change_state_cb, 
  685.             null, null);
  686.     state_machine_add_state(sm, CS_RUN, [CS_WALK, CS_FLY, CS_CLIMB, CS_STAY], change_state_cb, 
  687.             null, null);
  688.     state_machine_add_state(sm, CS_FLY, [CS_WALK], change_state_cb, 
  689.             null, null);
  690.     state_machine_add_state(sm, CS_CLIMB, [CS_WALK, CS_RUN, CS_STAY], change_state_cb, 
  691.             null, null);
  693.     check_state_machine_validation(sm);
  694.     set_state_machine_start_node(sm, CS_STAY);
  696.     return _character_sm;
  697. }
  699. function remove_devices_controls() {
  700.     for (var i = 0; i < _manifold_counter; i++)
  701.         m_ctl.remove_sensor_manifold(null, "FPS_USER_CONTROL_ACTION_"
  702.                 + i.toString());
  703. }
  705. function remove_plock_controls(character, elem) {
  706.     if (check_pointerlock(elem) && !m_main.detect_mobile()) {
  707.         if (_plock_cb.disable_cb)
  708.             _plock_cb.disable_cb(elem);
  709.         m_ctl.remove_sensor_manifold(character, "FPS_PLOCK");
  710.         m_ctl.remove_sensor_manifold(null, "FPS_ACTIVATE_PLOCK");
  711.     }
  712. }
  714. function remove_drag_controls(character, elem) {
  715.     if (!check_pointerlock(elem) || m_main.detect_mobile()) {
  716.         m_ctl.remove_sensor_manifold(character, "FPS_CAM_ROT");
  717.         m_ctl.remove_sensor_manifold(character, "FPS_DRAG_PRESS");
  718.         m_ctl.remove_sensor_manifold(character, "FPS_DRAG_MOVE");
  719.         m_ctl.remove_sensor_manifold(character, "FPS_SMOOTH_DRAG");
  720.     }
  721. }
  723. function remove_hmd_controls(character) {
  724.     if (check_vr_support())
  725.         m_ctl.remove_sensor_manifold(character, "FPS_CHARECTER_VR_ROT");
  726. }
  728. function remove_mobile_controls(character, elem) {
  729.     if (m_main.detect_mobile()) {
  730.         var forward_btn = document.getElementById(MOBILE_FORWARD_BTN_ID);
  731.         var backward_btn = document.getElementById(MOBILE_BACKWARD_BTN_ID);
  732.         if (forward_btn)
  733.             elem.removeChild(forward_btn);
  734.         if (backward_btn)
  735.             elem.removeChild(backward_btn);
  736.     }
  737. }
  738. function set_curr_gamepad_id(new_id) {
  739.     _curr_gamepad_id = new_id;
  740. }
  741. /**
  742.  * Character state defining that character is staying.
  743.  * @const {CharacterState} module:fps.CS_STAY
  744.  */
  745. exports.CS_STAY = CS_STAY;
  746. /**
  747.  * Character state defining that character is in walk-mode.
  748.  * @const {CharacterState} module:fps.CS_WALK
  749.  */
  750. exports.CS_WALK = CS_WALK;
  751. /**
  752.  * Character state defining that character is in run-mode.
  753.  * @const {CharacterState} module:fps.CS_RUN
  754.  */
  755. exports.CS_RUN = CS_RUN;
  756. /**
  757.  * Character state defining that character is in fly-mode.
  758.  * @const {CharacterState} module:fps.CS_FLY
  759.  */
  760. exports.CS_FLY = CS_FLY;
  761. /**
  762.  * Character state defining that character is in climb-mode.
  763.  * @const {CharacterState} module:fps.CS_CLIMB
  764.  */
  765. exports.CS_CLIMB = CS_CLIMB;
  767. /**
  768.  * An input type detecting a discrete user action, e.g. button press.
  769.  * @const module:fps.AT_PRESSED
  770.  */
  771. exports.AT_PRESSED = AT_PRESSED;
  772. /**
  773.  * An input type detecting a discrete user action, e.g. button release.
  774.  * @const module:fps.AT_RELEASED
  775.  */
  776. exports.AT_RELEASED = AT_RELEASED;
  777. /**
  778.  * An input type detecting a continuous user action,
  779.  * e.g. a held down button, mouse movement, gamepad stick tilt etc.
  780.  * @const module:fps.AT_CONTINUOUS
  781.  */
  782. exports.AT_CONTINUOUS = AT_CONTINUOUS;
  784. /**
  785.  * Bind action callback to user controls. This allows to set and define an additional
  786.  * action to an event and set the conditions to when and how the event happens.
  787.  * @method module:fps.bind_action
  788.  * @param {number} action_type Type of action
  789.  * @param {Array} action_controls Array of sensor types
  790.  * @param {Function} action_cb Function which applies logic
  791.  * @example var m_ctl = require("controls");
  792.  * var m_fps = require("fps");
  793.  * var m_input = require("input");
  794.  *
  795.  * var action_cb = function(value) {
  796.  *     console.log(value);
  797.  * };
  798.  *
  799.  * // bind custom callback to be executed after pressing the W key or one of the gamepad 
  800.  * // buttons or after clicking/touching the html element with the "forward_button_id" id
  801.  * m_fps.bind_action(m_fps.AT_PRESSED, [m_ctl.KEY_W, m_input.GMPD_BUTTON_12,
  802.  *          "forward_button_id"], action_cb);
  803.  */
  804. exports.bind_action = bind_action;
  805. function bind_action(action_type, action_controls, action_cb) {
  807.     if (!action_controls.length)
  808.         return;
  810.     var sensors = [];
  811.     for (var j = 0; j < action_controls.length; j++) {
  812.         if (typeof action_controls[j] == "number") {
  813.             if (action_controls[j] < GMPD_BTNS_OFFSET)
  814.                 sensors.push(m_ctl.create_keyboard_sensor(action_controls[j]));
  815.             else if (action_controls[j] < GMPD_AXIS_OFFSET) {
  816.                 sensors.push(m_ctl.create_gamepad_btn_sensor(action_controls[j],
  817.                         _curr_gamepad_id));
  818.             } else
  819.                 sensors.push(m_ctl.create_gamepad_axis_sensor(action_controls[j]));
  820.         } else if (typeof action_controls[j] == "string") {
  821.             var control_element = document.getElementById(action_controls[j]);
  822.             if (control_element) {
  823.                 sensors.push(m_ctl.create_touch_click_sensor(control_element));
  824.             } else
  825.                 m_print.error("Couldn't find element with " +
  826.                         action_controls[j] + " ID.");
  827.         }
  829.     }
  831.     var logic_func = function(s) {
  832.         return false;
  833.     }
  834.     var type = m_ctl.CT_SHOT;
  835.     var manifold_cb = function(obj, id, pulse, sens_num) {}
  837.     switch(action_type) {
  838.     case AT_PRESSED:
  839.         type = m_ctl.CT_TRIGGER;
  840.         logic_func = function(s) {
  841.             for (var i = 0; i < s.length; i++)
  842.                 if (s[i])
  843.                     return true;
  844.                 return false;
  845.         }
  846.         manifold_cb = function(obj, id, pulse, sens_num) {
  847.             if (pulse > 0)
  848.                 action_cb(1.0);
  849.             else
  850.                 action_cb(0.0);
  851.         }
  852.         break;
  853.     case AT_RELEASED:
  854.         type = m_ctl.CT_TRIGGER;
  855.         logic_func = function(s) {
  856.             for (var i = 0; i < s.length; i++)
  857.                 if (s[i])
  858.                     return true;
  859.                 return false;
  860.         }
  861.         manifold_cb = function(obj, id, pulse, sens_num) {
  862.             if (pulse < 0)
  863.                 action_cb(1.0);
  864.             else
  865.                 action_cb(0.0);
  866.         }
  867.         break;
  868.     case AT_CONTINUOUS:
  869.         type = m_ctl.CT_CONTINUOUS;
  870.         logic_func = function(s) {
  871.             for (var i = 0; i < s.length; i++)
  872.                 if (Math.abs(s[i]) > AXIS_THRESHOLD)
  873.                     return true;
  874.                 return false;
  875.         }
  876.         manifold_cb = function(obj, id, pulse, sens_num) {
  877.             if (pulse > 0) {
  878.                 for (var i = 0; i < sens_num; i++) {
  879.                     var value = m_ctl.get_sensor_value(obj, id, i);
  880.                     if (Math.abs(value) > AXIS_THRESHOLD) {
  881.                         action_cb(value);
  882.                         return;
  883.                     }
  884.                 }
  885.             } else
  886.                 action_cb(0.0);
  887.         }
  888.         break;
  889.     };
  891.     var action_id = "FPS_USER_CONTROL_ACTION_" + _manifold_counter.toString();
  892.     var sensors_number = sensors.length;
  893.     m_ctl.create_sensor_manifold(null, action_id, type,
  894.             sensors, logic_func, manifold_cb, sensors_number);
  895.     _manifold_counter++;
  896. }
  897. /**
  898.  * Enable FPS controls. This sets keyboard, gamepad and mouse controls.
  899.  * VR is also plug-and-play ready.
  900.  * @method module:fps.enable_fps_controls
  901.  * @param {Object}   [options={}] Initialization options.
  902.  * @param {Object3D}   [options.character=The result of the {@link module:scenes.get_first_character|get_first_character()} method call] Character.
  903.  * @param {HTMLElement} [options.element=The result of the {@link module:container.get_canvas|get_canvas()} method call] HTML element to add event listeners to.
  904.  * @param {CharMotionCallback}  [options.motion_cb=null] Motion callback function
  905.  * @param {number}  [options.gamepad_id=0] Connected gamepad ID.
  906.  * @param {number[]}  [options.forward_sens=[{@link module:controls.KEY_W|KEY_W}, {@link module:input.GMPD_BUTTON_12|GMPD_BUTTON_12}]] Array of sensor types used for forward motion.
  907.  * @param {number[]}  [options.backward_sens=[{@link module:controls.KEY_S|KEY_S}, {@link module:input.GMPD_BUTTON_13|GMPD_BUTTON_13}]] Array of sensor types used for backward motion.
  908.  * @param {number[]}  [options.right_sens=[{@link module:controls.KEY_D|KEY_D}, {@link module:input.GMPD_BUTTON_15|GMPD_BUTTON_15}]] Array of sensor types used for right motion.
  909.  * @param {number[]}  [options.left_sens=[{@link module:controls.KEY_A|KEY_A}, {@link module:input.GMPD_BUTTON_14|GMPD_BUTTON_14}]] Array of sensor types used for left motion.
  910.  * @param {number[]}  [options.jump_sens=[{@link module:controls.KEY_SPACE|KEY_SPACE}, {@link module:input.GMPD_BUTTON_1|GMPD_BUTTON_1}]] Array of sensor types used for jumping.
  911.  * @param {number[]}  [options.fly_sens=[{@link module:controls.KEY_SHIFT|KEY_SHIFT}, {@link module:input.GMPD_BUTTON_7|GMPD_BUTTON_7}]] Array of sensor types used for flying.
  912.  * @param {CharRotationCallback}  [options.rotation_cb] Callback for camera rotation. If not specified, the default one will be used.
  913.  * @param {boolean} [options.lock_camera=false] Parent camera to the character
  914.  * @cc_externs character element gamepad_id
  915.  * @cc_externs forward_sens backward_sens right_sens left_sens
  916.  * @cc_externs report_init_failure pause_invisible key_pause_enabled
  917.  * @cc_externs jump_sens fly_sens rotation_cb lock_camera
  918.  * @cc_externs move_dir_cd motion_cb
  919.  * @example var m_fps = require("fps");
  920.  *
  921.  * var character = m_scene.get_first_character();
  922.  *
  923.  * var move_cb = function(forw_back, right_left) {
  924.  *     console.log(forw_back, right_left);  
  925.  * }
  926.  *
  927.  * m_fps.enable_fps_controls(character, null, move_cb);
  928.  */
  929. exports.enable_fps_controls = function(options) {
  930.     options = options || {lock_camera : true};
  931.     var character = options.character || m_scs.get_first_character();
  932.     if (!character)
  933.         return;
  934.     var elem = options.element || m_cont.get_canvas();
  935.     var motion_cb = options.motion_cb || null;
  936.     set_curr_gamepad_id(options.gamepad_id || 0);
  938.     var forward_sens_arr = options.forward_sens || [m_ctl.KEY_W, m_input.GMPD_BUTTON_12];
  939.     var backward_sens_arr = options.backward_sens || [m_ctl.KEY_S, m_input.GMPD_BUTTON_13];
  940.     var right_sens_arr = options.right_sens || [m_ctl.KEY_D, m_input.GMPD_BUTTON_15];
  941.     var left_sens_arr = options.left_sens || [m_ctl.KEY_A, m_input.GMPD_BUTTON_14];
  942.     var jump_sens_arr = options.jump_sens || [m_ctl.KEY_SPACE, m_input.GMPD_BUTTON_1];
  943.     var run_sens_arr = options.run_sens || [m_ctl.KEY_SHIFT, m_input.GMPD_BUTTON_7];
  944.     var fly_sens_arr = options.fly_sens || [];
  946.     if (m_main.detect_mobile()) {
  947.         forward_sens_arr.push(MOBILE_FORWARD_BTN_ID);
  948.         backward_sens_arr.push(MOBILE_BACKWARD_BTN_ID);
  949.     }
  951.     var move_dir_cd = options.move_dir_cd || null;
  953.     var configs = {
  954.         forward_sens_arr : forward_sens_arr,
  955.         backward_sens_arr : backward_sens_arr,
  956.         right_sens_arr : right_sens_arr,
  957.         left_sens_arr : left_sens_arr,
  958.         jump_sens_arr : jump_sens_arr,
  959.         run_sens_arr : run_sens_arr,
  960.         fly_sens_arr : fly_sens_arr,
  961.         move_dir_cd: move_dir_cd
  962.     };
  963.     _rotation_cb = options.rotation_cb || default_rotation_cb;
  964.     var lock_camera = typeof options.lock_camera != "undefined" ? options.lock_camera : true;
  965.     set_characters_camera(character, lock_camera);
  966.     enable_camera_rotation(elem, character);
  967.     enable_movements(elem, character, motion_cb, configs);
  968. }
  969. /**
  970.  * Disable FPS controls.
  971.  * @method module:fps.disable_fps_controls
  972.  * @param {Object3D} [character=The result of the {@link module:scenes.get_first_character|get_first_character()} method call] Character
  973.  * @param {HTMLElement} [elem=Canvas container element] HTML element to add event listeners to
  974.  * @example var m_fps = require("fps");
  975.  *
  976.  * m_fps.disable_fps_controls();
  977.  */
  978. exports.disable_fps_controls = function(character, elem) {
  979.     character = character || m_scs.get_first_character();
  980.     elem = elem || m_cont.get_container();
  982.     if (!character)
  983.         return;
  985.     remove_devices_controls();
  986.     remove_plock_controls(character, elem);
  987.     remove_drag_controls(character, elem);
  988.     remove_hmd_controls(character);
  989.     remove_mobile_controls(character, elem);
  990. }
  991. /**
  992.  * Set character state changing callback function.
  993.  * @method module:fps.set_state_change_cb
  994.  * @param {number} state_id State ID
  995.  * @param {ChangeStateCallback} callback Callback function
  996.  * @example var m_fps = require("fps");
  997.  *
  998.  * var state_changing_cb = function(old_state_id, new_state_id) {
  999.  *     console.log(old_state_id, new_state_id);  
  1000.  * }
  1001.  *
  1002.  * m_fps.set_state_change_cb(m_fps.CS_WALK, state_changing_cb);
  1003.  */
  1004. exports.set_state_change_cb = function(state_id, callback) {
  1005.     var sm = _character_sm;
  1006.     set_state_machine_node_after_cb(sm, state_id, callback);
  1007. }
  1008. /**
  1009.  * Set character's camera smooth behavior
  1010.  * @method module:fps.set_cam_smooth_factor
  1011.  * @param {number} value Smooth factor
  1012.  * @example var m_fps = require("fps");
  1013.  *
  1014.  * m_fps.set_cam_smooth_factor(0.2);
  1015.  */
  1016. exports.set_cam_smooth_factor = function(value) {
  1017.     m_ctl.set_plock_smooth_factor(value);
  1018.     set_smooth_factor(value);
  1019. }
  1020. /**
  1021.  * Set character's camera smooth behavior
  1022.  * @method module:fps.get_cam_smooth_factor
  1023.  * @example var m_fps = require("fps");
  1024.  *
  1025.  * var smooth_factor = m_fps.get_cam_smooth_factor();
  1026.  */
  1027. exports.get_cam_smooth_factor = function() {
  1028.     return _smooth_factor;
  1029. }
  1030. /**
  1031.  * Set character's camera mouse sensitivity
  1032.  * @method module:fps.set_cam_sensitivity
  1033.  * @param {number} value Sensitivity
  1034.  * @example var m_fps = require("fps");
  1035.  *
  1036.  * m_fps.set_cam_sensitivity(80);
  1037.  */
  1038. exports.set_cam_sensitivity = set_cam_sensitivity;
  1039. function set_cam_sensitivity(value) {
  1040.     _fps_camera_mult = value / MULT_SCALE;
  1041. }
  1042. /**
  1043.  * Get character's camera mouse sensitivity
  1044.  * @method module:fps.get_cam_sensitivity
  1045.  * @example var m_fps = require("fps");
  1046.  *
  1047.  * var sens = m_fps.get_cam_sensitivity();
  1048.  */
  1049. exports.get_cam_sensitivity = get_cam_sensitivity;
  1050. function get_cam_sensitivity() {
  1051.     return _fps_camera_mult * MULT_SCALE;
  1052. }
  1053. /**
  1054.  * Set pointerlock callback function, which is called when pointerlock is enabled
  1055.  * @method module:fps.set_plock_enable_cb
  1056.  * @param {PlockCallback} callback Callback function
  1057.  * @example var m_fps = require("fps");
  1058.  * var cb = function(element) {
  1059.  *     console.log("pointerlock is enabled");  
  1060.  * }
  1061.  *
  1062.  * m_fps.set_plock_enable_cb(cb);
  1063.  */
  1064. exports.set_plock_enable_cb = function(callback) {
  1065.     _plock_cb.enable_cb = callback;
  1066. }
  1067. /**
  1068.  * Set pointerlock callback function, which is called when pointerlock is disabled
  1069.  * @method module:fps.set_plock_disable_cb
  1070.  * @param {PlockCallback} callback Callback function
  1071.  * @example var m_fps = require("fps");
  1072.  *
  1073.  * var cb = function(element) {
  1074.  *     console.log("pointerlock is disabled");  
  1075.  * }
  1076.  *
  1077.  * m_fps.set_plock_disable_cb(cb);
  1078.  */
  1079. exports.set_plock_disable_cb = function(callback) {
  1080.     _plock_cb.disable_cb = callback;
  1081. }
  1082. /**
  1083.  * Get character's current state.
  1084.  * @method module:fps.get_character_state
  1085.  * @returns {CharacterState} Character's current state
  1086.  * @example var m_fps = require("fps");
  1087.  *
  1088.  * var curr_state = m_fps.get_character_state();
  1089.  *
  1090.  * if (curr_state == m_fps.CS_RUN) 
  1091.  *     console.log("Character is running");
  1092.  */
  1093. exports.get_character_state = function() {
  1094.     return get_state_machine_state(_character_sm).id;
  1095. }
  1096. /**
  1097.  * Add new character's state.
  1098.  * @method module:fps.add_new_state
  1099.  * @returns {CharacterState} Character's new state
  1100.  * @example var m_fps = require("fps");
  1101.  *
  1102.  * var new_state = m_fps.add_new_state();
  1103.  */
  1104. exports.add_new_state = function() {
  1105.     return _state_counter++;
  1106. }
  1107. /**
  1108.  * Add new character's state to its state machine.
  1109.  * @method module:fps.add_state
  1110.  * @param {CharacterState} new_state Character's new state
  1111.  * @param {CharacterState[]} enabled_transitions Enabled transitions to another states
  1112.  * @param {ChangeStateCallback} change_state_cb Callback function
  1113.  * @example var m_fps = require("fps");
  1114.  *
  1115.  * var new_state = m_fps.add_new_state();
  1116.  * var state_changing_cb = function(old_state_id, new_state_id) {
  1117.  *     console.log(old_state_id, new_state_id);  
  1118.  * }
  1119.  * m_fps.add_state(new_state, [m_fps.CS_WALK, m_fps.CS_RUN], state_changing_cb);
  1120.  */
  1121. exports.add_state = function(new_state, enabled_transitions, change_state_cb) {
  1122.     var sm = get_state_machine();
  1123.     state_machine_add_state(sm, new_state, enabled_transitions, change_state_cb, 
  1124.             null, null);
  1125.     if (!check_state_machine_validation(sm))
  1126.         m_print.error("Incorrect state machine.");
  1127. }
  1128. /**
  1129.  * Switch character's state.
  1130.  * @method module:fps.switch_state
  1131.  * @param {CharacterState} state Character's state
  1132.  * @example var m_fps = require("fps");
  1133.  *
  1134.  * m_fps.switch_state(m_fps.CS_WALK);
  1135.  */
  1136. exports.switch_state = function(state) {
  1137.     var sm = get_state_machine();
  1138.     state_machine_switch_state(sm, state);
  1139. }
  1140. /**
  1141.  * Lock character's state changing.
  1142.  * @method module:fps.lock_character
  1143.  * @example var m_fps = require("fps");
  1144.  *
  1145.  * m_fps.lock_character();
  1146.  */
  1147. exports.lock_character = function() {
  1148.     var sm = get_state_machine();
  1149.     sm.lock = true;
  1150. }
  1151. /**
  1152.  * Unlock character's state changing.
  1153.  * @method module:fps.unlock_character
  1154.  * @example var m_fps = require("fps");
  1155.  *
  1156.  * m_fps.unlock_character();
  1157.  */
  1158. exports.unlock_character = function() {
  1159.     var sm = get_state_machine();
  1160.     sm.lock = false;
  1161. }
  1162. /**
  1163.  * Check if character's state changing is locked.
  1164.  * @method module:fps.is_character_locked
  1165.  * @example var m_fps = require("fps");
  1166.  *
  1167.  * if (m_fps.is_character_locked())
  1168.  *     console.log("character is locked");
  1169.  */
  1170. exports.is_character_locked = function() {
  1171.     var sm = get_state_machine();
  1172.     return sm.lock;
  1173. }
  1174. /**
  1175.  * Set character rotation callback.
  1176.  * @method module:fps.set_rotation_cb
  1177.  * @param {CharRotationCallback} rotation_cb Character's rotation callback
  1178.  * @example var m_fps = require("fps");
  1179.  *
  1180.  * m_fps.set_rotation_cb(function(char, rot_x, rot_y) {});
  1181.  */
  1182. exports.set_rotation_cb = function(rotation_cb) {
  1183.     if (!rotation_cb)
  1184.         _rotation_cb = default_rotation_cb;
  1185.     else
  1186.         _rotation_cb = rotation_cb;
  1187. }
  1188. /**
  1189.  * Freeze character's movements.
  1190.  * @method module:fps.freeze_movements
  1191.  * @example var m_fps = require("fps");
  1192.  *
  1193.  * m_fps.freeze_movements();
  1194.  */
  1195. exports.freeze_movements = function() {
  1196.     _is_freezed = true;
  1197. }
  1198. /**
  1199.  * Unfreeze character's movements.
  1200.  * @method module:fps.unfreeze_movements
  1201.  * @example var m_fps = require("fps");
  1202.  *
  1203.  * m_fps.unfreeze_movements();
  1204.  */
  1205. exports.unfreeze_movements = function() {
  1206.     _is_freezed = false;
  1207. }
  1209. };
  1211. var fps_factory = register("fps", FPS);
  1213. export default fps_factory;