Source: addons/app.js

  1. import register from "../util/register.js";
  2. import m_cam_fact from "../extern/camera.js";
  3. import m_cfg_fact from "../extern/config.js";
  4. import m_cons_fact from "../extern/constraints.js";
  5. import m_cont_fact from "../extern/container.js";
  6. import m_ctl_fact from "../extern/controls.js";
  7. import m_data_fact from "../extern/data.js";
  8. import m_dbg_fact from "../extern/debug.js";
  9. import m_input_fact from "../extern/input.js";
  10. import m_main_fact from "../extern/main.js";
  11. import m_phy_fact from "../extern/physics.js";
  12. import m_print_fact from "../intern/print.js";
  13. import m_screen_fact from "../extern/screen.js";
  14. import m_scs_fact from "../extern/scenes.js";
  15. import m_trans_fact from "../extern/transform.js";
  16. import m_util_fact from "../extern/util.js";
  17. import * as m_vec3 from "../libs/gl_matrix/vec3.js";
  19. /**
  20.  * Application add-on.
  21.  * Provides generic routines for the engine's initialization, UI and I/O.
  22.  * @module app
  23.  * @local AppInitCallback
  24.  * @local AnimFinishCallback
  25.  * @local QueueObject
  26.  */
  28. function App(ns, exports) {
  30. var m_cam    = m_cam_fact(ns);
  31. var m_cfg    = m_cfg_fact(ns);
  32. var m_cons   = m_cons_fact(ns);
  33. var m_cont   = m_cont_fact(ns);
  34. var m_ctl    = m_ctl_fact(ns);
  35. var m_data   = m_data_fact(ns);
  36. var m_dbg    = m_dbg_fact(ns);
  37. var m_input  = m_input_fact(ns);
  38. var m_main   = m_main_fact(ns);
  39. var m_phy    = m_phy_fact(ns);
  40. var m_print  = m_print_fact(ns);
  41. var m_screen = m_screen_fact(ns);
  42. var m_scs    = m_scs_fact(ns);
  43. var m_trans  = m_trans_fact(ns);
  44. var m_util   = m_util_fact(ns);
  46. // Constants used for the target camera
  47. var TARGET_KEY_ZOOM_POW1     = 1.0;
  48. var TARGET_KEY_ZOOM_POW2     = 0.15;
  49. var TARGET_TOUCH_ZOOM_FACTOR = 0.03;
  51. // Constants used for the eye camera
  52. var EYE_KEY_TRANS_FACTOR   = 5.0;
  53. var EYE_ROTATION_DECREMENT = 0.5;
  55. // Constants used for both target and eye camera
  56. var TARGET_EYE_MOUSE_ROT_MULT_PX = 0.003;
  57. var TARGET_EYE_MOUSE_PAN_MULT_PX = 0.00075;
  58. var TARGET_EYE_TOUCH_ROT_MULT_PX = 0.003;
  59. var TARGET_EYE_TOUCH_PAN_MULT_PX = 0.00075;
  60. var TARGET_EYE_KEY_ROT_FACTOR    = 0.75;
  62. // Constants used for the hover camera
  63. var HOVER_MOUSE_PAN_MULT_PX        = 0.003;
  64. var HOVER_MOUSE_ROT_MULT_PX        = 0.00075;
  65. var HOVER_TOUCH_PAN_MULT_PX        = 0.003;
  66. var HOVER_TOUCH_ROT_MULT_PX        = 0.003;
  67. var HOVER_KEY_TRANS_FACTOR         = 0.5;
  68. var HOVER_KEY_ZOOM_FACTOR          = 30.0;
  69. var HOVER_MOUSE_TOUCH_TRANS_FACTOR = 0.2;
  70. var HOVER_MOUSE_ZOOM_FACTOR        = 2.0;
  71. var HOVER_TOUCH_ZOOM_FACTOR        = 2.0;
  72. var HOVER_ZOOM_FACTOR_MIN          = 2.0;
  73. var HOVER_SPEED_MIN                = 1.0;
  76. var _smooth_factor = 1;
  77. // Constants used for camera smoothing
  78. var CAM_SMOOTH_ZOOM_MOUSE      = 0.1;
  79. var CAM_SMOOTH_ZOOM_TOUCH      = 0.15;
  80. var CAM_SMOOTH_ROT_TRANS_MOUSE = 0.08;
  81. var CAM_SMOOTH_ROT_TRANS_TOUCH = 0.12;
  83. // Constants used for camera physics
  84. var CHAR_HEAD_POSITION          = 0.5;
  85. var CAM_COLL_DELTA              = 0.25
  87. // NOTE: EPSILON_DELTA << EPSILON_DISTANCE to prevent camera freezing near pivot
  88. var EPSILON_DISTANCE = 0.001;
  89. var EPSILON_DELTA    = 0.00001;
  91. var FRAME_WAITING_PER = 10;
  93. var AXIS_THRESHOLD = 0.1;
  95. var TRANS_GMPD_KOEF = 0.002;
  96. var ZOOM_GMPD_KOEF = 0.05;
  98. var LOW_BANDWIDTH_LIMIT = 1.5;
  100. // Cached HTML elements
  101. var _fps_logger_elem = null;
  103. // Global flags used for re-initializing of application camera controls
  104. // (which should be done after switching camera type)
  105. var _disable_default_pivot   = false;
  106. var _disable_letter_controls = false;
  107. var _disable_zoom            = false;
  108. var _element                 = null;
  109. var _allow_element_exit      = false;
  110. var _disable_gamepad_controls = false;
  112. // Cached arrays
  113. var _vec2_tmp  = new Float32Array(2);
  114. var _vec2_tmp2 = new Float32Array(2);
  115. var _vec3_tmp  = new Float32Array(3);
  116. var _vec3_tmp2 = new Float32Array(3);
  117. var _quat4_tmp = new Float32Array(4);
  118. var _velocity_tmp = {};
  120. var _limits_tmp = {};
  122. /**
  123.  * Application initialization callback.
  124.  * @callback AppInitCallback
  125.  * @param {HTMLElement} canvas Initialized canvas element.
  126.  * @param {boolean} success Success flag.
  127.  */
  129. /**
  130.  * Initialize the engine.
  131.  * The "options" object may be extended by adding properties from the engine's
  132.  * configuration (see {@link module:config|config} module).
  133.  * In that case they will be applied before engine initialization.
  134.  * @param {Object}   [options={}] Initialization options.
  135.  * @param {string}   [options.canvas_container_id=null] Canvas container ID.
  136.  * @param {AppInitCallback} [options.callback=function(){}] Initialization callback.
  137.  * @param {string[]}  [options.error_purge_elements=null] Array of IDs of HTML 
  138.  * elements to be removed in case of initialization error.
  139.  * @param {boolean}  [options.show_hud_debug_info=false] Show HUD with
  140.  * developer info.
  141.  * @param {boolean}  [options.show_fps=false] Show FPS counter.
  142.  * @param {string}   [options.fps_elem_id=null] Custom fps counter id.
  143.  * @param {string}   [options.fps_wrapper_id=null] Show FPS wrapper with
  144.  * current id.
  145.  * @param {boolean}  [options.report_init_failure=true] Show elements with info
  146.  * about init failure
  147.  * @param {boolean}  [options.pause_invisible=true] Pause engine simulation if
  148.  * page is not visible (in other tab or minimized).
  149.  * @param {boolean}  [options.key_pause_enabled=true] Enable key pause
  150.  * @param {boolean}  [options.autoresize=false] Automatically resize canvas to
  151.  * match the size of container element.
  152.  * @param {number}  [options.force_container_ratio=0] Automatically resize
  153.  * canvas container height, based on its width and passed ratio value.
  154.  * @param {boolean} [options.min_capabilities=false] Set min capability mode
  155.  * @param {boolean} [options.debug_loading=false] Print loading info into the console
  156.  * @cc_externs canvas_container_id callback show_hud_debug_info
  157.  * @cc_externs sfx_mix_mode show_fps fps_elem_id error_purge_elements
  158.  * @cc_externs report_init_failure pause_invisible key_pause_enabled
  159.  * @cc_externs alpha alpha_sort_threshold assets_dds_available assets_pvr_available
  160.  * @cc_externs assets_min50_available quality fps_wrapper_id
  161.  * @cc_externs console_verbose physics_enabled autoresize track_container_position
  162.  * @cc_externs force_container_ratio from to elem prop cb duration opt_prefix
  163.  * @cc_externs opt_suffix min_capabilities srgb_type debug_loading
  164.  */
  166. exports.init = function(options) {
  167.     options = options || {};
  169.     var autoresize = false;
  170.     var canvas_container_id = null;
  171.     var callback = function() {};
  172.     var error_purge_elements = null;
  173.     var fps_elem_id = null;
  174.     var force_container_ratio = 0;
  175.     var fps_wrapper_id = null;
  176.     var key_pause_enabled = true;
  177.     var min_capabilities = false;
  178.     var pause_invisible = true;
  179.     var report_init_failure = true;
  180.     var sfx_mix_mode = false;
  181.     var show_fps = false;
  182.     var show_hud_debug_info = false;
  183.     var track_container_position = false;
  184.     var quality = m_cfg.get("quality");
  186.     for (var opt in options) {
  187.         switch (opt) {
  188.         case "canvas_container_id":
  189.             canvas_container_id = options.canvas_container_id;
  190.             break;
  191.         case "callback":
  192.             callback = options.callback;
  193.             break;
  194.         case "autoresize":
  195.             autoresize = options.autoresize;
  196.             break;
  197.         case "show_hud_debug_info":
  198.             show_hud_debug_info = options.show_hud_debug_info;
  199.             break;
  200.         case "sfx_mix_mode":
  201.             sfx_mix_mode = options.sfx_mix_mode;
  202.             break;
  203.         case "show_fps":
  204.             show_fps = options.show_fps;
  205.             break;
  206.         case "track_container_position":
  207.             track_container_position = options.track_container_position;
  208.             m_print.error_once("track_container_position deprecated. " +
  209.                     "Not needed anymore. Use the container.get_coords_target_space method.");
  210.             break;
  211.         case "fps_wrapper_id":
  212.             fps_wrapper_id = options.fps_wrapper_id;
  213.             break;
  214.         case "fps_elem_id":
  215.             fps_elem_id = options.fps_elem_id;
  216.             break;
  217.         case "error_purge_elements":
  218.             error_purge_elements = options.error_purge_elements;
  219.             break;
  220.         case "report_init_failure":
  221.             report_init_failure = options.report_init_failure;
  222.             break;
  223.         case "pause_invisible":
  224.             pause_invisible = options.pause_invisible;
  225.             break;
  226.         case "key_pause_enabled":
  227.             key_pause_enabled = options.key_pause_enabled;
  228.             break;
  229.         case "force_container_ratio":
  230.             force_container_ratio = options.force_container_ratio;
  231.             break;
  232.         case "min_capabilities":
  233.             min_capabilities = options.min_capabilities;
  234.             break;
  235.         case "quality":
  236.             quality = options.quality;
  237.             break;
  238.         default:
  239.             m_cfg.set(opt, options[opt]);
  240.             break;
  241.         }
  242.     }
  244.     if (quality != m_cfg.P_AUTO)
  245.         m_cfg.set("quality", quality);
  247.     var on_key_pause = function(e) {
  248.         if (e.keyCode == m_ctl.KEY_P) {
  249.             if (m_main.is_paused())
  250.                 m_main.resume();
  251.             else
  252.                 m_main.pause();
  253.         }
  254.     }
  256.     if (key_pause_enabled)
  257.         document.addEventListener("keydown", on_key_pause, false);
  259.     m_cfg.set("show_hud_debug_info", show_hud_debug_info);
  260.     m_cfg.set("sfx_mix_mode", sfx_mix_mode);
  262.     var init_hud_canvas = show_hud_debug_info || sfx_mix_mode || null;
  264.     var onload_cb = function() {
  265.         var init_ok = setup_canvas(canvas_container_id, init_hud_canvas,
  266.                 report_init_failure, error_purge_elements);
  268.         var canvas_elem = m_cont.get_canvas();
  270.         if (!init_ok) {
  271.             callback(canvas_elem, false);
  273.             return;
  274.         }
  276.         var canvas_container_elem = m_cont.get_container();
  278.         m_cont.resize_to_container();
  280.         if (show_fps) {
  281.             create_fps_logger_elem(fps_elem_id, fps_wrapper_id);
  282.             m_main.set_fps_callback(fps_callback);
  283.         }
  285.         if (pause_invisible) {
  286.             handle_page_visibility();
  287.             handle_position_visibility();
  288.         }
  290.         if (force_container_ratio) {
  291.             m_main.append_loop_cb(function() {
  292.                 canvas_container_elem.style.height =
  293.                     canvas_container_elem.clientWidth / force_container_ratio + "px";
  294.             });
  295.         }
  297.         if (autoresize)
  298.             m_main.append_loop_cb(function() {
  299.                 m_cont.resize_to_container();
  300.             });
  302.         if (track_container_position) {
  303.             m_main.append_loop_cb(function() {
  304.                 m_cont.force_offsets_updating();
  305.             });
  306.         }
  308.         if (min_capabilities)
  309.             m_cfg.reset_limits();
  311.         if (quality == m_cfg.P_AUTO) {
  312.             m_dbg.test_performance(function(time, bw) {
  313.                 if (time == 0) {
  314.                     m_print.log("QUALITY TEST RESULT: UNSUPPORTED, using HIGH");
  315.                     m_cfg.apply_quality(m_cfg.P_HIGH);
  316.                 } else if (bw < LOW_BANDWIDTH_LIMIT) {
  317.                     m_print.log("QUALITY TEST RESULT: LOW (" + bw.toFixed(1) + " GB/s)");
  318.                     m_cfg.apply_quality(m_cfg.P_LOW);
  319.                 } else {
  320.                     m_print.log("QUALITY TEST RESULT: HIGH (" + bw.toFixed(1) + " GB/s)");
  321.                     m_cfg.apply_quality(m_cfg.P_HIGH);
  322.                 }
  324.                 callback(canvas_elem, true);
  325.             });
  326.         } else
  327.             callback(canvas_elem, true);
  328.     };
  330.     var onunload_cb = function() {
  331.         m_data.cleanup();
  332.     };
  334.     if (document.readyState == "complete")
  335.         window.setTimeout(onload_cb, 0);
  336.     else
  337.         window.addEventListener("load", onload_cb, false);
  339.     window.addEventListener("unload", onunload_cb, false);
  340. }
  342. function handle_page_visibility() {
  344.     var was_paused = m_main.is_paused();
  346.     var visibility_change = function() {
  347.         if (document.hidden) {
  348.             was_paused = m_main.is_paused();
  349.             m_main.pause();
  350.         } else if (!was_paused)
  351.             m_main.resume();
  352.     }
  353.     document.addEventListener("visibilitychange", visibility_change, false);
  354. }
  356. function handle_position_visibility() {
  357.     var frame_counter = 0;
  358.     var container = m_cont.get_container();
  359.     var was_paused = m_main.is_paused();
  360.     var check_paused = true;
  362.     var visibility_change = function() {
  363.         if (frame_counter % FRAME_WAITING_PER == 0) {
  364.             var coords = container.getBoundingClientRect();
  365.             if (coords.top > window.innerHeight
  366.                     || coords.bottom < 0) {
  367.                 if (check_paused)
  368.                     was_paused = m_main.is_paused();
  369.                 m_main.pause();
  370.                 check_paused = false;
  371.             } else if (!was_paused && !check_paused) {
  372.                 m_main.resume();
  373.                 check_paused = true;
  374.             }
  375.         }
  376.         frame_counter++;
  377.     }
  378.     m_main.append_loop_cb(visibility_change);
  379. }
  381. function setup_canvas(canvas_container_id, init_hud_canvas,
  382.         report_init_failure, purge_elements) {
  384.     var canvas_elem = document.createElement("canvas");
  385.     var append_to = document.getElementById(canvas_container_id);
  387.     if (!append_to) {
  389.         m_print.error("Warning: canvas container \"" + canvas_container_id +
  390.             "\" not found, appending to body");
  391.         append_to = document.body;
  392.     }
  394.     canvas_elem.style.position = "absolute";
  395.     canvas_elem.style.left = 0;
  396.     canvas_elem.style.top = 0;
  397.     canvas_elem.style.width = append_to.offsetWidth + "px";
  398.     canvas_elem.style.height = append_to.offsetHeight + "px";
  399.     canvas_elem.width = append_to.offsetWidth * window.devicePixelRatio;
  400.     canvas_elem.height = append_to.offsetHeight * window.devicePixelRatio;
  402.     if (init_hud_canvas) {
  403.         var canvas_elem_hud = document.createElement("canvas");
  404.         // NOTE: pointer-events only for Chrome, Firefox, Safari
  405.         canvas_elem_hud.style.position = "absolute";
  406.         canvas_elem.style.left = 0;
  407.         canvas_elem.style.top = 0;
  408.         canvas_elem_hud.style.pointerEvents = "none";
  409.     } else
  410.         var canvas_elem_hud = null;
  412.     append_to.appendChild(canvas_elem);
  414.     if (!m_main.init(canvas_elem, canvas_elem_hud)) {
  415.         if (report_init_failure)
  416.             report_app_error("Browser could not initialize WebGL", "For more info visit",
  417.                     "https://www.blend4web.com/doc/en/problems_and_solutions.html#problems-upon-startup", purge_elements);
  418.         return false;
  419.     }
  421.     if (canvas_elem_hud)
  422.         m_cont.insert_to_container(canvas_elem_hud, "LAST");
  424.     return true;
  425. }
  427. function create_fps_logger_elem(fps_elem_id, fps_wrapper_id) {
  428.     if (fps_elem_id) {
  429.         if (fps_wrapper_id)
  430.             document.getElementById(fps_wrapper_id).style.display = "block";
  432.         _fps_logger_elem = document.getElementById(fps_elem_id);
  433.     } else {
  434.         _fps_logger_elem = document.createElement("div");
  435.         _fps_logger_elem.innerHTML = 0;
  436.         _fps_logger_elem.style.cssText =
  437.             "position:absolute;" +
  438.             "font-family: Arial, sans-serif;" +
  439.             "top: 20px;" +
  440.             "right: 20px;" +
  441.             "text-shadow: 0px 0px 6px #000;" +
  442.             "font-size: 40px;" +
  443.             "line-height: 50px;" +
  444.             "font-weight: bold;" +
  445.             "color: #fff;";
  447.         m_cont.insert_to_container(_fps_logger_elem, "JUST_AFTER_CANVAS");
  448.     }
  449. }
  451. function fps_callback(fps, phy_fps) {
  452.     var fps_str = String(fps);
  454.     if (phy_fps)
  455.         fps_str += "/" + String(phy_fps);
  457.     _fps_logger_elem.innerHTML = fps_str;
  458. }
  460. function elem_cloned(elem_id) {
  462.     var target = document.getElementById(elem_id);
  464.     // clone to prevent adding event listeners more than once
  465.     var new_element = target.cloneNode(true);
  466.     target.parentNode.replaceChild(new_element, target);
  468.     return new_element;
  469. }
  471. exports.set_onclick = function(elem_id, callback) {
  472.     var elem = elem_cloned(elem_id);
  473.     elem.addEventListener("mouseup", function(e) {
  474.         callback(elem.value);
  475.     }, false);
  476. }
  478. exports.set_onchange = function(elem_id, callback) {
  479.     var elem = elem_cloned(elem_id);
  480.     elem.addEventListener("change", function(e) {
  481.         var checked = elem.checked;
  482.         var rslt = checked != undefined ? checked : elem.value;
  483.         callback(rslt);
  484.     }, false);
  485. }
  487. exports.set_onkeypress = function(elem_id, callback) {
  488.     var elem = elem_cloned(elem_id);
  489.     elem.addEventListener("keypress", function(e) {
  490.         callback(e.keyCode, elem.value);
  491.     }, false);
  492. }
  494. function trans_hover_cam_horiz_local(camobj, dir, fact) {
  495.     var dist = Math.max(m_cam.hover_get_distance(camobj), HOVER_SPEED_MIN);
  497.     var obj_quat = m_trans.get_rotation(camobj, _quat4_tmp);
  498.     var abs_dir = m_util.quat_to_dir(obj_quat, dir, _vec3_tmp);
  499.     abs_dir[2] = 0;
  500.     m_vec3.normalize(abs_dir, abs_dir);
  501.     m_vec3.scale(abs_dir, dist * fact, abs_dir);
  503.     var obj_trans = m_trans.get_translation(camobj, _vec3_tmp2);
  504.     m_vec3.add(obj_trans, abs_dir, obj_trans)
  505.     m_cam.set_translation(camobj, obj_trans);
  506. }
  508. function zoom_hover_cam(camobj, fact) {
  509.     var limits = m_cam.hover_get_vertical_limits(camobj, _limits_tmp);
  510.     if (limits.up != limits.down) {
  511.         var y_angle = m_cam.get_camera_angles(camobj, _vec2_tmp2)[1];
  512.         var angle_factor = (limits.down - y_angle) / (limits.down - limits.up);
  513.         var dist_limits = m_cam.hover_get_distance_limits(camobj, _limits_tmp);
  514.         angle_factor = Math.max(angle_factor, HOVER_ZOOM_FACTOR_MIN / dist_limits.max);
  515.         m_cam.rotate_camera(camobj, 0, angle_factor * fact);
  516.     }
  517. }
  519. function trans_eye_cam_local(camobj, fact_x, fact_y, fact_z) {
  520.     fact_x *= EYE_KEY_TRANS_FACTOR;
  521.     fact_y *= EYE_KEY_TRANS_FACTOR;
  522.     fact_z *= EYE_KEY_TRANS_FACTOR;
  523.     m_trans.move_local(camobj, fact_x, fact_y, fact_z);
  524. }
  526. function calc_fact_from(fact_to) {
  527.     return fact_to / (1 - fact_to);
  528. }
  530. function trans_targ_cam_local(camobj, fact_view, elapsed) {
  531.     var dist = m_cam.target_get_distance(camobj);
  532.     var abs_fact_view = Math.abs(fact_view);
  533.     var fact = Math.pow(abs_fact_view * elapsed, TARGET_KEY_ZOOM_POW1
  534.             - Math.pow(abs_fact_view * elapsed, TARGET_KEY_ZOOM_POW2));
  536.     if (fact_view < 0)
  537.         if (dist > EPSILON_DISTANCE)
  538.             fact_view = - dist * fact;
  539.         else
  540.             fact_view = 0;
  541.     else
  542.         fact_view = dist * calc_fact_from(fact);
  544.     m_trans.move_local(camobj, 0, 0, fact_view);
  545. }
  547. function get_dest_mouse_touch(obj, value, fact, dist, dest_value) {
  548.     var t_mult = dist * fact;
  550.     for (var i = value; i > 0; --i) {
  551.         dist += t_mult;
  552.         dest_value += t_mult;
  553.         t_mult = dist * fact;
  554.     }
  555.     return dest_value;
  556. }
  558. function get_dest_zoom(obj, value, velocity_zoom, dest_value, dev_fact,
  559.         use_pivot) {
  561.     if (use_pivot) {
  562.         // camera zooming
  563.         var cam_pivot = m_cam.target_get_pivot(obj, _vec3_tmp);
  564.         var cam_eye = m_cam.get_translation(obj);
  565.         var dist = m_vec3.dist(cam_pivot, cam_eye) + dest_value;
  567.         if (value > 0)
  568.             dest_value = get_dest_mouse_touch(obj, value,
  569.                     -velocity_zoom, dist, dest_value);
  570.         else
  571.             dest_value = get_dest_mouse_touch(obj, -value,
  572.                     calc_fact_from(velocity_zoom), dist, dest_value);
  573.     } else
  574.         // use_hover == True
  575.         dest_value -= value * dev_fact * velocity_zoom;
  576.     return dest_value;
  577. }
  579. /**
  580.  * Assign keyboard and mouse controls to the active camera.
  581.  * (arrow keys, ADSW, wheel and others)
  582.  * @method module:app.enable_camera_controls
  583.  * @param {boolean} [disable_default_pivot=false] Do not use the possible
  584.  * camera-defined pivot point
  585.  * @param {boolean} [disable_letter_controls=false] Disable keyboard letter controls
  586.  * (only arrow keys will be used to control the camera).
  587.  * @param {boolean} [disable_zoom=false] Disable zoom
  588.  * @param {HTMLElement} [element] HTML element to add event listeners to. 
  589.  * The canvas container will be use by default.
  590.  * @param {boolean} [allow_element_exit=false] Continue receiving mouse events
  591.  * even when the mouse is leaving the HTML element
  592.  * @param {boolean} [disable_gamepad_controls=false] Disable gamepad controls
  593.  * @example 
  594.  * var m_app = require("app");
  595.  * m_app.enable_camera_controls();
  596.  */
  598. exports.enable_camera_controls = enable_camera_controls;
  600. function enable_camera_controls(disable_default_pivot, disable_letter_controls,
  601.                                 disable_zoom, element, allow_element_exit,
  602.                                 disable_gamepad_controls) {
  603.     _disable_default_pivot = disable_default_pivot;
  604.     _disable_letter_controls = disable_letter_controls;
  605.     _disable_zoom = disable_zoom;
  606.     _element = element;
  607.     _allow_element_exit = allow_element_exit;
  608.     _disable_gamepad_controls = disable_gamepad_controls;
  610.     var obj = m_scs.get_active_camera();
  611.     enable_cam_controls_resetting(obj);
  613.     var use_pivot = false;
  614.     var character = null;
  615.     var use_hover = false;
  617.     switch (m_cam.get_move_style(obj)) {
  618.     case m_cam.MS_TARGET_CONTROLS:
  619.         use_pivot = !disable_default_pivot;
  620.         break;
  621.     case m_cam.MS_EYE_CONTROLS:
  622.         character = m_scs.get_first_character();
  623.         break;
  624.     case m_cam.MS_STATIC:
  625.         return;
  626.     case m_cam.MS_HOVER_CONTROLS:
  627.         use_hover = true;
  628.         break;
  629.     }
  631.     var velocity = m_cam.get_velocities(obj, _velocity_tmp);
  633.     var elapsed = m_ctl.create_elapsed_sensor();
  635.     if (m_phy.has_simulated_physics(obj)) {
  637.         var collision = m_ctl.create_collision_sensor(obj, null, true);
  639.         var collision_cb = function(obj, id, pulse) {
  640.             var coll_dist = m_ctl.get_sensor_payload(obj, id, 0).coll_dist;
  641.             if (coll_dist < 0) {
  642.                 var coll_norm = m_ctl.get_sensor_payload(obj, id, 0).coll_norm;
  643.                 var recover_offset = _vec3_tmp;
  644.                 m_vec3.scale(coll_norm, -CAM_COLL_DELTA * coll_dist, recover_offset);
  645.                 var trans = m_trans.get_translation(obj, _vec3_tmp2);
  646.                 m_vec3.add(trans, recover_offset, trans);
  647.                 m_trans.set_translation_v(obj, trans);
  648.             }
  649.         }
  650.         m_ctl.create_sensor_manifold(obj, "CAMERA_COLLISION", m_ctl.CT_POSITIVE,
  651.                 [collision], null, collision_cb);
  652.     }
  654.     if (character) {
  655.         // apply camera transform to character
  656.         var trans = m_trans.get_translation(obj);
  657.         var quat  = m_trans.get_rotation(obj);
  658.         var char_quat = m_util.cam_quat_to_mesh_quat(quat);
  660.         trans[2] -= CHAR_HEAD_POSITION;
  661.         m_phy.set_transform(character, trans, char_quat);
  662.         m_cons.append_stiff_trans(obj, character, [0, 0, 0.5]);
  664.         var char_dir = new Float32Array(2);
  666.         var is_fly = true;
  667.         m_phy.set_character_move_type(character, m_phy.CM_FLY);
  669.         var move_type_cb = function() {
  670.             is_fly = !is_fly;
  671.             m_phy.set_character_move_type(character,
  672.                 is_fly ? m_phy.CM_FLY : m_phy.CM_WALK);
  673.         }
  675.         m_ctl.create_kb_sensor_manifold(obj, "TOGGLE_CHAR_MOVE_TYPE",
  676.                 m_ctl.CT_SHOT, m_ctl.KEY_C, move_type_cb);
  677.     }
  679.     var key_cb = function(obj, id, pulse) {
  680.         if (pulse == 1) {
  682.             var elapsed = m_ctl.get_sensor_value(obj, id, 0);
  684.             m_cam.get_velocities(obj, velocity);
  685.             switch (id) {
  686.             case "FORWARD":
  687.                 if (character)
  688.                     char_dir[0] = 1;
  689.                 else if (use_hover) {
  690.                     var hover_angle = m_cam.get_camera_angles(obj, _vec2_tmp2)[1];
  691.                     var axis = (Math.abs(hover_angle) >= Math.PI / 4) ? m_util.AXIS_Y : m_util.AXIS_MZ;
  692.                     trans_hover_cam_horiz_local(obj, axis,
  693.                             velocity.trans * HOVER_KEY_TRANS_FACTOR * elapsed);
  694.                 } else if (use_pivot)
  695.                     trans_targ_cam_local(obj, -velocity.zoom, elapsed);
  696.                 else
  697.                     trans_eye_cam_local(obj, 0, 0, -velocity.trans * elapsed);
  698.                 break;
  699.             case "BACKWARD":
  700.                 if (character)
  701.                     char_dir[0] = -1;
  702.                 else if (use_hover) {
  703.                     var hover_angle = m_cam.get_camera_angles(obj, _vec2_tmp2)[1];
  704.                     var axis = (Math.abs(hover_angle) >= Math.PI / 4) ? m_util.AXIS_MY : m_util.AXIS_Z;
  705.                     trans_hover_cam_horiz_local(obj, axis,
  706.                             velocity.trans * HOVER_KEY_TRANS_FACTOR * elapsed);
  707.                 } else if (use_pivot)
  708.                     trans_targ_cam_local(obj, velocity.zoom, elapsed);
  709.                 else
  710.                     trans_eye_cam_local(obj, 0, 0, velocity.trans * elapsed);
  711.                 break;
  712.             case "UP":
  713.                 if (use_hover)
  714.                     zoom_hover_cam(obj, - velocity.zoom * HOVER_KEY_ZOOM_FACTOR 
  715.                             * elapsed);
  716.                 else if (!character)
  717.                     trans_eye_cam_local(obj, 0, velocity.trans * elapsed, 0);
  718.                 break;
  719.             case "DOWN":
  720.                 if (use_hover)
  721.                     zoom_hover_cam(obj, velocity.zoom * HOVER_KEY_ZOOM_FACTOR 
  722.                             * elapsed);
  723.                 else if (!character)
  724.                     trans_eye_cam_local(obj, 0, -velocity.trans * elapsed, 0);
  725.                 break;
  726.             case "LEFT":
  727.                 if (character)
  728.                     char_dir[1] = 1;
  729.                 else if (use_hover)
  730.                     trans_hover_cam_horiz_local(obj, m_util.AXIS_MX,
  731.                             velocity.trans * HOVER_KEY_TRANS_FACTOR * elapsed);
  732.                 else
  733.                     trans_eye_cam_local(obj, -velocity.trans * elapsed, 0, 0);
  734.                 break;
  735.             case "RIGHT":
  736.                 if (character)
  737.                     char_dir[1] = -1;
  738.                 else if (use_hover)
  739.                     trans_hover_cam_horiz_local(obj, m_util.AXIS_X,
  740.                             velocity.trans * HOVER_KEY_TRANS_FACTOR * elapsed);
  741.                 else
  742.                     trans_eye_cam_local(obj, velocity.trans * elapsed, 0, 0);
  743.                 break;
  744.             case "ROT_LEFT":
  745.                 if (use_pivot)
  746.                     m_cam.rotate_camera(obj, -velocity.rot
  747.                             * TARGET_EYE_KEY_ROT_FACTOR * elapsed, 0);
  748.                 else
  749.                     m_cam.rotate_camera(obj, velocity.rot * TARGET_EYE_KEY_ROT_FACTOR
  750.                             * elapsed, 0);
  751.                 break;
  752.             case "ROT_RIGHT":
  753.                 if (use_pivot)
  754.                     m_cam.rotate_camera(obj, velocity.rot
  755.                             * TARGET_EYE_KEY_ROT_FACTOR * elapsed, 0);
  756.                 else
  757.                     m_cam.rotate_camera(obj, -velocity.rot * TARGET_EYE_KEY_ROT_FACTOR
  758.                             * elapsed, 0);
  759.                 break;
  760.             case "ROT_UP":
  761.                 if (use_pivot)
  762.                     m_cam.rotate_camera(obj, 0, -velocity.rot
  763.                             * TARGET_EYE_KEY_ROT_FACTOR * elapsed);
  764.                 else
  765.                     m_cam.rotate_camera(obj, 0, velocity.rot
  766.                             * TARGET_EYE_KEY_ROT_FACTOR * elapsed);
  767.                 break;
  768.             case "ROT_DOWN":
  769.                 if (use_pivot)
  770.                     m_cam.rotate_camera(obj, 0, velocity.rot
  771.                             * TARGET_EYE_KEY_ROT_FACTOR * elapsed);
  772.                 else
  773.                     m_cam.rotate_camera(obj, 0, -velocity.rot
  774.                             * TARGET_EYE_KEY_ROT_FACTOR * elapsed);
  775.                 break;
  776.             default:
  777.                 break;
  778.             }
  780.         } else {
  781.             switch (id) {
  782.             case "FORWARD":
  783.             case "BACKWARD":
  784.                 if (character)
  785.                     char_dir[0] = 0;
  786.                 break;
  787.             case "LEFT":
  788.             case "RIGHT":
  789.                 if (character)
  790.                     char_dir[1] = 0;
  791.                 break;
  792.             }
  793.         }
  795.         if (character) {
  796.             m_phy.set_character_move_dir(character, char_dir[0], char_dir[1]);
  797.             var angles = m_cam.get_camera_angles_char(obj, _vec2_tmp);
  798.             m_phy.set_character_rotation_h(character, angles[0]);
  799.             m_phy.set_character_vert_move_dir_angle(character, angles[1]);
  800.         }
  801.     }
  803.     var key_w, key_s, key_a, key_d, key_r, key_f, gmpd_btn_6, gmpd_btn_7;
  804.     var lh_axis, lv_axis, rh_axis, rv_axis;
  806.     if (!disable_gamepad_controls) {
  807.         var gmpd_indices = m_input.check_enable_gamepad_indices();
  808.         if (gmpd_indices.length)
  809.             var gamepad_id = gmpd_indices[gmpd_indices.length - 1];
  810.         else
  811.             var gamepad_id = 0;
  813.         gmpd_btn_6 = m_ctl.create_gamepad_btn_sensor(m_input.GMPD_BUTTON_6,
  814.                 gamepad_id);
  815.         gmpd_btn_7 = m_ctl.create_gamepad_btn_sensor(m_input.GMPD_BUTTON_7,
  816.                 gamepad_id);
  817.         lh_axis = m_ctl.create_gamepad_axis_sensor(m_input.GMPD_AXIS_0, gmpd_indices);
  818.         lv_axis = m_ctl.create_gamepad_axis_sensor(m_input.GMPD_AXIS_1, gmpd_indices);
  820.         rh_axis = m_ctl.create_gamepad_axis_sensor(m_input.GMPD_AXIS_2, gmpd_indices);
  821.         rv_axis = m_ctl.create_gamepad_axis_sensor(m_input.GMPD_AXIS_3, gmpd_indices);
  822.     } else
  823.         gmpd_btn_6 = gmpd_btn_7 = lh_axis = lv_axis = rh_axis = rv_axis =
  824.                 m_ctl.create_custom_sensor(0);
  826.     if (!disable_letter_controls) {
  827.         key_w = m_ctl.create_keyboard_sensor(m_ctl.KEY_W);
  828.         key_s = m_ctl.create_keyboard_sensor(m_ctl.KEY_S);
  829.         key_a = m_ctl.create_keyboard_sensor(m_ctl.KEY_A);
  830.         key_d = m_ctl.create_keyboard_sensor(m_ctl.KEY_D);
  831.         key_r = m_ctl.create_keyboard_sensor(m_ctl.KEY_R);
  832.         key_f = m_ctl.create_keyboard_sensor(m_ctl.KEY_F);
  833.     } else
  834.         key_w = key_s = key_a = key_d = key_r = key_f = m_ctl.create_custom_sensor(0);
  836.     var key_up = m_ctl.create_keyboard_sensor(m_ctl.KEY_UP);
  837.     var key_down = m_ctl.create_keyboard_sensor(m_ctl.KEY_DOWN);
  838.     var key_left = m_ctl.create_keyboard_sensor(m_ctl.KEY_LEFT);
  839.     var key_right = m_ctl.create_keyboard_sensor(m_ctl.KEY_RIGHT);
  841.     // var key_single_logic = null;
  842.     // var key_double_logic = function(s) {
  843.     //     return s[0] && (s[1] || s[2]);
  844.     // }
  845.      var key_triple_logic = function(s) {
  846.         return s[0] && (s[1] || s[2] || s[3]);
  847.     }
  848.     var key_double_pos_logic = function(s) {
  849.         return s[0] && (s[1] || s[2] > AXIS_THRESHOLD);
  850.     }
  851.     var key_double_neg_logic = function(s) {
  852.         return s[0] && (s[1] || s[2] < -AXIS_THRESHOLD);
  853.     }
  854.     var key_triple_pos_logic = function(s) {
  855.         return s[0] && (s[1] || s[2] || s[3] > AXIS_THRESHOLD);
  856.     }
  857.     var key_triple_neg_logic = function(s) {
  858.         return s[0] && (s[1] || s[2] || s[3] < -AXIS_THRESHOLD);
  859.     }
  861.     if (!use_hover) {
  862.         m_ctl.create_sensor_manifold(obj, "FORWARD", m_ctl.CT_CONTINUOUS,
  863.                 [elapsed, key_w, lv_axis], key_double_neg_logic, key_cb);
  864.         m_ctl.create_sensor_manifold(obj, "BACKWARD", m_ctl.CT_CONTINUOUS,
  865.                 [elapsed, key_s, lv_axis], key_double_pos_logic, key_cb);
  866.     }
  868.     if (use_pivot) {
  869.         m_ctl.create_sensor_manifold(obj, "ROT_UP", m_ctl.CT_CONTINUOUS,
  870.                 [elapsed, key_up, key_r, rv_axis], key_triple_neg_logic, key_cb);
  871.         m_ctl.create_sensor_manifold(obj, "ROT_DOWN", m_ctl.CT_CONTINUOUS,
  872.                 [elapsed, key_down, key_f, rv_axis], key_triple_pos_logic, key_cb);
  873.         m_ctl.create_sensor_manifold(obj, "ROT_LEFT", m_ctl.CT_CONTINUOUS,
  874.                 [elapsed, key_left, key_a, rh_axis], key_triple_neg_logic, key_cb);
  875.         m_ctl.create_sensor_manifold(obj, "ROT_RIGHT", m_ctl.CT_CONTINUOUS,
  876.                 [elapsed, key_right, key_d, rh_axis], key_triple_pos_logic, key_cb);
  877.     } else if (use_hover) {
  878.         m_ctl.create_sensor_manifold(obj, "LEFT", m_ctl.CT_CONTINUOUS,
  879.                 [elapsed, key_left, key_a, lh_axis], key_triple_neg_logic, key_cb);
  880.         m_ctl.create_sensor_manifold(obj, "RIGHT", m_ctl.CT_CONTINUOUS,
  881.                 [elapsed, key_right, key_d, lh_axis], key_triple_pos_logic, key_cb);
  882.         m_ctl.create_sensor_manifold(obj, "FORWARD", m_ctl.CT_CONTINUOUS,
  883.                 [elapsed, key_up, key_w, lv_axis], key_triple_neg_logic, key_cb);
  884.         m_ctl.create_sensor_manifold(obj, "BACKWARD", m_ctl.CT_CONTINUOUS,
  885.                 [elapsed, key_down, key_s, lv_axis], key_triple_pos_logic, key_cb);
  886.         m_ctl.create_sensor_manifold(obj, "UP", m_ctl.CT_CONTINUOUS,
  887.                 [elapsed, key_f, rv_axis], key_double_pos_logic, key_cb);
  888.         m_ctl.create_sensor_manifold(obj, "DOWN", m_ctl.CT_CONTINUOUS,
  889.                 [elapsed, key_r, rv_axis], key_double_neg_logic, key_cb);
  890.     } else {
  891.         m_ctl.create_sensor_manifold(obj, "UP", m_ctl.CT_CONTINUOUS,
  892.                 [elapsed, key_r, gmpd_btn_6], key_triple_logic, key_cb);
  893.         m_ctl.create_sensor_manifold(obj, "DOWN", m_ctl.CT_CONTINUOUS,
  894.                 [elapsed, key_f, gmpd_btn_7], key_triple_logic, key_cb);
  895.         m_ctl.create_sensor_manifold(obj, "LEFT", m_ctl.CT_CONTINUOUS,
  896.                 [elapsed, key_a, lh_axis], key_double_neg_logic, key_cb);
  897.         m_ctl.create_sensor_manifold(obj, "RIGHT", m_ctl.CT_CONTINUOUS,
  898.                 [elapsed, key_d, lh_axis], key_double_pos_logic, key_cb);
  899.         m_ctl.create_sensor_manifold(obj, "ROT_UP", m_ctl.CT_CONTINUOUS,
  900.                 [elapsed, key_up, rv_axis], key_double_neg_logic, key_cb);
  901.         m_ctl.create_sensor_manifold(obj, "ROT_DOWN", m_ctl.CT_CONTINUOUS,
  902.                 [elapsed, key_down, rv_axis], key_double_pos_logic, key_cb);
  903.         m_ctl.create_sensor_manifold(obj, "ROT_LEFT", m_ctl.CT_CONTINUOUS,
  904.                 [elapsed, key_left, rh_axis], key_double_neg_logic, key_cb);
  905.         m_ctl.create_sensor_manifold(obj, "ROT_RIGHT", m_ctl.CT_CONTINUOUS,
  906.                 [elapsed, key_right, rh_axis], key_double_pos_logic, key_cb);
  907.     }
  909.     if (!disable_zoom) {
  910.         // mouse wheel: camera zooming and translation speed adjusting
  911.         var dest_zoom_mouse = 0;
  912.         var mouse_wheel = m_ctl.create_mouse_wheel_sensor(element);
  914.         // camera zooming with touch
  915.         var dest_zoom_touch = 0;
  916.         var touch_zoom = m_ctl.create_touch_zoom_sensor(element);
  918.         var mouse_wheel_cb = function(obj, id, pulse) {
  919.             if (pulse == 1) {
  920.                 var value = m_ctl.get_sensor_value(obj, id, 0);
  921.                 m_cam.get_velocities(obj, velocity);
  922.                 if (use_pivot || use_hover) {
  923.                     dest_zoom_mouse = get_dest_zoom(obj, value, velocity.zoom,
  924.                             dest_zoom_mouse, HOVER_MOUSE_ZOOM_FACTOR, use_pivot);
  925.                 } else {
  926.                     // translation speed adjusting
  927.                     var factor = value * velocity.zoom;
  928.                     velocity.trans *= (1 + factor);
  929.                     m_cam.set_velocities(obj, velocity);
  930.                 }
  931.             }
  932.         }
  934.         m_ctl.create_sensor_manifold(obj, "MOUSE_WHEEL", m_ctl.CT_LEVEL,
  935.                 [mouse_wheel], null, mouse_wheel_cb);
  937.         var touch_zoom_cb = function(obj, id, pulse, param) {
  938.             if (pulse == 1) {
  939.                 var value = m_ctl.get_sensor_value(obj, id, 0);
  940.                 m_cam.get_velocities(obj, velocity);
  942.                 if (m_ctl.get_sensor_payload(obj, id, 0)
  943.                         === m_ctl.PL_MULTITOUCH_MOVE_ZOOM) {
  944.                     dest_zoom_touch = get_dest_zoom(obj, value, velocity.zoom
  945.                             * TARGET_TOUCH_ZOOM_FACTOR, dest_zoom_touch,
  946.                             HOVER_TOUCH_ZOOM_FACTOR, use_pivot);
  947.                 }
  948.             }
  949.         }
  951.         m_ctl.create_sensor_manifold(obj, "TOUCH_ZOOM", m_ctl.CT_LEVEL,
  952.                 [touch_zoom], null, touch_zoom_cb);
  954.         // camera zoom smoothing
  955.         var zoom_interp_cb = function(obj, id, pulse) {
  957.             if (use_pivot || use_hover) {
  958.                 if (Math.abs(dest_zoom_mouse) > EPSILON_DELTA
  959.                         || Math.abs(dest_zoom_touch) > EPSILON_DELTA) {
  960.                     var value = m_ctl.get_sensor_value(obj, id, 0);
  961.                     var zoom_mouse = m_util.smooth(dest_zoom_mouse, 0, value,
  962.                             smooth_coeff_zoom_mouse());
  963.                     dest_zoom_mouse -= zoom_mouse;
  965.                     var zoom_touch = m_util.smooth(dest_zoom_touch, 0, value,
  966.                             smooth_coeff_zoom_touch());
  967.                     dest_zoom_touch -= zoom_touch;
  969.                     if (use_hover) {
  970.                         zoom_hover_cam(obj, - (zoom_mouse + zoom_touch));
  971.                     } else {
  972.                         var res_dist = m_cam.target_get_distance(obj)
  973.                             + zoom_mouse + zoom_touch;
  974.                         // NOTE: prevent zoom overshooting.
  975.                         res_dist = Math.max(res_dist, EPSILON_DISTANCE);
  976.                         m_cam.target_set_distance(obj, res_dist);
  977.                     }
  978.                 } else {
  979.                     dest_zoom_mouse = 0;
  980.                     dest_zoom_touch = 0;
  981.                 }
  982.             }
  983.         }
  985.         m_ctl.create_sensor_manifold(obj, "ZOOM_INTERPOL", m_ctl.CT_POSITIVE,
  986.                 [elapsed], null, zoom_interp_cb);
  987.     }
  989.     // camera rotation and translation with mouse
  990.     var dest_x_mouse = 0;
  991.     var dest_y_mouse = 0;
  993.     // camera panning with mouse
  994.     var dest_pan_x_mouse = 0;
  995.     var dest_pan_y_mouse = 0;
  997.     var mouse_cb = function(obj, id, pulse, param) {
  998.         if (pulse == 1) {
  999.             var value = m_ctl.get_sensor_value(obj, id, 1);
  1001.             m_cam.get_velocities(obj, velocity);
  1002.             if (!use_hover) {
  1003.                 var left_mult  = TARGET_EYE_MOUSE_ROT_MULT_PX * velocity.rot;
  1004.                 var right_mult = TARGET_EYE_MOUSE_PAN_MULT_PX * velocity.trans;
  1005.             } else {
  1006.                 var left_mult  = HOVER_MOUSE_PAN_MULT_PX * velocity.trans;
  1007.                 var right_mult = HOVER_MOUSE_ROT_MULT_PX * velocity.rot;
  1008.             }
  1010.             if (m_ctl.get_sensor_payload(obj, id, 0).which === 1) {
  1011.                 dest_x_mouse += (param == "X") ? -value * left_mult : 0;
  1012.                 dest_y_mouse += (param == "Y") ? -value * left_mult : 0;
  1013.             } else if (m_ctl.get_sensor_payload(obj, id, 0).which === 2
  1014.                     || m_ctl.get_sensor_payload(obj, id, 0).which === 3) {
  1015.                 dest_pan_x_mouse += (param == "X") ? -value * right_mult : 0;
  1016.                 dest_pan_y_mouse += (param == "Y") ? -value * right_mult : 0;
  1017.             }
  1018.         }
  1019.     }
  1021.     // camera panning with gamepad
  1022.     var dest_pan_x_gmpd = 0;
  1023.     var dest_pan_y_gmpd = 0;
  1024.     if (!disable_gamepad_controls) {
  1025.         var gmpd_panning_x_pos_cb = function(obj, id, pulse) {
  1026.             m_cam.get_velocities(obj, velocity);
  1027.             dest_pan_x_gmpd += velocity.trans * TRANS_GMPD_KOEF;
  1028.         }
  1029.         var gmpd_panning_y_pos_cb = function(obj, id, pulse) {
  1030.             m_cam.get_velocities(obj, velocity);
  1031.             dest_pan_y_gmpd += velocity.zoom * ZOOM_GMPD_KOEF;
  1032.         }
  1033.         var gmpd_panning_x_neg_cb = function(obj, id, pulse) {
  1034.             m_cam.get_velocities(obj, velocity);
  1035.             dest_pan_x_gmpd -= velocity.trans * TRANS_GMPD_KOEF;
  1036.         }
  1037.         var gmpd_panning_y_neg_cb = function(obj, id, pulse) {
  1038.             m_cam.get_velocities(obj, velocity);
  1039.             dest_pan_y_gmpd -= velocity.zoom * ZOOM_GMPD_KOEF;
  1040.         }
  1042.         if (use_pivot) {
  1043.             m_ctl.create_sensor_manifold(obj, "GMPD_PAN_Y_POS", m_ctl.CT_CONTINUOUS,
  1044.                     [gmpd_btn_6], null, gmpd_panning_y_pos_cb);
  1045.             m_ctl.create_sensor_manifold(obj, "GMPD_PAN_Y_NEG", m_ctl.CT_CONTINUOUS,
  1046.                     [gmpd_btn_7], null, gmpd_panning_y_neg_cb);
  1047.             m_ctl.create_sensor_manifold(obj, "GMPD_PAN_X_POS", m_ctl.CT_CONTINUOUS,
  1048.                     [lh_axis], function(s) {return s[0] < -AXIS_THRESHOLD}, gmpd_panning_x_neg_cb);
  1049.             m_ctl.create_sensor_manifold(obj, "GMPD_PAN_X_NEG", m_ctl.CT_CONTINUOUS,
  1050.                     [lh_axis], function(s) {return s[0] > AXIS_THRESHOLD}, gmpd_panning_x_pos_cb);
  1051.         } else if (use_hover) {
  1052.             m_ctl.create_sensor_manifold(obj, "GMPD_PAN_X_POS", m_ctl.CT_CONTINUOUS,
  1053.                     [rh_axis], function(s) {return s[0] < -AXIS_THRESHOLD}, gmpd_panning_x_neg_cb);
  1054.             m_ctl.create_sensor_manifold(obj, "GMPD_PAN_X_NEG", m_ctl.CT_CONTINUOUS,
  1055.                     [rh_axis], function(s) {return s[0] > AXIS_THRESHOLD}, gmpd_panning_x_pos_cb);
  1056.         }
  1057.     }
  1059.     if (allow_element_exit) {
  1060.         var mouse_move_x = m_ctl.create_mouse_move_sensor("X", window);
  1061.         var mouse_move_y = m_ctl.create_mouse_move_sensor("Y", window);
  1062.         var mouse_down_c = m_ctl.create_mouse_click_sensor(element);
  1063.         var mouse_down_w = m_ctl.create_mouse_click_sensor(window);
  1065.         var element_exit_state = false;
  1066.         var element_exit_logic = function(s) {
  1067.             if (s[2])
  1068.                 element_exit_state = true;
  1069.             else if (!s[0])
  1070.                 element_exit_state = false;
  1071.             return element_exit_state && s[0];
  1072.         }
  1073.         m_ctl.create_sensor_manifold(obj, "MOUSE_X", m_ctl.CT_POSITIVE,
  1074.                 [mouse_down_w, mouse_move_x, mouse_down_c], element_exit_logic, mouse_cb, "X");
  1075.         m_ctl.create_sensor_manifold(obj, "MOUSE_Y", m_ctl.CT_POSITIVE,
  1076.                 [mouse_down_w, mouse_move_y, mouse_down_c], element_exit_logic, mouse_cb, "Y");
  1078.         var device = m_input.get_device_by_type_element(m_input.DEVICE_MOUSE, window);
  1079.         m_input.switch_prevent_default(device, false);
  1080.     } else {
  1081.         var mouse_move_x = m_ctl.create_mouse_move_sensor("X", element);
  1082.         var mouse_move_y = m_ctl.create_mouse_move_sensor("Y", element);
  1083.         var mouse_down = m_ctl.create_mouse_click_sensor(element);
  1084.         m_ctl.create_sensor_manifold(obj, "MOUSE_X", m_ctl.CT_POSITIVE,
  1085.                 [mouse_down, mouse_move_x], null, mouse_cb, "X");
  1086.         m_ctl.create_sensor_manifold(obj, "MOUSE_Y", m_ctl.CT_POSITIVE,
  1087.                 [mouse_down, mouse_move_y], null, mouse_cb, "Y");
  1088.     }
  1090.     // camera rotation and translation with touch
  1091.     var dest_x_touch = 0;
  1092.     var dest_y_touch = 0;
  1094.     // camera panning with touch
  1095.     var dest_pan_x_touch = 0;
  1096.     var dest_pan_y_touch = 0;
  1098.     var touch_move_x = m_ctl.create_touch_move_sensor("X", element);
  1099.     var touch_move_y = m_ctl.create_touch_move_sensor("Y", element);
  1101.     var touch_cb = function(obj, id, pulse, param) {
  1102.         if (pulse == 1) {
  1103.             m_cam.get_velocities(obj, velocity);
  1104.             if (use_hover)
  1105.                 var r_mult = HOVER_TOUCH_PAN_MULT_PX * velocity.trans;
  1106.             else
  1107.                 var r_mult = TARGET_EYE_TOUCH_ROT_MULT_PX * velocity.rot;
  1108.             var value = m_ctl.get_sensor_value(obj, id, 0);
  1109.             if (m_ctl.get_sensor_payload(obj, id, 0).gesture
  1110.                     === m_ctl.PL_SINGLE_TOUCH_MOVE) {
  1111.                 dest_x_touch += (param == "X") ? -value * r_mult : 0;
  1112.                 dest_y_touch += (param == "Y") ? -value * r_mult : 0;
  1113.             } else if (m_ctl.get_sensor_payload(obj, id, 0).gesture
  1114.                     ===  m_ctl.PL_MULTITOUCH_MOVE_PAN) {
  1115.                 if (!use_hover) {
  1116.                     var pan_mult = TARGET_EYE_TOUCH_PAN_MULT_PX * velocity.trans;
  1117.                 } else {
  1118.                     var pan_mult = HOVER_TOUCH_ROT_MULT_PX * velocity.rot;
  1119.                 }
  1120.                 dest_pan_x_touch += (param == "X") ? -value * pan_mult : 0;
  1121.                 dest_pan_y_touch += (param == "Y") ? -value * pan_mult : 0;
  1122.             }
  1123.         }
  1124.     }
  1126.     m_ctl.create_sensor_manifold(obj, "TOUCH_X", m_ctl.CT_POSITIVE,
  1127.             [touch_move_x], null, touch_cb, "X");
  1128.     m_ctl.create_sensor_manifold(obj, "TOUCH_Y", m_ctl.CT_POSITIVE,
  1129.             [touch_move_y], null, touch_cb, "Y");
  1131.     // camera rotation and translation smoothing
  1132.     var rot_trans_interp_cb = function(obj, id, pulse) {
  1133.         if (    Math.abs(dest_x_mouse) > EPSILON_DELTA ||
  1134.                 Math.abs(dest_y_mouse) > EPSILON_DELTA ||
  1135.                 Math.abs(dest_x_touch) > EPSILON_DELTA ||
  1136.                 Math.abs(dest_y_touch) > EPSILON_DELTA ||
  1137.                 Math.abs(dest_pan_x_mouse) > EPSILON_DELTA ||
  1138.                 Math.abs(dest_pan_y_mouse) > EPSILON_DELTA ||
  1139.                 Math.abs(dest_pan_x_touch) > EPSILON_DELTA ||
  1140.                 Math.abs(dest_pan_y_touch) > EPSILON_DELTA ||
  1141.                 Math.abs(dest_pan_x_gmpd) > EPSILON_DELTA ||
  1142.                 Math.abs(dest_pan_y_gmpd) > EPSILON_DELTA) {
  1144.             var value = m_ctl.get_sensor_value(obj, id, 0);
  1146.             var x_mouse = m_util.smooth(dest_x_mouse, 0, value,
  1147.                     smooth_coeff_rot_trans_mouse());
  1148.             var y_mouse = m_util.smooth(dest_y_mouse, 0, value,
  1149.                     smooth_coeff_rot_trans_mouse());
  1151.             dest_x_mouse -= x_mouse;
  1152.             dest_y_mouse -= y_mouse;
  1154.             var x_touch = m_util.smooth(dest_x_touch, 0, value,
  1155.                     smooth_coeff_rot_trans_touch());
  1156.             var y_touch = m_util.smooth(dest_y_touch, 0, value,
  1157.                     smooth_coeff_rot_trans_touch());
  1159.             dest_x_touch -= x_touch;
  1160.             dest_y_touch -= y_touch;
  1162.             var trans_x_mouse = m_util.smooth(dest_pan_x_mouse, 0,
  1163.                     value, smooth_coeff_rot_trans_mouse());
  1164.             var trans_y_mouse = m_util.smooth(dest_pan_y_mouse, 0,
  1165.                     value, smooth_coeff_rot_trans_mouse());
  1167.             dest_pan_x_mouse -= trans_x_mouse;
  1168.             dest_pan_y_mouse -= trans_y_mouse;
  1170.             var trans_x_touch = m_util.smooth(dest_pan_x_touch, 0,
  1171.                     value, smooth_coeff_rot_trans_touch());
  1172.             var trans_y_touch = m_util.smooth(dest_pan_y_touch, 0,
  1173.                     value, smooth_coeff_rot_trans_touch());
  1175.             dest_pan_x_touch -= trans_x_touch;
  1176.             dest_pan_y_touch -= trans_y_touch;
  1178.             var trans_x_gmpd = m_util.smooth(dest_pan_x_gmpd, 0,
  1179.                     value, smooth_coeff_rot_trans_mouse());
  1180.             var trans_y_gmpd = m_util.smooth(dest_pan_y_gmpd, 0,
  1181.                     value, smooth_coeff_rot_trans_mouse());
  1183.             dest_pan_x_gmpd -= trans_x_gmpd;
  1184.             dest_pan_y_gmpd -= trans_y_gmpd;
  1186.             if (use_pivot) {
  1187.                 m_cam.rotate_camera(obj, x_mouse + x_touch,
  1188.                         y_mouse + y_touch);
  1190.                 var dist = m_cam.target_get_distance(obj);
  1191.                 m_cam.target_pan_pivot(obj,
  1192.                         dist * (trans_x_mouse + trans_x_touch + trans_x_gmpd),
  1193.                         dist * (trans_y_mouse + trans_y_touch + trans_y_gmpd));
  1194.             } else if (use_hover) {
  1195.                 if (x_mouse + x_touch) {
  1196.                     trans_hover_cam_horiz_local(obj, m_util.AXIS_X,
  1197.                             (x_mouse + x_touch)
  1198.                             * HOVER_MOUSE_TOUCH_TRANS_FACTOR);
  1199.                 }
  1201.                 if (y_mouse + y_touch) {
  1202.                     var hover_angle = m_cam.get_camera_angles(obj, _vec2_tmp2)[1];
  1203.                     var axis = (Math.abs(hover_angle) > Math.PI / 4) ? m_util.AXIS_MY : m_util.AXIS_Z;
  1204.                     trans_hover_cam_horiz_local(obj, axis, (y_mouse + y_touch)
  1205.                             * HOVER_MOUSE_TOUCH_TRANS_FACTOR);
  1206.                 }
  1208.                 m_cam.rotate_camera(obj, trans_x_mouse + trans_x_touch + trans_x_gmpd, 0);
  1209.             } else {
  1210.                 m_cam.rotate_camera(obj, (x_mouse + x_touch) * EYE_ROTATION_DECREMENT,
  1211.                         (y_mouse + y_touch) * EYE_ROTATION_DECREMENT);
  1213.                 if (character) {
  1214.                     var angles = m_cam.get_camera_angles_char(obj, _vec2_tmp);
  1215.                     m_phy.set_character_rotation_h(character, angles[0]);
  1216.                     m_phy.set_character_vert_move_dir_angle(character, angles[1]);
  1217.                 }
  1218.             }
  1219.         }
  1220.     }
  1222.     m_ctl.create_sensor_manifold(obj, "ROT_TRANS_INTERPOL", m_ctl.CT_POSITIVE,
  1223.             [elapsed], null, rot_trans_interp_cb);
  1225.     m_ctl.create_kb_sensor_manifold(obj, "DEC_STEREO_DIST", m_ctl.CT_SHOT,
  1226.             m_ctl.KEY_LEFT_SQ_BRACKET, function(obj, id, pulse) {
  1227.                 var dist = m_cam.get_stereo_distance(obj);
  1228.                 m_cam.set_stereo_distance(obj, 0.9 * dist);
  1229.             });
  1231.     m_ctl.create_kb_sensor_manifold(obj, "INC_STEREO_DIST", m_ctl.CT_SHOT,
  1232.             m_ctl.KEY_RIGHT_SQ_BRACKET, function(obj, id, pulse) {
  1233.                 var dist = m_cam.get_stereo_distance(obj);
  1234.                 m_cam.set_stereo_distance(obj, 1.1 * dist);
  1235.             });
  1236. }
  1238. /**
  1239.  * Register sensors for resetting the camera controls if the camera move style
  1240.  * was changed.
  1241.  */
  1242. function enable_cam_controls_resetting(cam) {
  1243.     var prev_ms = m_cam.get_move_style(cam);
  1244.     var move_style_cb = function() {
  1245.         var curr_ms = m_cam.get_move_style(cam);
  1246.         var is_changed = curr_ms != prev_ms;
  1247.         prev_ms = curr_ms;
  1248.         return is_changed;
  1249.     }
  1250.     var cb_sensor = m_ctl.create_callback_sensor(move_style_cb);
  1252.     function reset_controls_cb(cam, id, pulse) {
  1253.         disable_camera_controls();
  1254.         enable_camera_controls(_disable_default_pivot, _disable_letter_controls,
  1255.                 _disable_zoom, _element, _allow_element_exit,
  1256.                 _disable_gamepad_controls);
  1257.     }
  1258.     m_ctl.create_sensor_manifold(cam, "CHANGE_MOVE_STYLE", m_ctl.CT_POSITIVE,
  1259.             [cb_sensor], null, reset_controls_cb);
  1260. }
  1262. /**
  1263.  * Disable controls for the active camera.
  1264.  * @method module:app.disable_camera_controls
  1265.  * @example 
  1266.  * var m_app = require("app");
  1267.  * m_app.disable_camera_controls();
  1268.  */
  1269. exports.disable_camera_controls = disable_camera_controls;
  1270. function disable_camera_controls() {
  1271.     var cam = m_scs.get_active_camera();
  1273.     if (m_ctl.check_sensor_manifold(cam, "TOGGLE_CHAR_MOVE_TYPE")
  1274.             && m_scs.get_first_character())
  1275.         m_cons.remove(cam);
  1277.     var cam_std_manifolds = ["FORWARD", "BACKWARD", "ROT_UP", "ROT_DOWN",
  1278.             "ROT_LEFT", "ROT_RIGHT", "UP", "DOWN", "LEFT", "RIGHT",
  1279.             "MOUSE_WHEEL", "TOUCH_ZOOM", "ZOOM_INTERPOL", "MOUSE_X", "MOUSE_Y",
  1280.             "TOUCH_X", "TOUCH_Y", "ROT_TRANS_INTERPOL", "CHANGE_MOVE_STYLE", 
  1281.             "TOGGLE_CHAR_MOVE_TYPE"];
  1283.     for (var i = 0; i < cam_std_manifolds.length; i++)
  1284.         m_ctl.remove_sensor_manifold(cam, cam_std_manifolds[i]);
  1285. }
  1287. /**
  1288.  * Assign some controls to the non-camera object.
  1289.  * @param {Object3D} obj Object 3D
  1290.  * @param {HTMLElement} [element=Canvas container element] HTML element
  1291.  */
  1292. exports.enable_object_controls = function(obj, element) {
  1293.     var trans_speed = 1;
  1295.     var is_vehicle = m_phy.is_vehicle_chassis(obj) ||
  1296.             m_phy.is_vehicle_hull(obj);
  1298.     var key_cb = function(obj, id, pulse) {
  1299.         if (pulse == 1) {
  1300.             var elapsed = m_ctl.get_sensor_value(obj, id, 0);
  1302.             switch (id) {
  1303.             case "FORWARD":
  1304.                 if (is_vehicle)
  1305.                     m_phy.vehicle_throttle(obj, 1);
  1306.                 else
  1307.                     m_trans.move_local(obj, 0, -trans_speed * elapsed, 0);
  1308.                 break;
  1309.             case "BACKWARD":
  1310.                 if (is_vehicle)
  1311.                     m_phy.vehicle_throttle(obj, -1);
  1312.                 else
  1313.                     m_trans.move_local(obj, 0, trans_speed * elapsed, 0);
  1314.                 break;
  1315.             case "LEFT":
  1316.                 if (is_vehicle)
  1317.                     m_phy.vehicle_steer(obj, -1);
  1318.                 else
  1319.                     m_trans.move_local(obj, trans_speed * elapsed, 0, 0);
  1320.                 break;
  1321.             case "RIGHT":
  1322.                 if (is_vehicle)
  1323.                     m_phy.vehicle_steer(obj, 1);
  1324.                 else
  1325.                     m_trans.move_local(obj, -trans_speed * elapsed, 0, 0);
  1326.                 break;
  1327.             default:
  1328.                 break;
  1329.             }
  1330.         } else {
  1331.             switch (id) {
  1332.             case "FORWARD":
  1333.             case "BACKWARD":
  1334.                 if (is_vehicle)
  1335.                     m_phy.vehicle_throttle(obj, 0);
  1336.                 break;
  1337.             case "LEFT":
  1338.             case "RIGHT":
  1339.                 if (is_vehicle)
  1340.                     m_phy.vehicle_steer(obj, 0);
  1341.                 break;
  1342.             default:
  1343.                 break;
  1344.             }
  1345.         }
  1346.     }
  1348.     var elapsed = m_ctl.create_elapsed_sensor();
  1350.     var key_w = m_ctl.create_keyboard_sensor(m_ctl.KEY_W);
  1351.     var key_s = m_ctl.create_keyboard_sensor(m_ctl.KEY_S);
  1352.     var key_a = m_ctl.create_keyboard_sensor(m_ctl.KEY_A);
  1353.     var key_d = m_ctl.create_keyboard_sensor(m_ctl.KEY_D);
  1355.     var key_up = m_ctl.create_keyboard_sensor(m_ctl.KEY_UP);
  1356.     var key_down = m_ctl.create_keyboard_sensor(m_ctl.KEY_DOWN);
  1357.     var key_left = m_ctl.create_keyboard_sensor(m_ctl.KEY_LEFT);
  1358.     var key_right = m_ctl.create_keyboard_sensor(m_ctl.KEY_RIGHT);
  1360.     var key_logic = function(s) {
  1361.         return s[0] && (s[1] || s[2]);
  1362.     }
  1364.     m_ctl.create_sensor_manifold(obj, "FORWARD", m_ctl.CT_CONTINUOUS,
  1365.             [elapsed, key_w, key_up], key_logic, key_cb);
  1366.     m_ctl.create_sensor_manifold(obj, "BACKWARD", m_ctl.CT_CONTINUOUS,
  1367.             [elapsed, key_s, key_down], key_logic, key_cb);
  1368.     m_ctl.create_sensor_manifold(obj, "LEFT", m_ctl.CT_CONTINUOUS,
  1369.             [elapsed, key_a, key_left], key_logic, key_cb);
  1370.     m_ctl.create_sensor_manifold(obj, "RIGHT", m_ctl.CT_CONTINUOUS,
  1371.             [elapsed, key_d, key_right], key_logic, key_cb);
  1372. }
  1374. /**
  1375.  * Remove controls from the non-camera object.
  1376.  * @param {Object3D} obj Object.
  1377.  */
  1378. exports.disable_object_controls = function(obj) {
  1379.     var obj_std_manifolds = ["FORWARD", "BACKWARD", "LEFT", "RIGHT"];
  1381.     for (var i = 0; i < obj_std_manifolds.length; i++)
  1382.         m_ctl.remove_sensor_manifold(obj, obj_std_manifolds[i]);
  1383. }
  1385. /**
  1386.  * Enable debug controls:
  1387.  * <ul>
  1388.  * <li>K - make camera debug shot
  1389.  * <li>L - make light debug shot
  1390.  * <li>M - flashback messages
  1391.  * </ul>
  1392.  */
  1393. exports.enable_debug_controls = function() {
  1394.     m_ctl.create_kb_sensor_manifold(null, "CAMERA_SHOT", m_ctl.CT_SHOT,
  1395.             m_ctl.KEY_K, function() {m_dbg.make_camera_frustum_shot();});
  1397.     m_ctl.create_kb_sensor_manifold(null, "LIGHT_SHOT", m_ctl.CT_SHOT,
  1398.             m_ctl.KEY_L, function() {m_dbg.make_light_frustum_shot();});
  1400.     m_ctl.create_kb_sensor_manifold(null, "TELEMETRY", m_ctl.CT_SHOT,
  1401.             m_ctl.KEY_T, function() {m_dbg.plot_telemetry();});
  1402. }
  1404. /**
  1405.  * Request fullscreen mode.
  1406.  * Security issues: execute by user event.
  1407.  * @method module:app.request_fullscreen
  1408.  * @param {HTMLElement} elem Element
  1409.  * @param {FullscreenEnabledCallback} enabled_cb Enabled callback
  1410.  * @param {FullscreenDisabledCallback} disabled_cb Disabled callback
  1411.  * @deprecated Use {@link module:screen.request_fullscreen} instead
  1412.  */
  1413. exports.request_fullscreen = function(elem, enabled_cb, disabled_cb) {
  1414.     m_print.error_deprecated("request_fullscreen", "screen.request_fullscreen");
  1415.     m_screen.request_fullscreen(elem, enabled_cb, disabled_cb);
  1416. };
  1418. /**
  1419.  * Exit fullscreen mode.
  1420.  * @method module:app.exit_fullscreen
  1421.  * @deprecated Use {@link module:screen.exit_fullscreen} instead
  1422.  */
  1423. exports.exit_fullscreen = function() {
  1424.     m_print.error_deprecated("exit_fullscreen", "screen.exit_fullscreen");
  1425.     m_screen.exit_fullscreen();
  1426. };
  1428. /**
  1429.  * Check whether fullscreen mode is available.
  1430.  * @method module:app.check_fullscreen
  1431.  * @returns {boolean} Result of the check.
  1432.  * @deprecated Use {@link module:screen.check_fullscreen} instead
  1433.  */
  1434. exports.check_fullscreen = function() {
  1435.     m_print.error_deprecated("check_fullscreen", "screen.check_fullscreen");
  1436.     return m_screen.check_fullscreen();
  1437. };
  1439. exports.report_app_error = report_app_error;
  1440. /**
  1441.  * Report an application error.
  1442.  * Creates standard HTML elements with error info and inserts them into the page body.
  1443.  * @method module:app.report_app_error
  1444.  * @param {string} text_message Message to place on upper element.
  1445.  * @param {string} link_message Message to place on bottom element.
  1446.  * @param {string} link Link to place on bottom element.
  1447.  * @param {string[]} purge_elements Array of element IDs to destroy just before the error
  1448.  * elements are inserted.
  1449.  */
  1450. function report_app_error(text_message, link_message, link, purge_elements) {
  1452.     var elem = document.createElement("div");
  1453.     var top_elem = document.createElement("div");
  1454.     var bottom_elem = document.createElement("div");
  1456.     if (purge_elements) {
  1457.         for (var i = 0; i < purge_elements.length; i++) {
  1458.             var purge_elem = document.getElementById(purge_elements[i]);
  1460.             if (purge_elem)
  1461.                 purge_elem.parentNode.removeChild(purge_elem);
  1462.         }
  1463.     }
  1465.     elem.style.cssText = "z-index:10;width:100%;height:auto;position:absolute;top:50%;margin-top:150px;text-align:center;";
  1466.     top_elem.style.cssText = "color:#fff;font-size:24px;";
  1467.     bottom_elem.style.cssText = "color:#fff;font-size:20px;";
  1469.     top_elem.innerHTML = text_message;
  1470.     bottom_elem.innerHTML = link_message + '   ' + '<a style="color:#fff;font-size:20px;width:100%;" href="' + link + '">'+link.replace("https://www.", "")+'</a>';
  1472.     elem.appendChild(top_elem);
  1473.     elem.appendChild(bottom_elem);
  1475.     document.body.appendChild(elem);
  1476. }
  1478. /**
  1479.  * Retrieve parameters of the page's URL.
  1480.  * @param {boolean} [allow_param_array=false] Create arrays of parameters if they share the same name.
  1481.  * @returns {Object|Null} URL parameters in a key-value format.
  1482.  */
  1483. exports.get_url_params = function(allow_param_array) {
  1484.     allow_param_array = !!allow_param_array;
  1486.     var url = decodeURIComponent(location.href.toString());
  1488.     if (url.indexOf("?") == -1)
  1489.         return null;
  1491.     var params = url.split("?")[1].split("&");
  1492.     var out = {};
  1494.     for (var i = 0; i < params.length; i++) {
  1495.         var param = params[i].split("=");
  1496.         var prop_name = param[0];
  1498.         if (param.length > 1) {
  1499.             var prop_val = param[1];
  1501.             if (allow_param_array) {
  1502.                 if (prop_name in out)
  1503.                     out[prop_name].push(prop_val);
  1504.                 else
  1505.                     out[prop_name] = [prop_val];
  1506.             } else
  1507.                 out[prop_name] = prop_val;
  1508.         } else {
  1509.             if (allow_param_array) {
  1510.                 if (!(prop_name in out))
  1511.                     out[prop_name] = [];
  1512.             } else
  1513.                 out[prop_name] = '';
  1514.         }
  1515.     }
  1517.     return out;
  1518. }
  1519. /**
  1520.  * Animate css-property value.
  1521.  * @method module:app.css_animate
  1522.  * @param {HTMLElement} elem HTML-element.
  1523.  * @param {string} prop Animated css-property.
  1524.  * @param {number} from Value from.
  1525.  * @param {number} to Value to.
  1526.  * @param {number} timeout Time for animation.
  1527.  * @param {string} [opt_prefix] Prefix of css-property (" scale(", "%" and etc).
  1528.  * @param {string} [opt_suffix] Suffix of css-property (" px", "%" and etc).
  1529.  * @param {GenericCallback} [opt_callback] Finish callback function.
  1530.  */
  1531. exports.css_animate = function(elem, prop, from, to, timeout, opt_prefix, opt_suffix, opt_callback) {
  1532.     if (!elem || !prop || !isFinite(from) || !isFinite(to) || !isFinite(timeout))
  1533.         return;
  1535.     opt_prefix   = opt_prefix || "";
  1536.     opt_suffix   = opt_suffix || "";
  1537.     opt_callback = opt_callback || function() {};
  1539.     var elem_style  = elem.style;
  1540.     var vendor_prop = prop.charAt(0).toUpperCase() + prop.slice(1);
  1542.     if (elem_style[prop] != undefined) {
  1544.     } else if (elem_style["webkit" + vendor_prop] != undefined) {
  1545.         prop = "webkit" + vendor_prop;
  1546.     } else if (elem_style["ms" + vendor_prop] != undefined) {
  1547.         prop = "ms" + vendor_prop;
  1548.     } else if (elem_style["moz" + vendor_prop] != undefined) {
  1549.         prop = "moz" + vendor_prop;
  1550.     } else
  1551.         return;
  1553.     function css_anim_cb(val) {
  1554.         if (!elem)
  1555.             return;
  1557.         elem_style[prop] = opt_prefix + val + opt_suffix;
  1559.         if (from > to && val <= to || from < to && val >= to) {
  1560.             elem_style[prop] = opt_prefix + to + opt_suffix;
  1561.             opt_callback();
  1562.         }
  1563.     }
  1565.     animate(elem, from, to, timeout, css_anim_cb);
  1566. }
  1568. /**
  1569.  * Animate html tag attribute.
  1570.  * @method module:app.attr_animate
  1571.  * @param {HTMLElement} elem HTML-element.
  1572.  * @param {string} attr_name Animated attribute name.
  1573.  * @param {number} from Value from.
  1574.  * @param {number} to Value to.
  1575.  * @param {number} timeout Time for animation.
  1576.  * @param {GenericCallback} [opt_callback] Finish callback function.
  1577.  */
  1578. exports.attr_animate = function(elem, attr_name, from, to, timeout, opt_callback) {
  1579.     if (!elem || !attr_name || !isFinite(from) || !isFinite(to) || !isFinite(timeout))
  1580.         return;
  1582.     opt_callback = opt_callback || function() {};
  1584.     function attr_anim_cb(val) {
  1585.         if (!elem)
  1586.             return;
  1588.         if (val >= 0)
  1589.             elem.setAttribute(attr_name, val);
  1591.         if (from > to && val <= to || from < to && val >= to) {
  1592.             elem.setAttribute(attr_name, to);
  1593.             opt_callback();
  1594.         }
  1595.     }
  1597.     animate(elem, from, to, timeout, attr_anim_cb);
  1598. }
  1600. // Animate value from "from" to "to" for "timeout" mseconds.
  1601. function animate(elem, from, to, timeout, anim_cb) {
  1602.     var start = performance.now();
  1604.     function cb() {
  1605.         var elapsed_total = performance.now() - start;
  1606.         var value = from + elapsed_total * (to - from) / timeout;
  1608.         anim_cb(value);
  1610.         if (elapsed_total >= timeout || !elem.parentNode)
  1611.             m_main.remove_loop_cb(cb);
  1612.     }
  1614.     m_main.append_loop_cb(cb);
  1615. }
  1617. /**
  1618.  * Animation finish callback.
  1619.  * @callback AnimFinishCallback
  1620.  */
  1622. /**
  1623.  * Queue object params.
  1624.  * @typedef {Object} QueueObject
  1625.  * @property {string} type Animation type.
  1626.  * @property {HTMLElement} elem Animated html element.
  1627.  * @property {string} prop Animated property.
  1628.  * @property {number} from Initial property value.
  1629.  * @property {number} to Target property value.
  1630.  * @property {number} duration Animation duration in ms.
  1631.  * @property {string} [opt_prefix=''] Prefix for the css property.
  1632.  * @property {string} [opt_suffix=''] Prefix for the css property.
  1633.  * @property {AnimFinishCallback} [cb=function(){}] Animation finish callback.
  1634.  */
  1636. /**
  1637.  * Animate queue of the html elements.
  1638.  * @method module:app.queue_animate
  1639.  * @param {QueueObject[]} queue Array of the queue objects.
  1640.  */
  1641. exports.queue_animate = function(queue) {
  1642.     if (!queue.length)
  1643.         return;
  1645.     var queue_obj = queue.shift();
  1647.     var elem     = queue_obj.elem;
  1648.     var prop     = queue_obj.prop;
  1649.     var from     = queue_obj.from;
  1650.     var to       = queue_obj.to;
  1651.     var duration = queue_obj.duration;
  1653.     var prefix = queue_obj.opt_prefix;
  1654.     var suffix = queue_obj.opt_suffix;
  1656.     var cb = function() {
  1657.         if (queue_obj.cb)
  1658.             queue_obj.cb();
  1660.         exports.queue_animate(queue);
  1661.     }
  1663.     if (queue_obj.type == "css")
  1664.         exports.css_animate(elem, prop, from, to, duration, prefix, suffix, cb);
  1665.     else if (queue_obj.type == "attr")
  1666.         exports.attr_animate(elem, prop, from, to, duration, cb);
  1667. }
  1669. function smooth_coeff_zoom_mouse() {
  1670.     return CAM_SMOOTH_ZOOM_MOUSE * _smooth_factor;
  1671. }
  1673. function smooth_coeff_zoom_touch() {
  1674.     return CAM_SMOOTH_ZOOM_TOUCH * _smooth_factor;
  1675. }
  1677. function smooth_coeff_rot_trans_mouse() {
  1678.     return CAM_SMOOTH_ROT_TRANS_MOUSE * _smooth_factor;
  1679. }
  1681. function smooth_coeff_rot_trans_touch() {
  1682.     return CAM_SMOOTH_ROT_TRANS_TOUCH * _smooth_factor;
  1683. }
  1685. /**
  1686.  * Set smooth factor for camera rotation and zoom.
  1687.  * @method module:app.set_camera_smooth_factor
  1688.  * @param {number} value New smooth factor
  1689.  */
  1690. exports.set_camera_smooth_factor = function(value) {
  1691.     _smooth_factor = value;
  1692. }
  1694. /**
  1695.  * Get smooth factor for camera rotation and zoom.
  1696.  * @method module:app.get_camera_smooth_factor
  1697.  * @returns {number} Smooth factor
  1698.  */
  1699. exports.get_camera_smooth_factor = function() {
  1700.     return _smooth_factor;
  1701. }
  1703. }
  1705. var app_factory = register("app", App);
  1707. export default app_factory;