Source: addons/camera_anim.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_print_fact from "../intern/print.js";
  6. import m_scs_fact from "../extern/scenes.js";
  7. import m_time_fact from "../extern/time.js";
  8. import m_trans_fact from "../extern/transform.js";
  9. import m_tsr_fact from "../extern/tsr.js";
  10. import m_util_fact from "../extern/util.js";
  11. import * as m_vec3 from "../libs/gl_matrix/vec3.js";
  13. /**
  14.  * Camera animation add-on.
  15.  * Implements procedural animation for the camera.
  16.  * @module camera_anim
  17.  * @local TrackToTargetZoomCallback
  18.  * @local TrackToTargetCallback
  19.  * @local AutoRotateDisabledCallback
  20.  * @local MoveCameraToPointCallback
  21.  * @local RotateCameraCallback
  22.  */
  23. function Camera_anim(ns, exports) {
  25. var m_cam   = m_cam_fact(ns);
  26. var m_ctl   = m_ctl_fact(ns);
  27. var m_print = m_print_fact(ns);
  28. var m_scs   = m_scs_fact(ns);
  29. var m_time  = m_time_fact(ns);
  30. var m_trans = m_trans_fact(ns);
  31. var m_tsr   = m_tsr_fact(ns);
  32. var m_util  = m_util_fact(ns);
  34. var ROTATION_OFFSET = 0.2;
  35. var ROTATION_LIMITS_EPS = 1E-6;
  36. var DEFAULT_CAM_LIN_SPEED = 1;
  37. var DEFAULT_CAM_ANGLE_SPEED = 0.01;
  38. var DEFAULT_CAM_ROTATE_TIME = 1000;
  40. // cache vars
  41. var _vec2_tmp           = new Float32Array(2);
  42. var _vec2_tmp2          = new Float32Array(2);
  43. var _vec3_tmp           = new Float32Array(3);
  44. var _vec3_tmp2          = new Float32Array(3);
  45. var _vec3_tmp3          = new Float32Array(3);
  46. var _tsr_tmp            = m_tsr.create();
  47. var _tsr_tmp2           = m_tsr.create();
  48. var _tsr_tmp3           = m_tsr.create();
  50. var _limits_tmp = {};
  52. var _is_camera_moving = false;
  53. var _is_camera_rotating = false;
  55. var _is_camera_stop_moving = false;
  56. var _is_camera_stop_rotating = false;
  58. /**
  59.  * Callback to be executed when the camera finishes its track animation.
  60.  * See track_to_target() method.
  61.  * @callback TrackToTargetCallback
  62.  */
  64. /**
  65.  * Callback to be executed when the camera finishes its zoom-in animation.
  66.  * See track_to_target() method.
  67.  * @callback TrackToTargetZoomCallback
  68.  */
  71. /**
  72.  * Smoothly rotate the EYE camera to make it pointing at the specified
  73.  * target (an object or some position). Then smoothly zoom on this target,
  74.  * pause and zoom back.
  75.  * @param {Object3D} cam_obj Camera object 3D
  76.  * @param {(Object3D|Vec3)} target Target object or target position
  77.  * @param {?number} [rot_speed=1] Rotation speed, radians per second
  78.  * @param {?number} [zoom_mult=2] Zoom level value
  79.  * @param {?number} [zoom_time=1] Time it takes to zoom on the target, seconds
  80.  * @param {?number} [zoom_delay=1] Delay before the camera zooms back, seconds
  81.  * @param {?TrackToTargetCallback} [track_cb] Track finishing callback
  82.  * @param {?TrackToTargetZoomCallback} [zoom_in_cb] Zoom-in callback
  83.  */
  84. exports.track_to_target = function(cam_obj, target, rot_speed, zoom_mult, 
  85.         zoom_time, zoom_delay, track_cb, zoom_in_cb) {
  87.     if (!m_cam.is_eye_camera(cam_obj)) {
  88.         m_print.error("track_to_target(): Wrong camera object or camera move style");
  89.         return;
  90.     }
  92.     if (m_util.is_vector(target))
  93.         var obj_pos = target;
  94.     else {
  95.         var obj_pos = _vec3_tmp;
  96.         m_trans.get_object_center(target, false, obj_pos);
  97.     }
  99.     rot_speed  = rot_speed  || 1;
  100.     zoom_mult  = zoom_mult  || 2;
  101.     zoom_time  = zoom_time  || 1;
  102.     zoom_delay  = zoom_delay || 1;
  104.     var cam_pos = m_trans.get_translation(cam_obj, _vec3_tmp2);
  105.     var dir_to_target = m_vec3.subtract(obj_pos, cam_pos, _vec3_tmp3);
  107.     var start_angles = m_cam.get_camera_angles(cam_obj, _vec2_tmp);
  108.     var finish_angles = m_cam.get_camera_angles_dir(dir_to_target, _vec2_tmp2);
  110.     var phi_angle = finish_angles[0] - start_angles[0];
  111.     var theta_angle = finish_angles[1] - start_angles[1];
  113.     // calculate arc angle on a unit sphere using the spherical law of cosines
  114.     var arc_angle = Math.acos(Math.cos(phi_angle) * Math.cos(theta_angle));
  115.     var rot_time = Math.abs(arc_angle / rot_speed);
  117.     var zoom_dist = m_vec3.length(dir_to_target) * (1 - 1 / zoom_mult);
  120.     var smooth_function = function(x) {
  121.         var f = 6 * x * (1 - x);
  122.         return f;
  123.     }
  125.     var _start_time = m_time.get_timeline();
  126.     var _stage = 0;
  127.     var track_to_target_cb = function(obj, id, pulse) {
  128.         // NOTE: if move_style was changed during the tracking
  129.         if (!m_cam.is_eye_camera(obj)) {
  130.             disable_cb();
  131.             return;
  132.         }
  134.         if (pulse == 1) {
  135.             var curr_time = m_ctl.get_sensor_value(obj, id, 0) - _start_time;
  136.             var elapsed = m_ctl.get_sensor_value(obj, id, 1);
  138.             if (curr_time < rot_time) {
  139.                 var smooth_coeff = smooth_function(curr_time / rot_time);
  140.                 var phi_delta = smooth_coeff * phi_angle * elapsed / rot_time;
  141.                 var theta_delta = smooth_coeff * theta_angle * elapsed / rot_time;
  142.                 m_cam.rotate_camera(cam_obj, phi_delta, theta_delta);
  143.             } else if (curr_time < rot_time + zoom_time) {
  145.                 if (_stage == 0) {
  146.                     m_cam.rotate_camera(cam_obj, finish_angles[0], finish_angles[1], true);
  147.                     _stage++;
  148.                 }
  150.                 var smooth_coeff = smooth_function(curr_time - rot_time / zoom_time);
  151.                 var delta_dist = smooth_coeff * zoom_dist * elapsed / zoom_time;
  152.                 m_trans.move_local(obj, 0, 0, -delta_dist);
  153.             } else if (curr_time < rot_time + zoom_time + zoom_delay) {
  154.                 if (_stage <= 1) {
  155.                     m_cam.rotate_camera(cam_obj, finish_angles[0], finish_angles[1], true);
  156.                     m_cam.eye_set_look_at(cam_obj, cam_pos);
  157.                     m_trans.move_local(obj, 0, 0, -zoom_dist);
  158.                     if (zoom_in_cb)
  159.                         zoom_in_cb();
  160.                     
  161.                     _stage++;
  162.                 }
  163.             } else if (curr_time < rot_time + zoom_time + zoom_delay + zoom_time) {
  164.                 if (_stage <= 2) {
  165.                     m_cam.rotate_camera(cam_obj, finish_angles[0], finish_angles[1], true);
  166.                     m_cam.eye_set_look_at(cam_obj, cam_pos);
  167.                     m_trans.move_local(obj, 0, 0, -zoom_dist);
  168.                     _stage++;
  169.                 }
  170.                 var smooth_coeff = smooth_function(curr_time - rot_time - zoom_time - zoom_delay / zoom_time);
  171.                 var delta_dist = smooth_coeff * zoom_dist * elapsed / zoom_time;
  172.                 m_trans.move_local(obj, 0, 0, delta_dist);
  173.             } else {
  174.                 m_cam.rotate_camera(cam_obj, finish_angles[0], finish_angles[1], true);
  175.                 m_cam.eye_set_look_at(cam_obj, cam_pos);
  176.                 disable_cb();
  177.             }
  178.         }
  179.     }
  181.     var disable_cb = function() {
  182.         m_ctl.remove_sensor_manifold(cam_obj, "TRACK_TO_TARGET");
  183.         if (track_cb)
  184.             track_cb();
  185.     }
  187.     var timeline = m_ctl.create_timeline_sensor();
  188.     var elapsed = m_ctl.create_elapsed_sensor();
  189.     m_ctl.create_sensor_manifold(cam_obj, "TRACK_TO_TARGET", m_ctl.CT_CONTINUOUS,
  190.             [timeline, elapsed], null, track_to_target_cb);
  191. }
  193. function init_limited_rotation_ratio(obj, limits, auto_rotate_ratio) {
  194.     var phi = m_cam.get_camera_angles(obj, _vec2_tmp)[0];
  196.     var delts = get_delta_to_limits(obj, phi, limits.left, limits.right, _vec2_tmp2);
  198.     return auto_rotate_ratio * Math.min(1, delts[0] / ROTATION_OFFSET,
  199.             delts[1] / ROTATION_OFFSET);
  200. }
  202. function get_delta_to_limits(obj, angle, limit_left, limit_right, dest) {
  203.     // accurate delta calculation
  204.     var diff_left = m_util.angle_wrap_0_2pi(angle - limit_left);
  205.     var delta_to_left = Math.min(diff_left, 2 * Math.PI - diff_left);
  206.     var diff_right = m_util.angle_wrap_0_2pi(limit_right - angle);
  207.     var delta_to_right = Math.min(diff_right, 2 * Math.PI - diff_right);
  209.     // some precision errors could be near the limits
  210.     if (Math.abs(delta_to_left) < ROTATION_LIMITS_EPS 
  211.             || 2 * Math.PI - Math.abs(delta_to_left) < ROTATION_LIMITS_EPS)
  212.         delta_to_left = 0;
  213.     if (Math.abs(delta_to_right) < ROTATION_LIMITS_EPS 
  214.             || 2 * Math.PI - Math.abs(delta_to_right) < ROTATION_LIMITS_EPS)
  215.         delta_to_right = 0;
  217.     if (m_cam.is_eye_camera(obj)) {
  218.         dest[0] = delta_to_right; // to min angle
  219.         dest[1] = delta_to_left; // to max angle
  220.     } else {
  221.         dest[0] = delta_to_left; // to min angle
  222.         dest[1] = delta_to_right; // to max angle
  223.     }
  225.     return dest;
  226. }
  228. /**
  229.  * Callback to be executed when auto-rotating is disabled.
  230.  * It is fired when either the user manually rotates the camera,
  231.  * or the auto_rotate() method is executed again.
  232.  * @callback AutoRotateDisabledCallback
  233.  */
  235. /**
  236.  * Switch auto-rotation of the TARGET or HOVER camera around its pivot, or
  237.  * auto-rotating of the EYE camera around itself.
  238.  * When it is called for the first time, auto-rotation is enabled
  239.  * while the next call will disable auto-rotation.
  240.  * @param {number} auto_rotate_ratio Rotation speed multiplier
  241.  * @param {AutoRotateDisabledCallback} [callback] Callback to be executed when auto-rotation is disabled
  242.  * @param {boolean} [disable_on_mouse_wheel] Disable camera auto-rotation after mouse scrolling.
  243.  */
  244. exports.auto_rotate = function(auto_rotate_ratio, callback, disable_on_mouse_wheel) {
  246.     callback = callback || function(){};
  248.     var obj = m_scs.get_active_camera();
  250.     if (m_cam.is_static_camera(obj)) {
  251.         m_print.error("auto_rotate(): Wrong camera move style");
  252.         return;
  253.     }
  255.     var angle_limits = {};
  256.     var rot_offset = 0;
  257.     var cur_rotate_ratio = 0;
  259.     function update_limited_rotation_params(curr_limits) {
  260.         angle_limits = angle_limits || {};
  261.         angle_limits.left = curr_limits.left;
  262.         angle_limits.right = curr_limits.right;
  263.         rot_offset = Math.min(ROTATION_OFFSET,
  264.                 (m_util.angle_wrap_0_2pi(angle_limits.right - angle_limits.left)) / 2);
  265.         cur_rotate_ratio = init_limited_rotation_ratio(obj,
  266.                 angle_limits, auto_rotate_ratio);
  267.     }
  269.     function elapsed_cb(obj, id, pulse) {
  270.         if (pulse == 1) {
  271.             var move_style = m_cam.get_move_style(obj);
  272.             // NOTE: if move_style was changed to STATIC during the autorotation
  274.             if (move_style == m_cam.MS_STATIC)
  275.                 disable_cb();
  276.             else if ((move_style == m_cam.MS_TARGET_CONTROLS 
  277.                     || move_style == m_cam.MS_EYE_CONTROLS) 
  278.                     && m_cam.has_horizontal_rot_limits(obj)) {
  280.                 var curr_limits = (move_style == m_cam.MS_EYE_CONTROLS) 
  281.                         ? m_cam.eye_get_horizontal_limits(obj, _limits_tmp)
  282.                         : m_cam.target_get_horizontal_limits(obj, _limits_tmp);
  284.                 if (angle_limits === null || curr_limits.left != angle_limits.left
  285.                         || curr_limits.right != angle_limits.right)
  286.                     update_limited_rotation_params(curr_limits);
  287.                 limited_auto_rotate(obj, id);
  288.             } else {
  289.                 angle_limits = null;
  290.                 unlimited_auto_rotate(obj, id);
  291.             }
  292.         }
  293.     }
  295.     function limited_auto_rotate(obj, id) {
  296.         var value = m_ctl.get_sensor_value(obj, id, 0);
  298.         var phi = m_cam.get_camera_angles(obj, _vec2_tmp)[0];
  299.         var delts = get_delta_to_limits(obj, phi, angle_limits.left, angle_limits.right,
  300.                 _vec2_tmp2);
  302.         if (delts[1] > rot_offset 
  303.                 && delts[0] > rot_offset)
  304.             cur_rotate_ratio = m_util.sign(cur_rotate_ratio) * auto_rotate_ratio;
  306.         else if (delts[1] < rot_offset)
  307.             cur_rotate_ratio = cur_rotate_ratio - 
  308.                     Math.pow(auto_rotate_ratio, 2) / (2 * ROTATION_OFFSET) * value;
  310.         else if (delts[0] < rot_offset)
  311.             cur_rotate_ratio = cur_rotate_ratio +
  312.                     Math.pow(auto_rotate_ratio, 2) / (2 * ROTATION_OFFSET) * value;
  314.         m_cam.rotate_camera(obj, value * cur_rotate_ratio, 0);
  315.     }
  317.     function unlimited_auto_rotate(obj, id) {
  318.         var value = m_ctl.get_sensor_value(obj, id, 0);
  319.         m_cam.rotate_camera(obj, value * auto_rotate_ratio, 0);
  320.     }
  322.     function disable_cb() {
  323.         m_ctl.remove_sensor_manifold(obj, "AUTO_ROTATE");
  324.         m_ctl.remove_sensor_manifold(obj, "DISABLE_AUTO_ROTATE");
  326.         callback();
  327.     }
  329.     if (!m_ctl.check_sensor_manifold(obj, "AUTO_ROTATE")) {
  330.         var mouse_move_x = m_ctl.create_mouse_move_sensor("X");
  331.         var mouse_move_y = m_ctl.create_mouse_move_sensor("Y");
  332.         var mouse_down   = m_ctl.create_mouse_click_sensor();
  333.         var touch_move   = m_ctl.create_touch_move_sensor();
  334.         var touch_zoom   = m_ctl.create_touch_zoom_sensor();
  335.         var elapsed      = m_ctl.create_elapsed_sensor();
  337.         if (disable_on_mouse_wheel)
  338.             var wheel_zoom = m_ctl.create_mouse_wheel_sensor();
  339.         else
  340.             var wheel_zoom = m_ctl.create_custom_sensor(0);
  342.         var logic_func = function(s) {return (s[0] && s[2]) || (s[1] && s[2]) || s[3] || s[4] || s[5]};
  344.         m_ctl.create_sensor_manifold(obj, "DISABLE_AUTO_ROTATE", m_ctl.CT_LEVEL,
  345.                                     [mouse_move_x, mouse_move_y, mouse_down,
  346.                                     touch_move, touch_zoom, wheel_zoom], logic_func,
  347.                                     disable_cb);
  349.         m_ctl.create_sensor_manifold(obj, "AUTO_ROTATE", m_ctl.CT_CONTINUOUS,
  350.                                     [elapsed], function(s) {return s[0]},
  351.                                     elapsed_cb);
  352.     } else
  353.         disable_cb();
  354. }
  356. /**
  357.  * Check if the camera is auto-rotating.
  358.  * @method module:camera_anim.is_auto_rotate
  359.  * @returns {boolean} Result of the check: true - when the camera is
  360.  * auto-rotating, false - otherwise.
  361.  */
  362. exports.is_auto_rotate = function() {
  363.     var obj = m_scs.get_active_camera();
  365.     return m_ctl.check_sensor_manifold(obj, "AUTO_ROTATE");
  366. }
  368. /**
  369.  * Check if auto-rotation is possible for the camera.
  370.  * For example, the STATIC camera cannot be rotated.
  371.  * @method module:camera_anim.check_auto_rotate
  372.  * @returns {boolean} Result of the check: true - when auto-rotation is
  373.  * possible, false - otherwise.
  374.  */
  375. exports.check_auto_rotate = function() {
  376.     var obj = m_scs.get_active_camera();
  377.     var cam_type = m_cam.get_move_style(obj);
  379.     if (cam_type == m_cam.MS_STATIC)
  380.         return false;
  382.     return true;
  383. }
  385. /**
  386.  * Callback to be executed when camera is finishes its moving animation.
  387.  * See move_camera_to_point() method
  388.  * @callback MoveCameraToPointCallback
  389.  */
  391. /**
  392.  * Smoothly move the camera to the target point. Intended for STATIC cameras only.
  393.  * @param {(Object3D|tsr)} cam_obj Camera object 3D
  394.  * @param {(Object3D|tsr)} point_obj Target point object 3D
  395.  * @param {number} cam_lin_speed Camera linear speed, meters per second
  396.  * @param {number} cam_angle_speed Camera angular speed, radians per second
  397.  * @param {MoveCameraToPointCallback} [cb] Finishing callback
  398.  */
  399. exports.move_camera_to_point = function(cam_obj, point_obj, cam_lin_speed, cam_angle_speed, cb) {
  400.     if (m_cam.get_move_style(cam_obj) != m_cam.MS_STATIC) {
  401.         m_print.error("move_camera_to_point(): wrong camera type");
  403.         return;
  404.     }
  406.     if (_is_camera_moving)
  407.         return;
  409.     if (!cam_obj) {
  410.         m_print.error("move_camera_to_point(): you must specify the camera object");
  412.         return;
  413.     }
  415.     if (!point_obj) {
  416.         m_print.error("move_camera_to_point(): you must specify the point object");
  418.         return;
  419.     }
  421.     cam_lin_speed   = cam_lin_speed || DEFAULT_CAM_LIN_SPEED;
  422.     cam_angle_speed = cam_angle_speed || DEFAULT_CAM_ANGLE_SPEED;
  424.     if (m_util.is_vector(cam_obj))
  425.         var cam_tsr = cam_obj;
  426.     else
  427.         var cam_tsr = m_trans.get_tsr(cam_obj, _tsr_tmp);
  429.     if (m_util.is_vector(point_obj))
  430.         var point_tsr = point_obj;
  431.     else
  432.         var point_tsr = m_trans.get_tsr(point_obj, _tsr_tmp2);
  434.     var distance  = m_vec3.distance(m_tsr.get_trans_view(cam_tsr),
  435.                                     m_tsr.get_trans_view(point_tsr));
  436.     var move_time = distance / cam_lin_speed;
  438.     var current_cam_dir = m_util.quat_to_dir(m_tsr.get_quat_view(cam_tsr),
  439.                                              m_util.AXIS_MZ, _vec3_tmp);
  440.     var target_cam_dir  = m_util.quat_to_dir(m_tsr.get_quat_view(point_tsr),
  441.                                              m_util.AXIS_MZ, _vec3_tmp2);
  443.     var vec_dot     = Math.min(Math.abs(m_vec3.dot(current_cam_dir,
  444.                                                    target_cam_dir)), 1);
  445.     var angle       = Math.acos(vec_dot);
  446.     var rotate_time = angle / cam_angle_speed;
  448.     var time = Math.max(move_time, rotate_time) * 1000;
  450.     _is_camera_moving = true;
  452.     var cur_animator = m_time.animate(0, 1, time, function(e) {
  453.         var new_tsr = m_tsr.interpolate(cam_tsr, point_tsr,
  454.                                         m_util.smooth_step(e), _tsr_tmp3);
  456.         if (_is_camera_stop_moving) {
  457.             m_time.clear_animation(cur_animator);
  458.             _is_camera_stop_moving = false;
  459.             _is_camera_moving = false;
  461.             return;
  462.         }
  464.         m_trans.set_tsr(cam_obj, new_tsr);
  466.         if (e == 1) {
  467.             _is_camera_moving = false;
  469.             if (cb)
  470.                 cb();
  471.         }
  472.     });
  473. }
  475. /**
  476.  * Callback to be executed when camera is finishes its rotate animation.
  477.  * See rotate_camera() method
  478.  * @callback RotateCameraCallback
  479.  */
  481. /**
  482.  * Smoothly rotate the camera. Intended for non-STATIC cameras.
  483.  * @param {Object3D} cam_obj Camera object 3D
  484.  * @param {number} angle_phi Horizontal rotation angle (in radians)
  485.  * @param {number} angle_theta Vertical rotation angle (in radians)
  486.  * @param {number} [time=1000] Rotation time in ms
  487.  * @param {RotateCameraCallback} [cb] Finishing callback
  488.  */
  489. exports.rotate_camera = function(cam_obj, angle_phi, angle_theta, time, cb) {
  490.     if (m_cam.get_move_style(cam_obj) == m_cam.MS_STATIC) {
  491.         m_print.error("rotate_camera(): not supported for STATIC cameras");
  492.         return;
  493.     }
  495.     if (_is_camera_rotating)
  496.         return;
  498.     if (!cam_obj) {
  499.         m_print.error("rotate_camera(): you must specify the camera object");
  501.         return;
  502.     }
  504.     if (!angle_phi && !angle_theta) {
  505.         m_print.error("rotate_camera(): you must specify the rotation angle");
  507.         return;
  508.     }
  510.     time = time || DEFAULT_CAM_ROTATE_TIME;
  512.     _is_camera_rotating = true;
  514.     function fin_cb() {
  515.         if (_is_camera_rotating) {
  516.             _is_camera_rotating = false;
  518.             if (cb)
  519.                 cb();
  520.         }
  521.     }
  523.     var delta_phi   = 0;
  524.     var cur_animator_phi = m_time.animate(0, angle_phi, time, function(e) {
  525.         if (_is_camera_stop_rotating || e >= angle_phi) {
  526.             _is_camera_stop_rotating = false;
  527.             m_time.clear_animation(cur_animator_phi);
  528.             fin_cb();
  529.             return;
  530.         }
  532.         m_cam.rotate_camera(cam_obj, delta_phi - e, 0);
  533.         delta_phi = e;
  534.     });
  536.     var delta_theta = 0;
  537.     var cur_animator_theta = m_time.animate(0, angle_theta, time, function(e) {
  538.         if (_is_camera_stop_rotating || e >= angle_theta) {
  539.             _is_camera_stop_rotating = false;
  540.             m_time.clear_animation(cur_animator_theta);
  541.             fin_cb();
  542.             return;
  543.         }
  545.         m_cam.rotate_camera(cam_obj, 0, delta_theta - e);
  546.         delta_theta = e;
  547.     });
  548. }
  550. /**
  551.  * Stop camera moving.
  552.  * @method module:camera_anim.stop_cam_moving
  553.  */
  554. exports.stop_cam_moving = function() {
  555.     _is_camera_stop_moving = true;
  556. }
  558. /**
  559.  * Stop camera rotating.
  560.  * @method module:camera_anim.stop_cam_rotating
  561.  */
  562. exports.stop_cam_rotating = function() {
  563.     _is_camera_stop_rotating = true;
  564. }
  566. /**
  567.  * Check if the camera is being moved by the 
  568.  * {@link module:camera_anim.move_camera_to_point|move_camera_to_point} function.
  569.  * @method module:camera_anim.is_moving
  570.  * @returns {boolean} Result of the check: true - when the camera is
  571.  * moving, false - otherwise.
  572.  */
  573. exports.is_moving = function() {
  574.     return _is_camera_moving;
  575. }
  577. /**
  578.  * Check if the camera is being rotated by the 
  579.  * {@link module:camera_anim.rotate_camera|rotate_camera} function.
  580.  * @method module:camera_anim.is_rotating
  581.  * @returns {boolean} Result of the check: true - when the camera is
  582.  * rotating, false - otherwise.
  583.  */
  584. exports.is_rotating = function() {
  585.     return _is_camera_rotating;
  586. }
  588. }
  590. var camera_anim_factory = register("camera_anim", Camera_anim);
  592. export default camera_anim_factory;