Source: extern/camera.js

  1. import register from "../util/register.js";
  3. import m_cam_fact from "../intern/camera.js";
  4. import m_cont_fact from "../intern/container.js";
  5. import * as m_math from "../intern/math.js";
  6. import m_obj_util_fact from "../intern/obj_util.js";
  7. import m_phy_fact from "../intern/physics.js";
  8. import m_print_fact from "../intern/print.js";
  9. import m_scs_fact from "../intern/scenes.js";
  10. import m_trans_fact from "../intern/transform.js";
  11. import * as m_tsr from "../intern/tsr.js";
  12. import * as m_util from "../intern/util.js";
  13. import * as m_vec3 from "../libs/gl_matrix/vec3.js";
  14. import * as m_vec4 from "../libs/gl_matrix/vec4.js";
  15. import * as m_quat from "../libs/gl_matrix/quat.js";
  17. /**
  18.  * API for controlling the camera within the bounds of the current camera model.
  19.  * Use {@link module:transform|Transform API} for low-level actions.<br>
  20.  * All functions require a valid camera object reference. Use
  21.  * {@link module:scenes.get_object_by_name|scenes.get_object_by_name()} or
  22.  * {@link module:scenes.get_active_camera|scenes.get_active_camera()} to obtain it.
  23.  * The result of applying various transforms to a camera can be overridden by the 
  24.  * present camera limits.
  25.  * <p>
  26.  * <b>API examples for this module</b>: 
  27.  * {@link https://www.blend4web.com/doc/en/camera.html#camera-controls-api|English},
  28.  * {@link https://www.blend4web.com/doc/zh/camera.html#camera-controls-api|中文}, 
  29.  * {@link https://www.blend4web.com/doc/ru/camera.html#camera-controls-api|Русский}.
  30.  * </p>
  31.  * @module camera
  32.  * @local DistanceLimits
  33.  * @local VerticalRotationLimits
  34.  * @local HorizontalRotationLimits
  35.  * @local HoverAngleLimits
  36.  * @local VerticalTranslationLimits
  37.  * @local HorizontalTranslationLimits
  38.  * @local HoverCameraParams
  39.  * @local TargetCameraParams
  40.  * @local EyeCameraParams
  41.  * @local StaticCameraParams
  42.  * @local PivotLimits
  43.  * @local VelocityParams
  44.  * @local FrustumPlanes
  45.  */
  46. function Camera(ns, exports) {
  48. var m_cam      = m_cam_fact(ns);
  49. var m_cont     = m_cont_fact(ns);
  50. var m_obj_util = m_obj_util_fact(ns);
  51. var m_phy      = m_phy_fact(ns);
  52. var m_print    = m_print_fact(ns);
  53. var m_scs      = m_scs_fact(ns);
  54. var m_trans    = m_trans_fact(ns);
  56. var _vec2_tmp = new Float32Array(2);
  57. var _vec3_tmp = new Float32Array(3);
  58. var _vec3_tmp2 = new Float32Array(3);
  59. var _vec4_tmp = new Float32Array(4);
  60. var _quat_tmp = m_quat.create();
  61. var _limits_tmp = {};
  62. var _limits_tmp2 = {};
  64. /**
  65.  * An object that defines distance limits for the HOVER/TARGET camera.
  66.  * The "min" value must be less or equal than the "max" value.
  67.  * @typedef {Object} DistanceLimits
  68.  * @property {number} min The minimum distance to the pivot.
  69.  * @property {number} max The maximum distance to the pivot.
  70.  * @cc_externs min max
  71.  */
  73. /**
  74.  * An object that defines limits for rotations in a vertical plane for the TARGET/EYE camera.
  75.  * The limits are converted by engine into the range [-Pi, Pi] when set via API.
  76.  * @see https://www.blend4web.com/doc/en/camera.html#camera-spherical-coordinates
  77.  * @typedef {Object} VerticalRotationLimits
  78.  * @property {number} down The elevation angle in radians that restricts a downward rotation.
  79.  * @property {number} up The elevation angle in radians that restricts an upward rotation.
  80.  * @property {boolean} [camera_space=false] Define limits relative to the current
  81.  * camera position/orientation, otherwise - in world space (by default).
  82.  * @cc_externs down up camera_space
  83.  */
  85. /**
  86.  * An object that defines limits for rotations in a horizontal plane for the TARGET/EYE camera.
  87.  * The limits are converted by engine into the range [0, 2Pi] when set via API.
  88.  * @see https://www.blend4web.com/doc/en/camera.html#camera-spherical-coordinates
  89.  * @typedef {Object} HorizontalRotationLimits
  90.  * @property {number} left The azimuth angle in radians that restricts a leftward rotation.
  91.  * @property {number} right The azimuth angle in radians that restricts a rightward rotation.
  92.  * @property {boolean} [camera_space=false] Define limits relative to the current
  93.  * camera position/orientation, otherwise - in world space (by default).
  94.  * @cc_externs left right camera_space
  95.  */
  97. /**
  98.  * An object that defines limits for rotations in a vertical plane for the HOVER camera.
  99.  * The limits are converted by engine into the range [-Pi, Pi] and then clamped
  100.  * to be in range [-Pi/2, 0] when set via API.
  101.  * The "down" value must be greater or equal than the "up" value.
  102.  * @see https://www.blend4web.com/doc/en/camera.html#camera-spherical-coordinates
  103.  * @typedef {Object} HoverAngleLimits
  104.  * @property {number} down The elevation angle in radians that restricts a downward rotation.
  105.  * @property {number} up The elevation angle in radians that restricts an upward rotation.
  106.  * @cc_externs down up
  107.  */
  109. /**
  110.  * An object that defines limits for translations along the Z axis for the HOVER camera.
  111.  * The "min" value must be less or equal than the "max" value.
  112.  * @see https://www.blend4web.com/doc/en/camera.html#hover-translation-limits
  113.  * @typedef {Object} VerticalTranslationLimits
  114.  * @property {number} min The minimum value that restricts camera translation along the Z axis.
  115.  * @property {number} max The maximum value that restricts camera translation along the Z axis.
  116.  * @cc_externs min max
  117.  */
  119. /**
  120.  * An object that defines limits for translations along the X axis for the HOVER camera.
  121.  * The "min" value must be less or equal than the "max" value.
  122.  * @see https://www.blend4web.com/doc/en/camera.html#hover-translation-limits
  123.  * @typedef {Object} HorizontalTranslationLimits
  124.  * @property {number} min The minimum value that restricts camera translation along the X axis.
  125.  * @property {number} max The maximum value that restricts camera translation along the X axis.
  126.  * @cc_externs min max
  127.  */
  129. /**
  130.  * An object that defines limits for translations along the Y axis for the 
  131.  * camera pivot point.
  132.  * @typedef {Object} PivotLimits
  133.  * @property {number} min_z The minimum value that restricts pivot translation 
  134.  * along the Z axis.
  135.  * @property {number} max_z The maximum value that restricts pivot translation 
  136.  * along the Z axis.
  137.  * @cc_externs min_z max_z
  138.  */
  140. /**
  141.  * An object that defines velocity of the camera movement.
  142.  * @typedef {Object} VelocityParams
  143.  * @property {number} [trans=Current velocity value] Translation velocity ([0,Infinity]).
  144.  * @property {number} [rot=Current velocity value] Rotation velocity ([0,Infinity]).
  145.  * @property {number} [zoom=Current velocity value] Zoom velocity ([0,1]).
  146.  * @cc_externs trans rot zoom
  147.  */
  149. /**
  150.  * An object that defines the STATIC camera parameters.
  151.  * @typedef {Object} StaticCameraParams
  152.  * @property {?Vec3} [pos=null] Position of the camera. Set to null to keep the current 
  153.  * camera position.
  154.  * @property {?Vec3} [look_at=null] Point the camera is looking at. Set to null to 
  155.  * keep the existing camera orientation.
  156.  * @cc_externs pos look_at
  157.  */
  159. /**
  160.  * An object that defines the EYE camera parameters.
  161.  * @typedef {Object} EyeCameraParams
  162.  * @property {?Vec3} [pos=null] Position of the camera. Set to null to keep the 
  163.  * current camera position.
  164.  * @property {?Vec3} [look_at=null] Point the camera is looking at. Set to null 
  165.  * to keep the existing camera orientation.
  166.  * @property {?HorizontalRotationLimits} [horiz_rot_lim=null] Horizontal rotation 
  167.  * limits. Set to null to disable the limits.
  168.  * @property {?VerticalRotationLimits} [vert_rot_lim=null] Vertical rotation limits. 
  169.  * Set to null to disable the limits.
  170.  * @cc_externs pos look_at horiz_rot_lim vert_rot_lim
  171.  */
  173. /**
  174.  * An object that defines the TARGET camera parameters.
  175.  * @typedef {Object} TargetCameraParams
  176.  * @property {?Vec3} [pos=null] Position of the camera. Set to null to keep the 
  177.  * current camera position.
  178.  * @property {Vec3} [pivot=null] Camera pivot point. If set to null, when the 
  179.  * current view vector of unit length will be used to define the pivot point.
  180.  * @property {?HorizontalRotationLimits} [horiz_rot_lim=null] Horizontal 
  181.  * rotation limits. Set to null to disable the limits.
  182.  * @property {?VerticalRotationLimits} [vert_rot_lim=null] Vertical rotation 
  183.  * limits. Set to null to disable the limits.
  184.  * @property {?DistanceLimits} [dist_lim=null] Distance limits. Set to null to 
  185.  * disable the limits.
  186.  * @property {?PivotLimits} [pivot_lim=null] Pivot limits. Set to 
  187.  * null to disable the limits.
  188.  * @property {boolean} [use_panning=false] Use panning mode.
  189.  * @cc_externs pos pivot horiz_rot_lim vert_rot_lim dist_lim use_panning
  190.  */
  192. /**
  193.  * An object that defines the HOVER camera parameters.
  194.  * @typedef {Object} HoverCameraParams
  195.  * @property {?Vec3} [pos=null] Position of the camera. Set to null to keep the 
  196.  * current camera position.
  197.  * @property {Vec3} pivot Camera pivot point.
  198.  * @property {?DistanceLimits} [dist_lim=null] Distance limits. Set to null to 
  199.  * define the limits as fixed distance to the pivot which depends on the 
  200.  * given pivot and camera positions.
  201.  * @property {?HoverAngleLimits} [hover_angle_lim=null] Hover angle limits. 
  202.  * Set to null to define the limits as fixed angle which depends on the given 
  203.  * pivot and camera positions.
  204.  * @property {?HorizontalTranslationLimits} [horiz_trans_lim=null] Horizontal 
  205.  * translation limits. Set to null to disable the limits.
  206.  * @property {?VerticalTranslationLimits} [vert_trans_lim=null] Vertical 
  207.  * translation limits. Set to null to disable the limits.
  208.  * @property {boolean} [enable_horiz_rot=false] Enable horizontal rotation.
  209.  * @cc_externs pos pivot dist_lim hover_angle_lim horiz_trans_lim vert_trans_lim
  210.  * @cc_externs enable_horiz_rot
  211.  */
  213. /**
  214.  * An object that defines the HOVER camera parameters.
  215.  * @typedef {Object} HoverCameraParamsRel
  216.  * @property {?Vec3} [pos=null] Position of the camera. Set to null to keep the 
  217.  * current camera position.
  218.  * @property {Vec3} pivot Camera pivot point.
  219.  * @property {number} [dist_interval=0] A distance variation around the established 
  220.  * distance to the pivot: distance ± dist_interval/2. The resulted distance 
  221.  * limits are clamped to be in range [0, +∞].
  222.  * @property {number} [angle_interval=0] A hover angle variation (in radians)
  223.  * around the established hover angle: hover angle ± angle_interval/2. The 
  224.  * resulted hover angle limits are clamped to be in range [-PI/2, 0].
  225.  * @property {number} [t=0.5] An optional parameter which lies in range [0, 1] 
  226.  * and defines the disposition of the given angle and distance intervals around 
  227.  * the established values, for example: 
  228.  * 0 - the given camera position is the nearest zoomed-in point, 
  229.  * 1 - the given camera position is the farthest zoomed-out point, 
  230.  * 0.5 (by default) - the given camera position is in the middle of the given 
  231.  * intervals and can be zoomed equally in both directions.
  232.  * @cc_externs pos pivot dist_interval angle_interval t
  233.  */
  235.  /**
  236.  * Camera frustum planes object.
  237.  * @typedef {Object} FrustumPlanes
  238.  * @property {Plane} Left frustum plane.
  239.  * @property {Plane} Right frustum plane.
  240.  * @property {Plane} Top frustum plane.
  241.  * @property {Plane} Bottom frustum plane.
  242.  * @property {Plane} Near frustum plane.
  243.  * @property {Plane} Far frustum plane.
  244.  * @cc_externs left right top bottom near far
  245.  */
  247. /**
  248.  * The camera's movement style: STATIC (non-interactive).
  249.  * @const {CameraMoveStyle} module:camera.MS_STATIC
  250.  */
  251. exports.MS_STATIC = m_cam.MS_STATIC;
  252. /**
  253.  * The camera's movement style: TARGET.
  254.  * @const {CameraMoveStyle} module:camera.MS_TARGET_CONTROLS
  255.  */
  256. exports.MS_TARGET_CONTROLS = m_cam.MS_TARGET_CONTROLS;
  257. /**
  258.  * The camera's movement style: EYE.
  259.  * @const {CameraMoveStyle} module:camera.MS_EYE_CONTROLS
  260.  */
  261. exports.MS_EYE_CONTROLS = m_cam.MS_EYE_CONTROLS;
  262. /**
  263.  * The camera's movement style: HOVER.
  264.  * @const {CameraMoveStyle} module:camera.MS_HOVER_CONTROLS
  265.  */
  266. exports.MS_HOVER_CONTROLS = m_cam.MS_HOVER_CONTROLS;
  268. /**
  269.  * Setup the STATIC camera.
  270.  * @method module:camera.static_setup
  271.  * @param {Object3D} camobj Camera 3D-object.
  272.  * @param {?StaticCameraParams} [params=null] The parameters of the STATIC camera.
  273.  */
  274. exports.static_setup = function(camobj, params) {
  275.     if (!m_obj_util.is_camera(camobj)) {
  276.         m_print.error("static_setup(): Wrong camera object");
  277.         return;
  278.     }
  280.     m_cam.wipe_move_style(camobj);
  281.     camobj.render.move_style = m_cam.MS_STATIC;
  283.     if (params) {
  284.         var pos = params.pos || m_tsr.get_trans_view(camobj.render.world_tsr);
  285.         if (params.look_at)
  286.             m_cam.set_look_at(camobj, pos, params.look_at);
  287.         else
  288.             m_trans.set_translation(camobj, pos);
  289.     }
  291.     m_trans.update_transform(camobj);
  292.     m_phy.sync_transform(camobj);
  294.     // init ortho properties after the camera was updated
  295.     m_cam.init_ortho_props(camobj);
  296. }
  298. /**
  299.  * Set position and orientation for the STATIC camera.
  300.  * @method module:camera.static_set_look_at
  301.  * @param {Object3D} camobj Camera 3D-object.
  302.  * @param {?Vec3} [pos=null] Position of the camera. Pass null to keep the current 
  303.  * camera position.
  304.  * @param {?Vec3} [look_at=null] Point the camera is looking at. Pass null to 
  305.  * keep the existing camera orientation.
  306.  */
  307. exports.static_set_look_at = function(camobj, pos, look_at) {
  308.     if (!m_cam.is_static_camera(camobj)) {
  309.         m_print.error("static_set_look_at(): Wrong camera object or camera move style");
  310.         return;
  311.     }
  313.     pos = pos || m_tsr.get_trans_view(camobj.render.world_tsr);
  314.     if (look_at)
  315.         m_cam.set_look_at(camobj, pos, look_at);
  316.     else
  317.         m_trans.set_translation(camobj, pos);
  319.     m_trans.update_transform(camobj);
  320.     m_phy.sync_transform(camobj);
  321. };
  323. /**
  324.  * Set the STATIC camera's rotation from quaternion.
  325.  * @method module:camera.static_set_rotation
  326.  * @param {Object3D} camobj Camera 3D-object.
  327.  * @param {Quat} quat Quaternion vector.
  328.  */
  329. exports.static_set_rotation = function(camobj, quat) {
  330.     if (!m_cam.is_static_camera(camobj)) {
  331.         m_print.error("static_set_rotation(): Wrong camera object or camera move style");
  332.         return;
  333.     }
  335.     m_trans.set_rotation(camobj, quat);
  337.     m_trans.update_transform(camobj);
  338.     m_phy.sync_transform(camobj);
  339. };
  341. /**
  342.  * Get the STATIC camera's rotation quaternion.
  343.  * @method module:camera.static_get_rotation
  344.  * @param {Object3D} camobj Camera 3D-object.
  345.  * @param {?Quat} [dest=new Float32Array(4);] Destination vector.
  346.  * @returns {?Quat} Destination vector.
  347.  */
  348. exports.static_get_rotation = function(camobj, dest) {
  349.     if (!m_cam.is_static_camera(camobj)) {
  350.         m_print.error("static_get_rotation(): Wrong camera object or camera move style");
  351.         return null;
  352.     }
  354.     dest = dest || new Float32Array(4);
  355.     return m_trans.get_rotation(camobj, dest);
  356. };
  358. /**
  359.  * Setup the EYE camera.
  360.  * @method module:camera.eye_setup
  361.  * @param {Object3D} camobj Camera 3D-object.
  362.  * @param {?EyeCameraParams} [params=null] The parameters of the EYE camera.
  363.  */
  364. exports.eye_setup = function(camobj, params) {
  366.     if (!m_obj_util.is_camera(camobj)) {
  367.         m_print.error("eye_setup(): Wrong camera object");
  368.         return;
  369.     }
  370.     if (params && params.horiz_rot_lim)
  371.         if (typeof params.horiz_rot_lim.left != "number" 
  372.                 || typeof params.horiz_rot_lim.right != "number") {
  373.             m_print.error("eye_setup(): Wrong horizontal limits object.");
  374.             return;
  375.         }
  376.     if (params && params.vert_rot_lim)
  377.         if (typeof params.vert_rot_lim.down != "number" 
  378.                 || typeof params.vert_rot_lim.up != "number") {
  379.             m_print.error("eye_setup(): Wrong vertical limits object.");
  380.             return;
  381.         }
  383.     m_cam.wipe_move_style(camobj);
  384.     camobj.render.move_style = m_cam.MS_EYE_CONTROLS;
  386.     if (params) {
  387.         var pos = params.pos || m_tsr.get_trans_view(camobj.render.world_tsr);
  388.         m_cam.setup_eye_model(camobj, pos, params.look_at, params.horiz_rot_lim, 
  389.                 params.vert_rot_lim);
  390.     }
  392.     m_trans.update_transform(camobj);
  393.     m_phy.sync_transform(camobj);
  395.     // init ortho after the camera was updated
  396.     m_cam.init_ortho_props(camobj);
  397. }
  399. /**
  400.  * Set position and orientation for the EYE camera.
  401.  * @method module:camera.eye_set_look_at
  402.  * @param {Object3D} camobj Camera 3D-object.
  403.  * @param {?Vec3} [pos=null] Position of the camera. Pass null to keep the current 
  404.  * camera position.
  405.  * @param {?Vec3} [look_at=null] Point the camera is looking at. Pass null to 
  406.  * keep the existing camera orientation.
  407.  */
  408. exports.eye_set_look_at = function(camobj, pos, look_at) {
  409.     if (!m_cam.is_eye_camera(camobj)) {
  410.         m_print.error("eye_set_look_at(): Wrong camera object or camera move style");
  411.         return;
  412.     }
  414.     pos = pos || m_tsr.get_trans_view(camobj.render.world_tsr);
  415.     if (look_at)
  416.         m_cam.set_look_at_corrected(camobj, pos, look_at);
  417.     else
  418.         m_trans.set_translation(camobj, pos);
  420.     m_cam.correct_up(camobj, camobj.render.vertical_axis, true);
  422.     m_trans.update_transform(camobj);
  423.     m_phy.sync_transform(camobj);
  424. };
  426. /**
  427.  * Rotate the EYE camera counterclockwise (CCW) around its origin by the given angles.
  428.  * Performs delta rotation or sets the camera's absolute rotation depending on 
  429.  * the "is_abs" parameter.
  430.  * @see https://www.blend4web.com/doc/en/camera.html#camera-spherical-coordinates
  431.  * @method module:camera.eye_rotate
  432.  * @param {Object3D} camobj Camera 3D-object.
  433.  * @param {number} phi Azimuth angle in radians.
  434.  * @param {number} theta Elevation angle in radians.
  435.  * @param {boolean} [is_abs=false] Performs delta rotation if FALSE, sets 
  436.  * camera's absolute rotation if TRUE.
  437.  * @deprecated [17.06] Use {@link module:camera.rotate_camera} instead
  438.  */
  439. exports.eye_rotate = function(camobj, phi, theta, is_abs) {
  440.     m_print.error_deprecated("eye_rotate", "rotate_camera");
  441.     if (!m_cam.is_eye_camera(camobj)) {
  442.         m_print.error("eye_rotate(): Wrong camera object or camera move style");
  443.         return;
  444.     }
  446.     is_abs = is_abs || false;
  447.     exports.rotate_camera(camobj, phi, theta, is_abs);
  448. }
  450. /**
  451.  * Set vertical rotation limits for the EYE camera.
  452.  * @see https://www.blend4web.com/doc/en/camera.html#camera-spherical-coordinates
  453.  * @method module:camera.eye_set_vertical_limits
  454.  * @param {Object3D} camobj Camera 3D-object.
  455.  * @param {?VerticalRotationLimits} [limits=null] Vertical rotation limits. 
  456.  * Pass null to disable the limits.
  457.  */
  458. exports.eye_set_vertical_limits = function(camobj, limits) {
  459.     if (!m_cam.is_eye_camera(camobj)) {
  460.         m_print.error("eye_set_vertical_limits(): Wrong camera object or camera move style");
  461.         return;
  462.     }
  464.     if (limits)
  465.         if (typeof limits.down != "number" || typeof limits.up != "number") {
  466.             m_print.error("eye_set_vertical_limits(): Incorrect limits object.");
  467.             return;
  468.         }
  470.     m_cam.set_vertical_rot_limits(camobj, limits);
  471.     m_trans.update_transform(camobj);
  472.     m_phy.sync_transform(camobj);
  473. }
  475. /**
  476.  * Get vertical rotation limits of the EYE camera (converted to the [-Pi, Pi] range).
  477.  * @see https://www.blend4web.com/doc/en/camera.html#camera-spherical-coordinates
  478.  * @method module:camera.eye_get_vertical_limits
  479.  * @param {Object3D} camobj Camera 3D-object.
  480.  * @param {?VerticalRotationLimits} [dest=new Object();] The receiving object.
  481.  * @param {boolean} [local=false] Use camera local space representation.
  482.  * @returns {?VerticalRotationLimits} Vertical rotation limits or null if disabled.
  483.  */
  484. exports.eye_get_vertical_limits = function(camobj, dest, local) {
  485.     if (!m_cam.is_eye_camera(camobj)) {
  486.         m_print.error("eye_get_vertical_limits(): Wrong camera object or camera move style");
  487.         return null;
  488.     }
  490.     var render = camobj.render;
  491.     if (render.vertical_limits) {
  492.         dest = dest || {};
  493.         if (local) {
  494.             dest.down = render.vertical_limits.down_local;
  495.             dest.up = render.vertical_limits.up_local;
  496.         } else {
  497.             dest.down = render.vertical_limits.down;
  498.             dest.up = render.vertical_limits.up;
  499.         }
  500.         dest.camera_space = local || false;
  501.         return dest;
  502.     } else
  503.         return null;
  504. }
  506. /**
  507.  * Set horizontal rotation limits for the EYE camera.
  508.  * @see https://www.blend4web.com/doc/en/camera.html#camera-spherical-coordinates
  509.  * @method module:camera.eye_set_horizontal_limits
  510.  * @param {Object3D} camobj Camera 3D-object.
  511.  * @param {?HorizontalRotationLimits} [limits=null] Horizontal rotation limits. 
  512.  * Pass null to disable the limits.
  513.  */
  514. exports.eye_set_horizontal_limits = function(camobj, limits) {
  515.     if (!m_cam.is_eye_camera(camobj)) {
  516.         m_print.error("eye_set_horizontal_limits(): Wrong camera object or camera move style");
  517.         return;
  518.     }
  520.     if (limits)
  521.         if (typeof limits.left != "number" || typeof limits.right != "number") {
  522.             m_print.error("eye_set_horizontal_limits(): Incorrect limits object.");
  523.             return;
  524.         }
  526.     m_cam.set_horizontal_rot_limits(camobj, limits);
  527.     m_trans.update_transform(camobj);
  528.     m_phy.sync_transform(camobj);
  529. }
  531. /**
  532.  * Get horizontal angle limits of the EYE camera (converted to the [0, 2Pi] range).
  533.  * @see https://www.blend4web.com/doc/en/camera.html#camera-spherical-coordinates
  534.  * @method module:camera.eye_get_horizontal_limits
  535.  * @param {Object3D} camobj Camera 3D-object.
  536.  * @param {?HorizontalRotationLimits} [dest=new Object();] The receiving object.
  537.  * @param {boolean} [local=false] Use camera local space representation.
  538.  * @returns {?HorizontalRotationLimits} Horizontal rotation limits or null if disabled.
  539.  */
  540. exports.eye_get_horizontal_limits = function(camobj, dest, local) {
  541.     if (!m_cam.is_eye_camera(camobj)) {
  542.         m_print.error("eye_get_horizontal_limits(): Wrong camera object or camera move style");
  543.         return null;
  544.     }
  546.     var render = camobj.render;
  547.     if (render.horizontal_limits) {
  548.         dest = dest || {};
  549.         if (local) {
  550.             dest.left = render.horizontal_limits.left_local;
  551.             dest.right = render.horizontal_limits.right_local;
  552.         } else {
  553.             dest.left = render.horizontal_limits.left;
  554.             dest.right = render.horizontal_limits.right;
  555.         }
  556.         dest.camera_space = local || false;
  557.         return dest;
  558.     } else
  559.         return null;
  560. }
  562. /**
  563.  * Setup the TARGET camera.
  564.  * @method module:camera.target_setup
  565.  * @param {Object3D} camobj Camera 3D-object.
  566.  * @param {TargetCameraParams} params The parameters of the TARGET camera.
  567.  */
  568. exports.target_setup = function(camobj, params) {
  570.     if (!m_obj_util.is_camera(camobj)) {
  571.         m_print.error("target_setup(): Wrong camera object");
  572.         return;
  573.     }
  574.     if (params.horiz_rot_lim)
  575.         if (typeof params.horiz_rot_lim.left != "number" 
  576.                 || typeof params.horiz_rot_lim.right != "number") {
  577.             m_print.error("target_setup(): Wrong horizontal limits object");
  578.             return;
  579.         }
  580.     if (params.vert_rot_lim)
  581.         if (typeof params.vert_rot_lim.down != "number" 
  582.                 || typeof params.vert_rot_lim.up != "number") {
  583.             m_print.error("target_setup(): Wrong vertical limits object");
  584.             return;
  585.         }
  586.     if (params.dist_lim) {
  587.         if (typeof params.dist_lim.min != "number" 
  588.                 || typeof params.dist_lim.max != "number" 
  589.                 || params.dist_lim.min > params.dist_lim.max) {
  590.             m_print.error("target_setup(): Wrong distance limits object");
  591.             return;
  592.         }
  593.         params.dist_lim.min = Math.max(params.dist_lim.min, 0);
  594.         params.dist_lim.max = Math.max(params.dist_lim.max, 0);
  595.     }
  597.     if (params.pivot_lim) {
  598.         if (typeof params.pivot_lim.min_y != "number" 
  599.                 || typeof params.pivot_lim.max_y != "number" 
  600.                 || params.pivot_lim.min_y > params.pivot_lim.max_y) {
  601.             m_print.error("target_setup(): Wrong pivot limits object");
  602.             return;
  603.         }
  604.     }
  606.     m_cam.wipe_move_style(camobj);
  607.     camobj.render.move_style = m_cam.MS_TARGET_CONTROLS;
  609.     var pos = params.pos || m_tsr.get_trans_view(camobj.render.world_tsr);
  610.     var pivot = params.pivot;
  611.     if (!pivot) {
  612.         var view_vec = get_view_vector(camobj, _vec3_tmp);
  613.         pivot = m_vec3.add(pos, view_vec, view_vec);
  614.     }
  615.     m_cam.setup_target_model(camobj, pos, pivot, params.horiz_rot_lim, 
  616.             params.vert_rot_lim, params.dist_lim, params.pivot_lim, 
  617.             params.use_panning || false);
  619.     m_trans.update_transform(camobj);
  620.     m_phy.sync_transform(camobj);
  622.     // init ortho after the camera was updated
  623.     m_cam.init_ortho_props(camobj);
  624. }
  626. /**
  627.  * Rotate the TARGET camera counterclockwise (CCW) around its pivot by the given 
  628.  * angles.
  629.  * Performs delta rotation or sets the camera's absolute rotation depending on 
  630.  * the "is_abs" parameter.
  631.  * @see https://www.blend4web.com/doc/en/camera.html#camera-spherical-coordinates
  632.  * @method module:camera.target_rotate
  633.  * @param {Object3D} camobj Camera 3D-object.
  634.  * @param {number} phi Azimuth angle in radians.
  635.  * @param {number} theta Elevation angle in radians.
  636.  * @param {boolean} [is_abs=false] Performs delta rotation if FALSE, sets 
  637.  * camera's absolute rotation if TRUE.
  638.  * @deprecated [17.06] Use {@link module:camera.rotate_camera} instead
  639.  */
  640. exports.target_rotate = function(camobj, phi, theta, is_abs) {
  641.     m_print.error_deprecated("target_rotate", "rotate_camera");
  642.     if (!m_cam.is_target_camera(camobj)) {
  643.         m_print.error("target_rotate(): Wrong camera object or camera move style");
  644.         return;
  645.     }
  647.     is_abs = is_abs || false;
  648.     
  649.     exports.rotate_camera(camobj, phi, theta, is_abs);
  650. }
  652. /**
  653.  * Set translation and pivot point for the TARGET camera.
  654.  * The result of this operation can be corrected by existing limits.
  655.  * @method module:camera.target_set_trans_pivot
  656.  * @param {Object3D} camobj Camera 3D-object.
  657.  * @param {?Vec3} [trans=null] Translation vector. Pass null to keep the current 
  658.  * camera position.
  659.  * @param {?Vec3} [pivot=null] Pivot vector. Pass null to keep the current pivot 
  660.  * point.
  661.  */
  662. exports.target_set_trans_pivot = function(camobj, trans, pivot) {
  663.     if (!m_cam.is_target_camera(camobj)) {
  664.         m_print.error("target_set_trans_pivot(): Wrong camera object or camera move style");
  665.         return;
  666.     }
  668.     trans = trans || m_tsr.get_trans_view(camobj.render.world_tsr);
  669.     pivot = pivot || camobj.render.pivot;
  670.     m_cam.set_trans_pivot(camobj, trans, pivot);
  672.     m_trans.update_transform(camobj);
  673.     m_phy.sync_transform(camobj);
  674. }
  676. /**
  677.  * Performs parallel translation for the TARGET camera. It works as similar as
  678.  * the set_translation() method but uses the camera pivot to perform the translation.
  679.  * @method module:camera.target_set_pivot_translation
  680.  * @param {Object3D} camobj Camera 3D-object.
  681.  * @param {Vec3} trans New pivot position.
  682.  */
  683. exports.target_set_pivot_translation = function(camobj, trans) {
  684.     if (!m_cam.is_target_camera(camobj)) {
  685.         m_print.error("target_set_pivot_translation(): Wrong camera object or camera move style");
  686.         return;
  687.     }
  689.     m_cam.set_target_pivot(camobj, trans);
  691.     m_trans.update_transform(camobj);
  692.     m_phy.sync_transform(camobj);
  693. }
  695. /**
  696.  * Set distance to the pivot point for the TARGET camera.
  697.  * The result of this operation can be corrected by existing limits.
  698.  * @method module:camera.target_set_distance
  699.  * @param {Object3D} camobj Camera 3D-object.
  700.  * @param {number} distance Distance to the pivot point.
  701.  */
  702. exports.target_set_distance = function(camobj, distance) {
  703.     if (!m_cam.is_target_camera(camobj)) {
  704.         m_print.error("target_set_distance(): Wrong camera object or camera move style");
  705.         return;
  706.     }
  708.     var dist_curr = m_trans.obj_point_distance(camobj, camobj.render.pivot);
  709.     var dist_needed = Math.max(0, distance);
  711.     // +y move backward
  712.     m_trans.move_local(camobj, 0, 0, dist_needed - dist_curr);
  714.     m_trans.update_transform(camobj);
  715.     m_phy.sync_transform(camobj);
  716. }
  718. /**
  719.  * Get distance to the pivot point for the TARGET camera.
  720.  * @method module:camera.target_get_distance
  721.  * @param {Object3D} camobj Camera 3D-object.
  722.  * @returns {number} Distance to the pivot point.
  723.  */
  724. exports.target_get_distance = function(camobj) {
  725.     if (!m_cam.is_target_camera(camobj)) {
  726.         m_print.error("target_get_distance(): Wrong camera object or camera move style");
  727.         return 0;
  728.     }
  730.     return m_trans.obj_point_distance(camobj, camobj.render.pivot);
  731. }
  733. /**
  734.  * Zoom the TARGET camera to the object.
  735.  * @method module:camera.target_zoom_object
  736.  * @param {Object3D} camobj Camera 3D-object.
  737.  * @param {Object3D} obj Object 3D.
  738.  */
  739. exports.target_zoom_object = function(camobj, obj) {
  740.     if (!m_cam.is_target_camera(camobj)) {
  741.         m_print.error("target_zoom_object(): Wrong camera object or camera move style");
  742.         return;
  743.     }
  745.     var center = m_trans.get_object_center(obj, false, _vec3_tmp);
  747.     var radius = m_trans.get_object_size(obj);
  748.     var active_scene = m_scs.get_active();
  749.     var cam_scene_data = m_obj_util.get_scene_data(camobj, active_scene);
  750.     var main_camera = cam_scene_data.cameras[0];
  751.     var ang_radius = m_cam.get_angular_diameter(main_camera) / 2;
  752.     var dist_need = radius / Math.sin(ang_radius);
  753.     var dist_current = m_trans.obj_point_distance(camobj, center);
  755.     m_cam.set_trans_pivot(camobj, m_tsr.get_trans_view(camobj.render.world_tsr), center);
  756.     // TODO: excess update
  757.     m_trans.update_transform(camobj);
  759.     // +y move backward
  760.     m_trans.move_local(camobj, 0, 0, dist_need - dist_current);
  762.     m_trans.update_transform(camobj);
  763.     m_phy.sync_transform(camobj);
  764. }
  766. /**
  767.  * Get the pivot point of the TARGET camera.
  768.  * @method module:camera.target_get_pivot
  769.  * @param {Object3D} camobj Camera 3D-object.
  770.  * @param {?Vec3} [dest=new Float32Array(3);] Pivot destination vector.
  771.  * @returns {?Vec3} Pivot destination vector.
  772.  */
  773. exports.target_get_pivot = function(camobj, dest) {
  774.     if (!m_cam.is_target_camera(camobj)) {
  775.         m_print.error("target_get_pivot(): Wrong camera object or camera move style");
  776.         return null;
  777.     }
  779.     dest = dest || new Float32Array(3);
  780.     m_vec3.copy(camobj.render.pivot, dest);
  781.     return dest;
  782. }
  784. /**
  785.  * Set distance limits for the TARGET camera.
  786.  * @method module:camera.target_set_distance_limits
  787.  * @param {Object3D} camobj Camera 3D-object.
  788.  * @param {?DistanceLimits} [limits=null] Distance limits. Pass null to disable 
  789.  * the limits.
  790.  */
  791. exports.target_set_distance_limits = function(camobj, limits) {
  792.     if (!m_cam.is_target_camera(camobj)) {
  793.         m_print.error("target_set_distance_limits(): Wrong camera object or camera move style");
  794.         return;
  795.     }
  797.     if (limits) {
  798.         if (typeof limits.min != "number" || typeof limits.max != "number" 
  799.                 || limits.min > limits.max) {
  800.             m_print.error("target_set_distance_limits(): Wrong limits object");
  801.             return;
  802.         }
  803.         limits.min = Math.max(limits.min, 0);
  804.         limits.max = Math.max(limits.max, 0);
  805.     }
  807.     m_cam.set_distance_limits(camobj, limits);
  808.     m_trans.update_transform(camobj);
  809.     m_phy.sync_transform(camobj);
  810. }
  812. /**
  813.  * Get distance limits of the TARGET camera.
  814.  * @method module:camera.target_get_distance_limits
  815.  * @param {Object3D} camobj Camera 3D-object.
  816.  * @param {?DistanceLimits} [dest=new Object();] The receiving object.
  817.  * @returns {?DistanceLimits} Distance limits or null if disabled.
  818.  */
  819. exports.target_get_distance_limits = function(camobj, dest) {
  820.     if (!m_cam.is_target_camera(camobj)) {
  821.         m_print.error("target_get_distance_limits(): Wrong camera object or camera move style");
  822.         return null;
  823.     }
  825.     var render = camobj.render;
  826.     if (render.distance_limits) {
  827.         dest = dest || {};
  828.         dest.min = render.distance_limits.min;
  829.         dest.max = render.distance_limits.max;
  830.         return dest;
  831.     } else
  832.         return null;
  833. }
  835. /**
  836.  * Set vertical rotation limits for the TARGET camera.
  837.  * @see https://www.blend4web.com/doc/en/camera.html#camera-spherical-coordinates
  838.  * @method module:camera.target_set_vertical_limits
  839.  * @param {Object3D} camobj Camera 3D-object.
  840.  * @param {?VerticalRotationLimits} [limits=null] Vertical rotation limits. 
  841.  * Pass null to disable the limits.
  842.  */
  843. exports.target_set_vertical_limits = function(camobj, limits) {
  844.     if (!m_cam.is_target_camera(camobj)) {
  845.         m_print.error("target_set_vertical_limits(): Wrong camera object or camera move style");
  846.         return;
  847.     }
  849.     if (limits)
  850.         if (typeof limits.down != "number" || typeof limits.up != "number") {
  851.             m_print.error("target_set_vertical_limits(): Wrong limits object");
  852.             return;
  853.         }
  855.     m_cam.set_vertical_rot_limits(camobj, limits);
  856.     m_trans.update_transform(camobj);
  857.     m_phy.sync_transform(camobj);
  858. }
  860. /**
  861.  * Get vertical rotation limits of the TARGET camera (converted to the [-Pi, Pi] range).
  862.  * @see https://www.blend4web.com/doc/en/camera.html#camera-spherical-coordinates
  863.  * @method module:camera.target_get_vertical_limits
  864.  * @param {Object3D} camobj Camera 3D-object.
  865.  * @param {?VerticalRotationLimits} [dest=new Object();] The receiving object.
  866.  * @param {boolean} [local=false] Use camera local space representation.
  867.  * @returns {?VerticalRotationLimits} Vertical rotation limits or null if disabled.
  868.  */
  869. exports.target_get_vertical_limits = function(camobj, dest, local) {
  870.     if (!m_cam.is_target_camera(camobj)) {
  871.         m_print.error("target_get_vertical_limits(): Wrong camera object or camera move style");
  872.         return null;
  873.     }
  875.     var render = camobj.render;
  876.     if (render.vertical_limits) {
  877.         dest = dest || {};
  878.         if (local) {
  879.             dest.down = render.vertical_limits.down_local;
  880.             dest.up = render.vertical_limits.up_local;
  881.         } else {
  882.             dest.down = render.vertical_limits.down;
  883.             dest.up = render.vertical_limits.up;
  884.         }
  885.         dest.camera_space = local || false;
  886.         return dest;
  887.     } else
  888.         return null;
  889. }
  891. /**
  892.  * Set horizontal rotation limits for the TARGET camera.
  893.  * @see https://www.blend4web.com/doc/en/camera.html#camera-spherical-coordinates
  894.  * @method module:camera.target_set_horizontal_limits
  895.  * @param {Object3D} camobj Camera 3D-object.
  896.  * @param {?HorizontalRotationLimits} [limits=null] Horizontal rotation limits.
  897.  * Pass null to disable the limits.
  898.  */
  899. exports.target_set_horizontal_limits = function(camobj, limits) {
  900.     if (!m_cam.is_target_camera(camobj)) {
  901.         m_print.error("target_set_horizontal_limits(): Wrong camera object or camera move style");
  902.         return;
  903.     }
  905.     if (limits)
  906.         if (typeof limits.left != "number" || typeof limits.right != "number") {
  907.             m_print.error("target_set_horizontal_limits(): Wrong limits object");
  908.             return;
  909.         }
  911.     m_cam.set_horizontal_rot_limits(camobj, limits);
  912.     m_trans.update_transform(camobj);
  913.     m_phy.sync_transform(camobj);
  914. }
  916. /**
  917.  * Get horizontal rotation limits of the TARGET camera (converted to the [0, 2Pi] range).
  918.  * @see https://www.blend4web.com/doc/en/camera.html#camera-spherical-coordinates
  919.  * @method module:camera.target_get_horizontal_limits
  920.  * @param {Object3D} camobj Camera 3D-object.
  921.  * @param {?HorizontalRotationLimits} [dest=new Object();] The receiving object.
  922.  * @param {boolean} [local=false] Use camera local space representation.
  923.  * @returns {?HorizontalRotationLimits} Horizontal rotation limits or null if disabled.
  924.  */
  925. exports.target_get_horizontal_limits = function(camobj, dest, local) {
  926.     if (!m_cam.is_target_camera(camobj)) {
  927.         m_print.error("target_get_horizontal_limits(): Wrong camera object or camera move style");
  928.         return null;
  929.     }
  931.     var render = camobj.render;
  932.     if (render.horizontal_limits) {
  933.         dest = dest || {};
  934.         if (local) {
  935.             dest.left = render.horizontal_limits.left_local;
  936.             dest.right = render.horizontal_limits.right_local;
  937.         } else {
  938.             dest.left = render.horizontal_limits.left;
  939.             dest.right = render.horizontal_limits.right;
  940.         }
  941.         dest.camera_space = local || false;
  942.         return dest;
  943.     } else
  944.         return null;
  945. }
  947. /**
  948.  * Set pivot limits for the TARGET camera.
  949.  * @method module:camera.target_set_pivot_limits
  950.  * @param {Object3D} camobj Camera 3D-object.
  951.  * @param {?PivotLimits} [limits=null] Pivot limits. Pass null to 
  952.  * disable the limits.
  953.  */
  954. exports.target_set_pivot_limits = function(camobj, limits) {
  955.     if (!m_cam.is_target_camera(camobj)) {
  956.         m_print.error("target_set_pivot_limits(): Wrong camera object or camera move style");
  957.         return;
  958.     }
  960.     if (limits) {
  961.         if (typeof limits.min_z != "number" || typeof limits.max_z != "number" 
  962.                 || limits.min_z > limits.max_z) {
  963.             m_print.error("target_set_pivot_limits(): Wrong limits object");
  964.             return;
  965.         }
  966.     }
  968.     m_cam.set_pivot_limits(camobj, limits);
  969.     m_trans.update_transform(camobj);
  970.     m_phy.sync_transform(camobj);
  971. }
  973. /**
  974.  * Get pivot limits of the TARGET camera.
  975.  * @method module:camera.target_get_pivot_limits
  976.  * @param {Object3D} camobj Camera 3D-object.
  977.  * @param {?PivotLimits} [dest=new Object();] The receiving object.
  978.  * @returns {?PivotLimits} pivot limits or null if disabled.
  979.  */
  980. exports.target_get_pivot_limits = function(camobj, dest) {
  981.     if (!m_cam.is_target_camera(camobj)) {
  982.         m_print.error("target_get_pivot_limits(): Wrong camera object or camera move style");
  983.         return null;
  984.     }
  986.     var render = camobj.render;
  987.     if (render.pivot_limits) {
  988.         dest = dest || {};
  989.         dest.min_z = render.pivot_limits.min_z;
  990.         dest.max_z = render.pivot_limits.max_z;
  991.         return dest;
  992.     } else
  993.         return null;
  994. }
  996. /**
  997.  * Translate the pivot point of the TARGET camera in screen space.
  998.  * Translation distance is defined with absolute value of parameters.
  999.  * +h from left to right
  1000.  * +v from down to up
  1001.  * @method module:camera.target_pan_pivot
  1002.  * @param {Object3D} camobj Camera 3D-object
  1003.  * @param {number} trans_h_delta Absolute delta of the horizontal translation.
  1004.  * @param {number} trans_v_delta Absolute delta of the vertical translation.
  1005.  */
  1006. exports.target_pan_pivot = function(camobj, trans_h_delta, trans_v_delta) {
  1007.     if (!m_cam.is_target_camera(camobj)) {
  1008.         m_print.error("target_pan_pivot(): wrong object");
  1009.         return;
  1010.     }
  1012.     var render = camobj.render;
  1014.     if (render.use_panning) {
  1015.         var trans_vector = _vec3_tmp;
  1016.         trans_vector[0] = trans_h_delta;
  1017.         trans_vector[1] = -trans_v_delta;
  1018.         trans_vector[2] = 0;
  1020.         m_tsr.transform_dir_vec3(trans_vector, render.world_tsr, trans_vector);
  1022.         m_vec3.add(render.pivot, trans_vector, render.pivot);
  1024.         var cam_trans = m_tsr.get_trans_view(render.world_tsr);
  1025.         m_vec3.add(cam_trans, trans_vector, cam_trans);
  1027.         m_trans.update_transform(camobj);
  1028.         m_phy.sync_transform(camobj);
  1029.     }
  1030. }
  1032. /**
  1033.  * Enable/disable panning for the TARGET camera.
  1034.  * @method module:camera.target_switch_panning
  1035.  * @param {Object3D} camobj Camera 3D-object.
  1036.  * @param {boolean} enable Enable or disable panning.
  1037.  */
  1038. exports.target_switch_panning = function(camobj, enable) {
  1039.     if (!m_cam.is_target_camera(camobj)) {
  1040.         m_print.error("target_switch_panning(): Wrong camera object or camera move style");
  1041.         return null;
  1042.     }
  1044.     camobj.render.use_panning = enable;
  1045. }
  1047. /**
  1048.  * Setup HOVER camera model with the distance and hover angle limits defined as 
  1049.  * variations around the current values which depend on the given camera/pivot 
  1050.  * positions.
  1051.  * @method module:camera.hover_setup_rel
  1052.  * @param {Object3D} camobj Camera 3D-object.
  1053.  * @param {HoverCameraParamsRel} params The parameters of the HOVER camera.
  1054.  */
  1055. exports.hover_setup_rel = function(camobj, params) {
  1056.     exports.hover_setup(camobj, { pos: params.pos, pivot: params.pivot });
  1058.     if (typeof params.dist_interval == "undefined")
  1059.         var dist_interval = 0;
  1060.     else
  1061.         var dist_interval = Math.max(params.dist_interval, 0);
  1063.     if (typeof params.angle_interval == "undefined")
  1064.         var angle_interval = 0;
  1065.     else
  1066.         var angle_interval = Math.max(params.angle_interval, 0);
  1068.     if (typeof params.t == "undefined")
  1069.         var t = 0.5;
  1070.     else
  1071.         var t = m_util.clamp(params.t, 0, 1);        
  1073.     var dist_lim = exports.hover_get_distance_limits(camobj, _limits_tmp);
  1074.     dist_lim.min = Math.max(dist_lim.min - t * dist_interval, 0);
  1075.     dist_lim.max = dist_lim.max + (1 - t) * dist_interval;
  1077.     var ha_lim = exports.hover_get_vertical_limits(camobj, _limits_tmp2);
  1078.     ha_lim.down = m_util.clamp(ha_lim.down + t * angle_interval, -Math.PI/2, 0);
  1079.     ha_lim.up = m_util.clamp(ha_lim.up - (1 - t) * angle_interval, -Math.PI/2, 0);
  1081.     m_cam.hover_set_distance_limits(camobj, dist_lim);
  1082.     m_cam.hover_set_vertical_limits(camobj, ha_lim);
  1084.     m_trans.update_transform(camobj);
  1085.     m_phy.sync_transform(camobj);
  1087.     // init ortho after the camera was updated
  1088.     m_cam.init_ortho_props(camobj);
  1089. }
  1091. /**
  1092.  * Setup HOVER camera model.
  1093.  * @method module:camera.hover_setup
  1094.  * @param {Object3D} camobj Camera 3D-object.
  1095.  * @param {HoverCameraParams} params The parameters of the HOVER camera.
  1096.  */
  1097. exports.hover_setup = function(camobj, params) {
  1099.     if (!m_obj_util.is_camera(camobj)) {
  1100.         m_print.error("hover_setup(): Wrong camera object");
  1101.         return;
  1102.     }
  1104.     if (params.dist_lim) {
  1105.         if (typeof params.dist_lim.min != "number" 
  1106.                 || typeof params.dist_lim.max != "number"
  1107.                 || params.dist_lim.min > params.dist_lim.max) {
  1108.             m_print.error("hover_setup(): Wrong distance limits object");
  1109.             return;
  1110.         }
  1111.         params.dist_lim.min = Math.max(params.dist_lim.min, 0);
  1112.         params.dist_lim.max = Math.max(params.dist_lim.max, 0);
  1113.     }
  1114.     if (params.hover_angle_lim)
  1115.         if (typeof params.hover_angle_lim.down != "number" 
  1116.                 || typeof params.hover_angle_lim.up != "number"
  1117.                 || params.hover_angle_lim.down < params.hover_angle_lim.up) {
  1118.             m_print.error("hover_setup(): Wrong hover angle limits object");
  1119.             return;
  1120.         }
  1121.     if (params.horiz_trans_lim)
  1122.         if (typeof params.horiz_trans_lim.min != "number" 
  1123.                 || typeof params.horiz_trans_lim.max != "number"
  1124.                 || params.horiz_trans_lim.min > params.horiz_trans_lim.max) {
  1125.             m_print.error("hover_setup(): Wrong horizontal translation limits object");
  1126.             return;
  1127.         }
  1128.     if (params.vert_trans_lim)
  1129.         if (typeof params.vert_trans_lim.min != "number" 
  1130.                 || typeof params.vert_trans_lim.max != "number"
  1131.                 || params.vert_trans_lim.min > params.vert_trans_lim.max) {
  1132.             m_print.error("hover_setup(): Wrong vertical translation limits object");
  1133.             return;
  1134.         }
  1136.     m_cam.wipe_move_style(camobj);
  1137.     camobj.render.move_style = m_cam.MS_HOVER_CONTROLS;
  1139.     var pos = params.pos || m_tsr.get_trans_view(camobj.render.world_tsr);
  1140.     m_cam.setup_hover_model(camobj, pos, params.pivot, params.dist_lim, 
  1141.             params.hover_angle_lim, params.horiz_trans_lim, 
  1142.             params.vert_trans_lim, params.enable_horiz_rot || false);
  1144.     m_trans.update_transform(camobj);
  1145.     m_phy.sync_transform(camobj);
  1147.     // init ortho after the camera was updated
  1148.     m_cam.init_ortho_props(camobj);
  1149. }
  1151. /**
  1152.  * Rotate the HOVER camera around its pivot by the given angles.
  1153.  * Performs delta rotation or sets the camera's absolute rotation depending on 
  1154.  * the "is_abs" parameter.
  1155.  * @see https://www.blend4web.com/doc/en/camera.html#camera-spherical-coordinates
  1156.  * @method module:camera.hover_rotate
  1157.  * @param {Object3D} camobj Camera 3D-object.
  1158.  * @param {number} phi Azimuth angle in radians
  1159.  * @param {number} theta Elevation angle in radians
  1160.  * @param {boolean} [is_abs=false] Performs delta rotation if FALSE, sets 
  1161.  * camera's absolute rotation if TRUE.
  1162.  * @deprecated [17.06] Use {@link module:camera.rotate_camera} instead
  1163.  */
  1164. exports.hover_rotate = function(camobj, phi, theta, is_abs) {
  1165.     m_print.error_deprecated("hover_rotate", "rotate_camera");
  1166.     if (!m_cam.is_hover_camera(camobj)) {
  1167.         m_print.error("hover_rotate(): Wrong camera object or camera move style");
  1168.         return;
  1169.     }
  1171.     is_abs = is_abs || false;
  1173.     exports.rotate_camera(camobj, phi, theta, is_abs);
  1174. }
  1176. /**
  1177.  * Performs parallel translation for the HOVER camera. It works as similar as
  1178.  * the set_translation() method but uses the camera pivot to perform the translation.
  1179.  * @method module:camera.hover_set_pivot_translation
  1180.  * @param {Object3D} camobj Camera 3D-object.
  1181.  * @param {Vec3} trans New pivot position.
  1182.  */
  1183. exports.hover_set_pivot_translation = function(camobj, trans) {
  1184.     if (!m_cam.is_hover_camera(camobj)) {
  1185.         m_print.error("hover_set_pivot_translation(): Wrong camera object or camera move style");
  1186.         return;
  1187.     }
  1189.     m_cam.set_hover_pivot(camobj, trans);
  1191.     m_trans.update_transform(camobj);
  1192.     m_phy.sync_transform(camobj);
  1193. }
  1195. /**
  1196.  * Get pivot position of the HOVER camera.
  1197.  * @method module:camera.hover_get_pivot
  1198.  * @param {Object3D} camobj Camera 3D-object.
  1199.  * @param {Vec3} [dest=new Float32Array(3);] Destination vector for the pivot translation.
  1200.  * @returns {?Vec3} Destination vector for the pivot translation.
  1201.  */
  1202. exports.hover_get_pivot = function(camobj, dest) {
  1203.     if (!m_cam.is_hover_camera(camobj)) {
  1204.         m_print.error("hover_get_pivot(): Wrong camera object or camera move style");
  1205.         return null;
  1206.     }
  1208.     dest = dest || new Float32Array(3);
  1209.     m_vec3.copy(camobj.render.hover_pivot, dest);
  1210.     return dest;
  1211. }
  1213. /**
  1214.  * Get distance to the pivot point for the HOVER camera.
  1215.  * @method module:camera.hover_get_distance
  1216.  * @param {Object3D} camobj Camera 3D-object.
  1217.  * @returns {number} Distance to the pivot.
  1218.  */
  1219. exports.hover_get_distance = function(camobj) {
  1220.     if (!m_cam.is_hover_camera(camobj)) {
  1221.         m_print.error("hover_get_distance(): Wrong camera object or camera move style");
  1222.         return 0;
  1223.     }
  1225.     return m_trans.obj_point_distance(camobj, camobj.render.hover_pivot);
  1226. }
  1228. /**
  1229.  * Set vertical rotation (hover angle) limits for the HOVER camera.
  1230.  * @see https://www.blend4web.com/doc/en/camera.html#camera-spherical-coordinates
  1231.  * @method module:camera.hover_set_vertical_limits
  1232.  * @param {Object3D} camobj Camera 3D-object.
  1233.  * @param {HoverAngleLimits} limits Hover angle limits
  1234.  */
  1235. exports.hover_set_vertical_limits = function(camobj, limits) {
  1236.     if (!m_cam.is_hover_camera(camobj)) {
  1237.         m_print.error("hover_set_vertical_limits(): Wrong camera object or camera move style");
  1238.         return;
  1239.     }
  1241.     if (typeof limits.down != "number" || typeof limits.up != "number"
  1242.             || limits.down < limits.up) {
  1243.         m_print.error("hover_set_vertical_limits(): Wrong limits object");
  1244.         return;
  1245.     }
  1247.     m_cam.hover_set_vertical_limits(camobj, limits);
  1249.     m_trans.update_transform(camobj);
  1250.     m_phy.sync_transform(camobj);
  1251. }
  1253. /**
  1254.  * Get vertical rotation (hover angle) limits for the HOVER camera (converted to the [-Pi, 0] range).
  1255.  * @see https://www.blend4web.com/doc/en/camera.html#camera-spherical-coordinates
  1256.  * @method module:camera.hover_get_vertical_limits
  1257.  * @param {Object3D} camobj Camera 3D-object.
  1258.  * @param {?HoverAngleLimits} [dest=new Object();] The receiving object.
  1259.  * @returns {?HoverAngleLimits} Hover angle limits.
  1260.  */
  1261. exports.hover_get_vertical_limits = function(camobj, dest) {
  1262.     if (!m_cam.is_hover_camera(camobj)) {
  1263.         m_print.error("hover_get_vertical_limits(): Wrong camera object or camera move style");
  1264.         return null;
  1265.     }
  1267.     var render = camobj.render;
  1268.     dest = dest || {};
  1269.     dest.down = render.vertical_limits.down;
  1270.     dest.up = render.vertical_limits.up;
  1272.     return dest;
  1273. }
  1275. /**
  1276.  * Set distance limits for the HOVER camera.
  1277.  * @method module:camera.hover_set_distance_limits
  1278.  * @param {Object3D} camobj Camera 3D-object.
  1279.  * @param {DistanceLimits} limits Distance limits.
  1280.  */
  1281. exports.hover_set_distance_limits = function(camobj, limits) {
  1282.     if (!m_cam.is_hover_camera(camobj)) {
  1283.         m_print.error("hover_set_distance_limits(): Wrong camera object or camera move style");
  1284.         return;
  1285.     }
  1287.     if (typeof limits.min != "number" || typeof limits.max != "number"
  1288.             || limits.min > limits.max) {
  1289.         m_print.error("hover_set_distance_limits(): Wrong limits object");
  1290.         return;
  1291.     }
  1292.     limits.min = Math.max(limits.min, 0);
  1293.     limits.max = Math.max(limits.max, 0);
  1295.     m_cam.hover_set_distance_limits(camobj, limits);
  1297.     m_trans.update_transform(camobj);
  1298.     m_phy.sync_transform(camobj);
  1299. }
  1301. /**
  1302.  * Get distance limits of the HOVER camera.
  1303.  * @method module:camera.hover_get_distance_limits
  1304.  * @param {Object3D} camobj Camera 3D-object.
  1305.  * @param {?DistanceLimits} [dest=new Object();] The receiving object.
  1306.  * @returns {?DistanceLimits} Distance limits.
  1307.  */
  1308. exports.hover_get_distance_limits = function(camobj, dest) {
  1309.     if (!m_cam.is_hover_camera(camobj)) {
  1310.         m_print.error("hover_get_distance_limits(): Wrong camera object or camera move style");
  1311.         return null;
  1312.     }
  1314.     var render = camobj.render;
  1315.     dest = dest || {};
  1316.     dest.min = render.distance_limits.min;
  1317.     dest.max = render.distance_limits.max;
  1318.     return dest;
  1319. }
  1321. /**
  1322.  * Set vertical (along the Z axis) translation limits for the HOVER camera.
  1323.  * @see https://www.blend4web.com/doc/en/camera.html#hover-translation-limits
  1324.  * @method module:camera.hover_set_vert_trans_limits
  1325.  * @param {Object3D} camobj Camera 3D-object.
  1326.  * @param {?VerticalTranslationLimits} limits Vertical translation limits.
  1327.  * Pass null to disable the limits.
  1328.  */
  1329. exports.hover_set_vert_trans_limits = function(camobj, limits) {
  1330.     if (!m_cam.is_hover_camera(camobj)) {
  1331.         m_print.error("hover_set_vert_trans_limits(): Wrong camera object or camera move style");
  1332.         return;
  1333.     }
  1335.     if (limits)
  1336.         if (typeof limits.min != "number" || typeof limits.max != "number"
  1337.                 || limits.min > limits.max) {
  1338.             m_print.error("hover_set_vert_trans_limits(): Wrong limits object");
  1339.             return;
  1340.         }
  1342.     m_cam.set_vert_trans_limits(camobj, limits);
  1343.     m_trans.update_transform(camobj);
  1344.     m_phy.sync_transform(camobj);
  1345. }
  1347. /**
  1348.  * Get vertical translation limits of the HOVER camera.
  1349.  * @see https://www.blend4web.com/doc/en/camera.html#hover-translation-limits
  1350.  * @method module:camera.hover_get_vert_trans_limits
  1351.  * @param {Object3D} camobj Camera 3D-object.
  1352.  * @param {?VerticalTranslationLimits} [dest=new Object();] The receiving object.
  1353.  * @returns {?VerticalTranslationLimits} Vertical translation limits or null if disabled.
  1354.  */
  1355. exports.hover_get_vert_trans_limits = function(camobj, dest) {
  1356.     if (!m_cam.is_hover_camera(camobj)) {
  1357.         m_print.error("hover_get_vert_trans_limits(): Wrong camera object or camera move style");
  1358.         return null;
  1359.     }
  1361.     var render = camobj.render;
  1362.     if (render.hover_vert_trans_limits) {
  1363.         dest = dest || {};
  1364.         dest.min = render.hover_vert_trans_limits.min;
  1365.         dest.max = render.hover_vert_trans_limits.max;
  1366.         return dest;
  1367.     } else
  1368.         return null;
  1369. }
  1371. /**
  1372.  * Set horizontal (along the X axis) translation limits for the HOVER camera.
  1373.  * @see https://www.blend4web.com/doc/en/camera.html#hover-translation-limits
  1374.  * @method module:camera.hover_set_horiz_trans_limits
  1375.  * @param {Object3D} camobj Camera 3D-object.
  1376.  * @param {?HorizontalTranslationLimits} limits Horizontal translation limits.
  1377.  * Pass null to disable the limits.
  1378.  */
  1379. exports.hover_set_horiz_trans_limits = function(camobj, limits) {
  1380.     if (!m_cam.is_hover_camera(camobj)) {
  1381.         m_print.error("hover_set_horiz_trans_limits(): Wrong camera object or camera move style");
  1382.         return;
  1383.     }
  1385.     if (limits)
  1386.         if (typeof limits.min != "number" || typeof limits.max != "number"
  1387.                 || limits.min > limits.max) {
  1388.             m_print.error("hover_set_horiz_trans_limits(): Wrong limits object");
  1389.             return;
  1390.         }
  1392.     m_cam.set_hor_trans_limits(camobj, limits);
  1393.     m_trans.update_transform(camobj);
  1394.     m_phy.sync_transform(camobj);
  1395. }
  1397. /**
  1398.  * Get horizontal translation limits of the HOVER camera.
  1399.  * @see https://www.blend4web.com/doc/en/camera.html#hover-translation-limits
  1400.  * @method module:camera.hover_get_horiz_trans_limits
  1401.  * @param {Object3D} camobj Camera 3D-object.
  1402.  * @param {?HorizontalTranslationLimits} [dest=new Object();] The receiving object.
  1403.  * @returns {?HorizontalTranslationLimits} Horizontal translation limits or null if disabled.
  1404.  */
  1405. exports.hover_get_horiz_trans_limits = function(camobj, dest) {
  1406.     if (!m_cam.is_hover_camera(camobj)) {
  1407.         m_print.error("hover_get_horiz_trans_limits(): Wrong camera object or camera move style");
  1408.         return null;
  1409.     }
  1411.     var render = camobj.render;
  1412.     if (render.hover_horiz_trans_limits) {
  1413.         dest = dest || {};
  1414.         dest.min = render.hover_horiz_trans_limits.min;
  1415.         dest.max = render.hover_horiz_trans_limits.max;
  1416.         return dest;
  1417.     } else
  1418.         return null;
  1419. }
  1421. /**
  1422.  * Enable/disable horizontal rotation for the HOVER camera.
  1423.  * @method module:camera.hover_switch_horiz_rotation
  1424.  * @param {Object3D} camobj Camera 3D-object.
  1425.  * @param {boolean} enable Enable or disable the rotation.
  1426.  */
  1427. exports.hover_switch_horiz_rotation = function(camobj, enable) {
  1428.     if (!m_cam.is_hover_camera(camobj)) {
  1429.         m_print.error("hover_switch_horiz_rotation(): Wrong camera object or camera move style");
  1430.         return null;
  1431.     }
  1433.     camobj.render.enable_hover_hor_rotation = enable;
  1434. }
  1436. /**
  1437.  * Check if the object is a camera and has the MS_STATIC movement style.
  1438.  * @method module:camera.is_static_camera
  1439.  * @param {Object3D} obj Object 3D
  1440.  * @returns {boolean} The result of the checking.
  1441.  */
  1442. exports.is_static_camera = m_cam.is_static_camera;
  1444. /**
  1445.  * Check if the object is a camera and has the MS_TARGET_CONTROLS movement style.
  1446.  * @method module:camera.is_target_camera
  1447.  * @param {Object3D} obj Object 3D
  1448.  * @returns {boolean} The result of the checking.
  1449.  */
  1450. exports.is_target_camera = m_cam.is_target_camera;
  1452. /**
  1453.  * Check if the object is a camera and has the MS_EYE_CONTROLS movement style.
  1454.  * @method module:camera.is_eye_camera
  1455.  * @param {Object3D} obj Object 3D
  1456.  * @returns {boolean} The result of the checking.
  1457.  */
  1458. exports.is_eye_camera = m_cam.is_eye_camera;
  1460. /**
  1461.  * Check if the object is a camera and has the MS_HOVER_CONTROLS movement style.
  1462.  * @method module:camera.is_hover_camera
  1463.  * @param {Object3D} obj Object 3D
  1464.  * @returns {boolean} The result of the checking.
  1465.  */
  1466. exports.is_hover_camera = m_cam.is_hover_camera;
  1468. function is_hmd_camera(camobj) {
  1469.     if (!m_obj_util.is_camera(camobj)) {
  1470.         m_print.error("is_hmd_camera(): Wrong camera object");
  1471.         return false;
  1472.     }
  1474.     var active_scene = m_scs.get_active();
  1475.     var cam_scene_data = m_obj_util.get_scene_data(camobj, active_scene);
  1476.     var cameras = cam_scene_data.cameras;
  1477.     for (var i = 0; i < cameras.length; i++) {
  1478.         var cam = cameras[i];
  1480.         if (cam.type == m_cam.TYPE_HMD_LEFT ||
  1481.                 cam.type == m_cam.TYPE_HMD_RIGHT)
  1482.             return true;
  1483.     }
  1485.     return false;
  1486. }
  1488. /**
  1489.  * Get movement style of the camera.
  1490.  * @method module:camera.get_move_style
  1491.  * @param {Object3D} camobj Camera 3D-object.
  1492.  * @returns {?CameraMoveStyle} Camera movement style.
  1493.  */
  1494. exports.get_move_style = function(camobj) {
  1495.     if (!m_obj_util.is_camera(camobj)) {
  1496.         m_print.error("get_move_style(): Wrong camera object");
  1497.         return null;
  1498.     }
  1500.     return m_cam.get_move_style(camobj);
  1501. }
  1503. /**
  1504.  * Translates the STATIC/EYE camera. Performs parallel translation for the TARGET/HOVER
  1505.  * camera and its pivot.
  1506.  * @method module:camera.set_translation
  1507.  * @param {Object3D} camobj Camera 3D-object.
  1508.  * @param {Vec3} trans New camera position.
  1509.  */
  1510. exports.set_translation = function(camobj, trans) {
  1511.     if (!m_obj_util.is_camera(camobj)) {
  1512.         m_print.error("set_translation(): Wrong camera object");
  1513.         return;
  1514.     }
  1516.     var render = camobj.render;
  1518.     if (m_cam.is_target_camera(camobj)) {
  1519.         var cam_trans = m_tsr.get_trans_view(render.world_tsr);
  1520.         var trans_delta = m_vec3.subtract(trans, cam_trans, _vec3_tmp);
  1521.         m_vec3.add(trans_delta, render.pivot, render.pivot);
  1522.     } else if (m_cam.is_hover_camera(camobj)) {
  1523.         var cam_trans = m_tsr.get_trans_view(render.world_tsr);
  1524.         var trans_delta = m_vec3.subtract(trans, cam_trans, _vec3_tmp);
  1525.         m_vec3.add(trans_delta, render.hover_pivot, render.hover_pivot);
  1526.     }
  1527.     m_trans.set_translation(camobj, trans);
  1529.     m_trans.update_transform(camobj);
  1530.     m_phy.sync_transform(camobj);
  1531. }
  1533. /**
  1534.  * Get the camera's translation vector.
  1535.  * @method module:camera.get_translation
  1536.  * @param {Object3D} camobj Camera 3D-object.
  1537.  * @param {Vec3} [dest=new Float32Array(3);] Destination vector.
  1538.  * @returns {?Vec3} Destination vector.
  1539.  */
  1540. exports.get_translation = function(camobj, dest) {
  1541.     if (!m_obj_util.is_camera(camobj)) {
  1542.         m_print.error("get_translation(): Wrong camera object");
  1543.         return null;
  1544.     }
  1546.     dest = dest || new Float32Array(3);
  1547.     return m_trans.get_translation(camobj, dest);
  1548. }
  1550. /**
  1551.  * Rotate the TARGET/EYE/HOVER camera counterclockwise (CCW) by the given
  1552.  * angles depending on the camera's movement style.
  1553.  * Performs the delta rotation or sets the camera's absolute rotation depending
  1554.  * on the "*_is_abs" parameters.
  1555.  * @see https://www.blend4web.com/doc/en/camera.html#camera-spherical-coordinates
  1556.  * @method module:camera.rotate_camera
  1557.  * @param {Object3D} camobj Camera 3D-object.
  1558.  * @param {number} phi Azimuth angle in radians
  1559.  * @param {number} theta Elevation angle in radians
  1560.  * @param {boolean} [is_abs=false] Performs delta rotation if FALSE, sets camera's absolute rotation if TRUE.
  1561.  */
  1562. exports.rotate_camera = function(camobj, phi, theta, is_abs) {
  1563.     if (!m_obj_util.is_camera(camobj)) {
  1564.         m_print.error("rotate_camera(): Wrong camera object");
  1565.         return;
  1566.     }
  1568.     is_abs = is_abs || false;
  1570.     
  1571.     if (is_abs)
  1572.         m_cam.set_rotation_angles(camobj, phi, theta);
  1573.     else
  1574.         m_cam.rotate_angles(camobj, phi, theta);
  1576.     m_trans.update_transform(camobj);
  1577.     m_phy.sync_transform(camobj);
  1578. }
  1580. /**
  1581.  * Set velocity parameters for the camera.
  1582.  * @method module:camera.set_velocities
  1583.  * @param {Object3D} camobj Camera 3D-object.
  1584.  * @param {VelocityParams} velocity Velocity parameters.
  1585.  */
  1586. exports.set_velocities = function(camobj, velocity) {
  1587.     if (!m_obj_util.is_camera(camobj)) {
  1588.         m_print.error("set_velocities(): Wrong camera object");
  1589.         return;
  1590.     }
  1592.     var render = camobj.render;
  1593.     if (typeof velocity.trans == "number")
  1594.         render.velocity_trans = m_util.clamp(velocity.trans, 0, Infinity);
  1595.     if (typeof velocity.rot == "number")
  1596.         render.velocity_rot = m_util.clamp(velocity.rot, 0, Infinity);
  1597.     if (typeof velocity.zoom == "number")
  1598.         render.velocity_zoom = m_util.clamp(velocity.zoom, 0, 0.99);
  1599. }
  1601. /**
  1602.  * Get velocity parameters of the camera.
  1603.  * @method module:camera.get_velocities
  1604.  * @param {Object3D} camobj Camera 3D-object.
  1605.  * @param {VelocityParams} dest The receiving object.
  1606.  * @returns {?VelocityParams} Velocity parameters.
  1607.  */
  1608. exports.get_velocities = function(camobj, dest) {
  1609.     if (!m_obj_util.is_camera(camobj)) {
  1610.         m_print.error("get_velocities(): Wrong camera object");
  1611.         return null;
  1612.     }
  1614.     var render = camobj.render;
  1615.     dest = dest || {};
  1616.     dest.trans = render.velocity_trans;
  1617.     dest.rot = render.velocity_rot;
  1618.     dest.zoom = render.velocity_zoom;
  1619.     return dest;
  1620. }
  1622. /**
  1623.  * Check whether the camera is looking upwards.
  1624.  * @method module:camera.is_look_up
  1625.  * @param {Object3D} camobj Camera 3D-object.
  1626.  * @returns {boolean} The result of the checking.
  1627.  */
  1628. exports.is_look_up = function(camobj) {
  1629.     if (!m_obj_util.is_camera(camobj)) {
  1630.         m_print.error("is_look_up(): Wrong camera object");
  1631.         return false;
  1632.     }
  1634.     var quat = m_tsr.get_quat_view(camobj.render.world_tsr);
  1635.     var dir = m_util.quat_to_dir(quat, m_util.AXIS_MZ, _vec3_tmp);
  1637.     return dir[1] >= 0;
  1638. }
  1640. /**
  1641.  * Get the angles of horizontal (azimuth) and vertical (elevation) rotation
  1642.  * (CCW as seen from the rotation axis) of the TARGET/HOVER camera, or the
  1643.  * analogous orientation angles of the EYE camera.
  1644.  * Intended for the cameras with corrected up vector.
  1645.  * @see https://www.blend4web.com/doc/en/camera.html#camera-spherical-coordinates
  1646.  * @method module:camera.get_camera_angles
  1647.  * @param {Object3D} camobj Camera 3D-object.
  1648.  * @param {?Vec2} [dest=new Float32Array(2);] Destination vector for the camera
  1649.  * angles (in radians): [phi, theta], phi: [0, 2Pi], theta: [-Pi, Pi].
  1650.  * @returns {?Vec2} Destination vector for the camera angles (in radians): [phi, theta].
  1651.  */
  1652. exports.get_camera_angles = function(camobj, dest) {
  1653.     if (!m_obj_util.is_camera(camobj)) {
  1654.         m_print.error("get_camera_angles(): Wrong camera object");
  1655.         return null;
  1656.     }
  1658.     dest = dest || new Float32Array(2);
  1659.     m_cam.get_camera_angles(camobj, dest);
  1660.     return dest;
  1661. }
  1663. /**
  1664.  * Get the angles of horizontal (azimuth) and vertical (elevation) rotation
  1665.  * (CCW as seen from the rotation axis) of the TARGET/HOVER camera, or the
  1666.  * analogous orientation angles of the EYE camera.
  1667.  * The angles are converted for the character object.
  1668.  * Intended for the cameras with corrected up vector.
  1669.  * @see https://www.blend4web.com/doc/en/camera.html#camera-spherical-coordinates
  1670.  * @method module:camera.get_camera_angles_char
  1671.  * @param {Object3D} camobj Camera 3D-object.
  1672.  * @param {?Vec2} [dest=new Float32Array(2);] Destination vector for the camera
  1673.  * angles (in radians): [phi, theta], phi: [0, 2Pi], theta: [-Pi, Pi].
  1674.  * @returns {?Vec2} Destination vector for the camera angles (in radians): [phi, theta].
  1675.  */
  1676. exports.get_camera_angles_char = function(camobj, dest) {
  1677.     if (!m_obj_util.is_camera(camobj)) {
  1678.         m_print.error("get_camera_angles_char(): Wrong camera object");
  1679.         return null;
  1680.     }
  1682.     dest = dest || new Float32Array(2);
  1683.     m_cam.get_camera_angles_char(camobj, dest);
  1684.     return dest;
  1685. }
  1687. /**
  1688.  * Get the angles of horizontal (azimuth) and vertical (elevation) rotation
  1689.  * (CCW as seen from the rotation axis) of the TARGET/HOVER camera, or the
  1690.  * analogous orientation angles of the EYE camera from the given direction 
  1691.  * representing the view vector of the camera, which up vector is vertically aligned.
  1692.  * @see https://www.blend4web.com/doc/en/camera.html#camera-spherical-coordinates
  1693.  * @method module:camera.get_camera_angles_dir
  1694.  * @param {Vec3} dir Direction representing the view vector of the camera.
  1695.  * @param {?Vec2} [dest=new Float32Array(2);] Destination vector for the camera
  1696.  * angles (in radians): [phi, theta], phi: [0, 2Pi], theta: [-Pi, Pi].
  1697.  * @returns {?Vec2} Destination vector for the camera angles (in radians): [phi, theta].
  1698.  * @example
  1699.  * var m_cam = require("camera");
  1700.  * var m_vec3 = require("vec3");
  1701.  *
  1702.  * var view_vec = m_vec3.fromValues(10, 5, -3);
  1703.  * var angles = new Float32Array(2);
  1704.  * m_cam.get_camera_angles_dir(view_vec, angles);
  1705.  * var phi = angles[0], theta = angles[1];
  1706.  */
  1707. exports.get_camera_angles_dir = function(dir, dest) {
  1708.     dest = dest || new Float32Array(2);
  1710.     var dir_norm = m_vec3.normalize(dir, _vec3_tmp);
  1711.     var quat = m_util.rotation_to_stable(m_util.AXIS_MZ, dir_norm, _quat_tmp);
  1712.     m_util.correct_cam_quat_up(quat, true);
  1713.     m_cam.get_camera_angles_from_quat(quat, m_util.AXIS_Z, dest);
  1714.     return dest;
  1715. }
  1717. /**
  1718.  * Set the distance to the convergence plane of the stereoscopic camera.
  1719.  * @method module:camera.set_stereo_distance
  1720.  * @param {Object3D} camobj Camera 3D-object.
  1721.  * @param {number} conv_dist Distance from the convergence plane.
  1722.  */
  1723. exports.set_stereo_distance = function(camobj, conv_dist) {
  1724.     if (!m_obj_util.is_camera(camobj)) {
  1725.         m_print.error("set_stereo_distance(): Wrong camera object");
  1726.         return;
  1727.     }
  1729.     var active_scene = m_scs.get_active();
  1730.     var cam_scene_data = m_obj_util.get_scene_data(camobj, active_scene);
  1731.     var cameras = cam_scene_data.cameras;
  1732.     for (var i = 0; i < cameras.length; i++) {
  1733.         var cam = cameras[i];
  1734.         if (cam.type == m_cam.TYPE_STEREO_LEFT ||
  1735.                 cam.type == m_cam.TYPE_STEREO_RIGHT ||
  1736.                 cam.type == m_cam.TYPE_HMD_LEFT ||
  1737.                 cam.type == m_cam.TYPE_HMD_RIGHT)
  1738.             m_cam.set_stereo_params(cam, conv_dist, cam.stereo_eye_dist);
  1739.     }
  1740. }
  1741. /**
  1742.  * Get the distance from the convergence plane of the stereoscopic camera.
  1743.  * @method module:camera.get_stereo_distance
  1744.  * @param {Object3D} camobj Camera 3D-object.
  1745.  * @returns {number} Distance from convergence plane.
  1746.  */
  1747. exports.get_stereo_distance = function(camobj) {
  1748.     if (!m_obj_util.is_camera(camobj)) {
  1749.         m_print.error("get_stereo_distance(): Wrong camera object");
  1750.         return 0;
  1751.     }
  1753.     var active_scene = m_scs.get_active();
  1754.     var cam_scene_data = m_obj_util.get_scene_data(camobj, active_scene);
  1755.     var cameras = cam_scene_data.cameras;
  1756.     for (var i = 0; i < cameras.length; i++) {
  1757.         var cam = cameras[i];
  1758.         if (cam.type == m_cam.TYPE_STEREO_LEFT ||
  1759.                 cam.type == m_cam.TYPE_STEREO_RIGHT)
  1760.             return cam.stereo_conv_dist;
  1761.     }
  1763.     return 0;
  1764. }
  1766. /**
  1767.  * Set the distance between eyes of the stereoscopic camera.
  1768.  * @method module:camera.set_eye_distance
  1769.  * @param {Object3D} camobj Camera 3D-object.
  1770.  * @param {number} eye_dist Distance between eyes.
  1771.  */
  1772. exports.set_eye_distance = function(camobj, eye_dist) {
  1773.     if (!m_obj_util.is_camera(camobj)) {
  1774.         m_print.error("set_eye_distance(): Wrong camera object");
  1775.         return;
  1776.     }
  1777.     var active_scene = m_scs.get_active();
  1778.     var cam_scene_data = m_obj_util.get_scene_data(camobj, active_scene);
  1779.     var cameras = cam_scene_data.cameras;
  1780.     m_cam.set_eye_distance(cameras, eye_dist);
  1781. }
  1783. /**
  1784.  * Get the distance between eyes of the stereoscopic camera.
  1785.  * @method module:camera.get_eye_distance
  1786.  * @param {Object3D} camobj Camera 3D-object.
  1787.  * @returns {number} Distance between eyes.
  1788.  */
  1789. exports.get_eye_distance = function(camobj) {
  1790.     if (!m_obj_util.is_camera(camobj)) {
  1791.         m_print.error("get_eye_distance(): Wrong camera object");
  1792.         return 0;
  1793.     }
  1795.     var active_scene = m_scs.get_active();
  1796.     var cam_scene_data = m_obj_util.get_scene_data(camobj, active_scene);
  1797.     var cameras = cam_scene_data.cameras;
  1798.     for (var i = 0; i < cameras.length; i++) {
  1799.         var cam = cameras[i];
  1800.         if (cam.type == m_cam.TYPE_STEREO_LEFT ||
  1801.                 cam.type == m_cam.TYPE_STEREO_RIGHT ||
  1802.                 cam.type == m_cam.TYPE_HMD_LEFT ||
  1803.                 cam.type == m_cam.TYPE_HMD_RIGHT)
  1804.             return cam.stereo_eye_dist;
  1805.     }
  1807.     return 0;
  1808. }
  1810. /**
  1811.  * Set vertical axis of the camera.
  1812.  * @method module:camera.set_vertical_axis
  1813.  * @param {Object3D} camobj Camera 3D-object.
  1814.  * @param {Vec3} axis Vertical axis.
  1815.  */
  1816. exports.set_vertical_axis = function(camobj, axis) {
  1817.     if (!m_obj_util.is_camera(camobj)) {
  1818.         m_print.error("set_vertical_axis(): Wrong camera object");
  1819.         return;
  1820.     }
  1822.     var render = camobj.render;
  1823.     m_vec3.copy(axis, render.vertical_axis);
  1825.     m_trans.update_transform(camobj);
  1826.     m_phy.sync_transform(camobj);
  1827. }
  1829. /**
  1830.  * Get vertical axis of the camera.
  1831.  * @method module:camera.get_vertical_axis
  1832.  * @param {Object3D} camobj Camera 3D-object.
  1833.  * @param {?Vec3} [dest=m_vec3.create();] Destination vector.
  1834.  * @returns {?Vec3} Destination vector.
  1835.  */
  1836. exports.get_vertical_axis = function(camobj, dest) {
  1837.     if (!m_obj_util.is_camera(camobj)) {
  1838.         m_print.error("get_vertical_axis(): Wrong camera object");
  1839.         return;
  1840.     }
  1842.     if (!dest)
  1843.         dest = m_vec3.create();
  1845.     var render = camobj.render;
  1846.     m_vec3.copy(render.vertical_axis, dest);
  1848.     return dest;
  1849. }
  1851. /**
  1852.  * Translate the view plane of the camera.
  1853.  * Modify the projection matrix of the camera so it appears to be moving in up-down
  1854.  * and left-right directions. This method can be used to imitate character
  1855.  * walking/running/driving.
  1856.  * @method module:camera.translate_view
  1857.  * @param {Object3D} camobj Camera 3D-object.
  1858.  * @param {number} x X coord (positive - left to right).
  1859.  * @param {number} y Y coord (positive - down to up).
  1860.  * @param {number} angle Rotation angle in radians (clockwise).
  1861.  */
  1862. exports.translate_view = function(camobj, x, y, angle) {
  1863.     if (!m_obj_util.is_camera(camobj)) {
  1864.         m_print.error("translate_view(): Wrong camera object");
  1865.         return;
  1866.     }
  1868.     var active_scene = m_scs.get_active();
  1869.     var cam_scene_data = m_obj_util.get_scene_data(camobj, active_scene);
  1870.     var cameras = cam_scene_data.cameras;
  1871.     for (var i = 0; i < cameras.length; i++) {
  1872.         var cam = cameras[i];
  1874.         m_vec3.set(-x, -y, 0, cam.view_transform_params.trans);
  1875.         // cam.view_transform_params.angle = angle;
  1877.         if (cam.reflection_plane)
  1878.             m_cam.set_projection_reflect(cam, false);
  1879.         else
  1880.             m_cam.set_projection(cam, false);
  1881.     }
  1882. }
  1884. /**
  1885.  * Get camera view vector in world space.
  1886.  * @method module:camera.get_view_vector
  1887.  * @param {Object3D} camobj Camera 3D-object.
  1888.  * @param {?Vec3} [dest=new Float32Array(3);] Destination vector.
  1889.  * @returns {?Vec3} Destination vector.
  1890.  */
  1891. exports.get_view_vector = get_view_vector;
  1892. function get_view_vector(camobj, dest) {
  1893.     if (!m_obj_util.is_camera(camobj)) {
  1894.         m_print.error("get_view_vector(): Wrong camera object");
  1895.         return null;
  1896.     }
  1898.     dest = dest || new Float32Array(3);
  1899.     var quat = m_tsr.get_quat_view(camobj.render.world_tsr);
  1900.     m_util.quat_to_dir(quat, m_util.AXIS_MZ, dest);
  1902.     return dest;
  1903. }
  1905. /**
  1906.  * Get the vertical angle of the camera's field of view.
  1907.  * @method module:camera.get_fov
  1908.  * @param {Object3D} camobj Camera 3D-object.
  1909.  * @returns {number} Camera field of view (in radians).
  1910.  */
  1911. exports.get_fov = function(camobj) {
  1912.     if (!m_obj_util.is_camera(camobj)) {
  1913.         m_print.error("get_fov(): Wrong camera object");
  1914.         return 0;
  1915.     }
  1916.     var active_scene = m_scs.get_active();
  1917.     var cam_scene_data = m_obj_util.get_scene_data(camobj, active_scene);
  1918.     var cameras = cam_scene_data.cameras;
  1919.     return m_cam.get_fov(cameras[0]);
  1920. }
  1922. /**
  1923.  * Set the vertical angle of the camera's field of view.
  1924.  * @method module:camera.set_fov
  1925.  * @param {Object3D} camobj Camera 3D-object.
  1926.  * @param {number} fov New camera field of view (in radians).
  1927.  */
  1928. exports.set_fov = function(camobj, fov) {
  1929.     if (!m_obj_util.is_camera(camobj)) {
  1930.         m_print.error("set_fov(): Wrong camera object");
  1931.         return;
  1932.     }
  1934.     var active_scene = m_scs.get_active();
  1935.     var cam_scene_data = m_obj_util.get_scene_data(camobj, active_scene);
  1936.     var cameras = cam_scene_data.cameras;
  1937.     for (var i = 0; i < cameras.length; i++) {
  1938.         var cam = cameras[i];
  1940.         m_cam.set_fov(cam, fov);
  1942.         if (cam.reflection_plane)
  1943.             m_cam.set_projection_reflect(cam, false);
  1944.         else
  1945.             m_cam.set_projection(cam, false);
  1946.     }
  1947. }
  1949. /**
  1950.  * Set the angles of the camera's field of view (for head-mounted display only).
  1951.  * @method module:camera.set_hmd_fov
  1952.  * @param {Object3D} camobj Camera 3D-object.
  1953.  * @param {Vec4} hmd_left_fov New left camera field of view.
  1954.  * @param {Vec4} hmd_right_fov New right camera field of view.
  1955.  * @deprecated Do not use it anymore
  1956.  */
  1957. exports.set_hmd_fov = function(camobj, hmd_left_fov, hmd_right_fov) {
  1958.     m_print.error_once("set_hmd_fov() deprecated");
  1959. }
  1961. /**
  1962.  * Correct the UP vector of the camera.
  1963.  * @method module:camera.correct_up
  1964.  * @param {Object3D} camobj Camera 3D-object.
  1965.  * @param {Vec3} [z_axis=util.AXIS_Z] Axis vector.
  1966.  * @param {boolean} [strict=false] Align camera exactly with the direction of 
  1967.  * the given axis vector (never with the opposite direction).
  1968.  */
  1969. exports.correct_up = function(camobj, z_axis, strict) {
  1970.     if (!m_obj_util.is_camera(camobj)) {
  1971.         m_print.error("correct_up(): Wrong camera object");
  1972.         return;
  1973.     }
  1975.     z_axis = z_axis || camobj.render.vertical_axis;
  1976.     m_cam.correct_up(camobj, z_axis, strict || false);
  1978.     m_trans.update_transform(camobj);
  1979.     m_phy.sync_transform(camobj);
  1980. }
  1982. /**
  1983.  * Set the orthogonal scale of the camera.
  1984.  * @method module:camera.set_ortho_scale
  1985.  * @param {Object3D} camobj Camera 3D-object.
  1986.  * @param {number} ortho_scale Orthogonal scale.
  1987.  */
  1988. exports.set_ortho_scale = function(camobj, ortho_scale) {
  1989.     if (!m_obj_util.is_camera(camobj) || !m_cam.is_ortho_camera(camobj)) {
  1990.         m_print.error("set_ortho_scale(): Wrong camera object");
  1991.         return;
  1992.     }
  1994.     var render = camobj.render;
  1996.     if (m_cam.is_target_camera(camobj)) {
  1997.         var trans = m_tsr.get_trans_view(render.world_tsr);
  1998.         var dir_dist = m_vec3.dist(trans, render.pivot);
  1999.         render.init_fov = ortho_scale / 2 * render.init_dist / dir_dist;
  2000.     } else if (m_cam.is_hover_camera(camobj)) {
  2001.         var trans = m_tsr.get_trans_view(render.world_tsr);
  2002.         var dir_dist = m_vec3.distance(trans, render.hover_pivot);
  2003.         render.init_fov = ortho_scale / 2 * render.init_dist / dir_dist;
  2004.     } else {
  2005.         var active_scene = m_scs.get_active();
  2006.         var cam_scene_data = m_obj_util.get_scene_data(camobj, active_scene);
  2007.         // hover camera without distance limits, EYE or STATIC camera
  2008.         cam_scene_data.cameras[0].fov = ortho_scale / 2;
  2009.     }
  2011.     m_cam.update_ortho_scale(camobj);
  2012. }
  2014. /**
  2015.  * Get the orthogonal scale of the camera.
  2016.  * @method module:camera.get_ortho_scale
  2017.  * @param {Object3D} camobj Camera 3D-object.
  2018.  * @returns {number} Orthogonal scale.
  2019.  */
  2020. exports.get_ortho_scale = function(camobj) {
  2021.     if (!m_obj_util.is_camera(camobj) || !m_cam.is_ortho_camera(camobj)) {
  2022.         m_print.error("get_ortho_scale(): Wrong camera object");
  2023.         return 0;
  2024.     }
  2025.     var active_scene = m_scs.get_active();
  2026.     var cam_scene_data = m_obj_util.get_scene_data(camobj, active_scene);
  2027.     return cam_scene_data.cameras[0].fov * 2;
  2028. }
  2030. /**
  2031.  * Check whether the camera is an ORTHO camera.
  2032.  * @method module:camera.is_ortho_camera
  2033.  * @param {Object3D} camobj Camera 3D-object.
  2034.  * @returns {boolean} The result of the checking.
  2035.  */
  2036. exports.is_ortho_camera = function(camobj) {
  2037.     if (!m_obj_util.is_camera(camobj)) {
  2038.         m_print.error("is_ortho_camera(): Wrong camera object");
  2039.         return false;
  2040.     }
  2042.     return m_cam.is_ortho_camera(camobj);
  2043. }
  2045. /**
  2046.  * Calculate the direction of the camera ray based on the Canvas coordinates.
  2047.  * The origin of the Canvas space is located in the top left corner of the Canvas.
  2048.  * @method module:camera.calc_ray
  2049.  * @param {Object3D} camobj Camera 3D-object.
  2050.  * @param {number} canvas_x X Canvas coordinate.
  2051.  * @param {number} canvas_y Y Canvas coordinate.
  2052.  * @param {?ParametricLine} [dest=new Float32Array(6);] Destination parametric line.
  2053.  * @returns {?ParametricLine} Destination parametric line.
  2054.  */
  2055. exports.calc_ray = function(camobj, canvas_x, canvas_y, dest) {
  2056.     if (!m_obj_util.is_camera(camobj)) {
  2057.         m_print.error("calc_ray(): Wrong camera object");
  2058.         return null;
  2059.     }
  2060.     var active_scene = m_scs.get_active();
  2061.     var cam_scene_data = m_obj_util.get_scene_data(camobj, active_scene);
  2062.     var cam = cam_scene_data.cameras[0];
  2063.     // NOTE: It's for compatibility.
  2064.     if (dest && dest.length == 3)
  2065.         m_print.error_once("dest parameter in the function \"calc_ray\" " +
  2066.                 "should be type of parametric line.");
  2067.     else
  2068.         dest = dest || new Float32Array(6);
  2070.     switch (cam.type) {
  2071.     case m_cam.TYPE_PERSP:
  2072.     case m_cam.TYPE_PERSP_ASPECT:
  2073.     case m_cam.TYPE_STEREO_LEFT:
  2074.     case m_cam.TYPE_STEREO_RIGHT:
  2075.         var top_1m = Math.tan(m_cam.get_vfov(cam) / 2);
  2076.         var right_1m = top_1m * cam.aspect;
  2078.         var dir = _vec3_tmp;
  2080.         var viewport_xy = m_cont.canvas_to_viewport_coords(canvas_x, canvas_y,
  2081.             _vec2_tmp, cam);
  2083.         // in the camera's local space
  2084.         dir[0] = (2.0 * viewport_xy[0] / cam.width - 1.0) * right_1m;
  2085.         dir[1] = (1.0 - 2.0 * viewport_xy[1] / cam.height) * top_1m;
  2086.         dir[2] = -1;
  2088.         m_tsr.transform_dir_vec3(dir, camobj.render.world_tsr, dir);
  2090.         m_vec3.normalize(dir, dir);
  2092.         if (dest.length == 3)
  2093.             m_vec3.copy(dir, dest);
  2094.         else {
  2095.             var cam_eye = m_trans.get_translation(camobj, _vec3_tmp2);
  2096.             m_math.set_pline_initial_point(dest, cam_eye);
  2097.             m_math.set_pline_directional_vec(dest, dir);
  2098.         }
  2100.         return dest;
  2101.     case m_cam.TYPE_ORTHO:
  2103.         var dir = _vec3_tmp;
  2104.         var viewport_xy = m_cont.canvas_to_viewport_coords(canvas_x, canvas_y,
  2105.                 _vec2_tmp, cam);
  2107.         dir[0] = (2.0 * viewport_xy[0] / cam.width - 1.0) * cam.top * cam.aspect;
  2108.         dir[1] = (1.0 - 2.0 * viewport_xy[1] / cam.height) * cam.top;
  2109.         dir[2] = 0;
  2111.         m_tsr.transform_vec3(dir, camobj.render.world_tsr, dir);
  2112.         m_vec3.copy(dir, dest);
  2114.         var quat = m_tsr.get_quat_view(camobj.render.world_tsr, _vec4_tmp);
  2115.         m_vec3.transformQuat(m_util.AXIS_MZ, quat, dir);
  2117.         m_math.set_pline_directional_vec(dest, dir);
  2118.         return dest;
  2119.     default:
  2120.         m_print.error("calc_ray(): Non-compatible camera");
  2121.         return dest;
  2122.     }
  2123. }
  2125. /**
  2126.  * Project the 3D point to the Canvas.
  2127.  * Returned coordinates are measured in CSS pixels.
  2128.  * @method module:camera.project_point
  2129.  * @param {Object3D} camobj Camera 3D-object.
  2130.  * @param {Vec3} point Point in world space.
  2131.  * @param {Vec2|Vec3} [dest=new Float32Array(2);] Destination canvas coordinates
  2132.  * (vec2 - X/Y, vec3 - X/Y/DEPTH).
  2133.  * @returns {Vec2|Vec3} Destination canvas coordinates.
  2134.  */
  2135. exports.project_point = function(camobj, point, dest) {
  2136.     if (!m_obj_util.is_camera(camobj)) {
  2137.         m_print.error("project_point(): Wrong camera object");
  2138.         return null;
  2139.     }
  2141.     dest = dest || new Float32Array(2);
  2142.     return m_cam.project_point(camobj, point, dest);
  2143. }
  2145. /**
  2146.  * Check whether the camera has distance limits.
  2147.  * @method module:camera.has_distance_limits
  2148.  * @param {Object3D} camobj Camera 3D-object.
  2149.  * @returns {boolean} The result of the checking.
  2150.  */
  2151. exports.has_distance_limits = function(camobj) {
  2152.     return (m_cam.is_target_camera(camobj) || m_cam.is_hover_camera(camobj)) 
  2153.         && camobj.render.distance_limits !== null;
  2154. }
  2156. /**
  2157.  * Check whether the camera has any vertical rotation limits.
  2158.  * @method module:camera.has_vertical_rot_limits
  2159.  * @param {Object3D} camobj Camera 3D-object.
  2160.  * @returns {boolean} The result of the checking.
  2161.  */
  2162. exports.has_vertical_rot_limits = function(camobj) {
  2163.     return (m_cam.is_eye_camera(camobj) || m_cam.is_target_camera(camobj) 
  2164.             || m_cam.is_hover_camera(camobj)) && camobj.render.vertical_limits !== null;
  2165. }
  2167. /**
  2168.  * Check whether the camera has any horizontal rotation limits.
  2169.  * @method module:camera.has_horizontal_rot_limits
  2170.  * @param {Object3D} camobj Camera 3D-object.
  2171.  * @returns {boolean} The result of the checking.
  2172.  */
  2173. exports.has_horizontal_rot_limits = function(camobj) {
  2174.     return (m_cam.is_target_camera(camobj) || m_cam.is_eye_camera(camobj)) 
  2175.             && camobj.render.horizontal_limits !== null;
  2176. }
  2178. /**
  2179.  * Check whether the camera has any vertical translation limits.
  2180.  * @method module:camera.has_vertical_trans_limits
  2181.  * @param {Object3D} camobj Camera 3D-object.
  2182.  * @returns {boolean} The result of the checking.
  2183.  */
  2184. exports.has_vertical_trans_limits = function(camobj) {
  2185.     return m_cam.is_hover_camera(camobj) && camobj.render.hover_vert_trans_limits !== null;
  2186. }
  2188. /**
  2189.  * Check whether the camera has any horizontal translation limits.
  2190.  * @method module:camera.has_horizontal_trans_limits
  2191.  * @param {Object3D} camobj Camera 3D-object.
  2192.  * @returns {boolean} The result of the checking.
  2193.  */
  2194. exports.has_horizontal_trans_limits = function(camobj) {
  2195.     return m_cam.is_hover_camera(camobj) && camobj.render.hover_horiz_trans_limits !== null;
  2196. }
  2198. /**
  2199.  * Get camera frustum planes.
  2200.  * @method module:camera.get_frustum_planes
  2201.  * @param {Object3D} camobj Camera object.
  2202.  * @param {FrustumPlanes} planes Frustum planes object.
  2203.  * @returns {?FrustumPlanes} Frustum planes object.
  2204.  */
  2205. exports.get_frustum_planes = function(camobj, planes) {
  2206.     if (!m_obj_util.is_camera(camobj)) {
  2207.         m_print.error("get_frustum_planes(): Wrong camera object");
  2208.         return null;
  2209.     }
  2210.     var active_scene = m_scs.get_active();
  2211.     var cam_scene_data = m_obj_util.get_scene_data(camobj, active_scene);
  2212.     var fr_planes = cam_scene_data.cameras[0].frustum_planes;
  2213.     m_vec4.copy(fr_planes.left, planes.left);
  2214.     m_vec4.copy(fr_planes.right, planes.right);
  2215.     m_vec4.copy(fr_planes.top, planes.top);
  2216.     m_vec4.copy(fr_planes.bottom, planes.bottom);
  2217.     m_vec4.copy(fr_planes.near, planes.near);
  2218.     m_vec4.copy(fr_planes.far, planes.far);
  2220.     return planes;
  2221. }
  2223. /**
  2224.  * Set camera projection matrix.
  2225.  * @method module:camera.set_projection
  2226.  * @param {Object3D} camobj Camera object.
  2227.  * @param {Float32Array} matrix Projection matrix.
  2228.  */
  2229. exports.set_projection = function(camobj, matrix) {
  2230.     if (!m_obj_util.is_camera(camobj))
  2231.         m_print.error("set_projection(): Wrong camera object");
  2232.     else
  2233.         m_cam.set_proj_mat(camobj, matrix);
  2234. }
  2236. }
  2238. var camera_factory = register("camera", Camera);
  2240. export default camera_factory;