Source: extern/constraints.js

  1. import register from "../util/register.js";
  3. import m_cam_fact from "../intern/camera.js";
  4. import m_cons_fact from "../intern/constraints.js";
  5. import m_obj_util_fact from "../intern/obj_util.js";
  6. import m_phy_fact from "../intern/physics.js";
  7. import m_print_fact from "../intern/print.js";
  8. import m_trans_fact from "../intern/transform.js";
  9. import * as m_util from "../intern/util.js";
  10. import * as m_vec3 from "../libs/gl_matrix/vec3.js";
  12. /**
  13.  * Object constraints API. Please note that these constraints are not the same
  14.  * as those assigned in Blender.
  15.  * @module constraints
  16.  * @local StiffViewportPositioning
  17.  */
  18. function Constraints(ns, exports) {
  20. var m_cam      = m_cam_fact(ns);
  21. var m_cons     = m_cons_fact(ns);
  22. var m_obj_util = m_obj_util_fact(ns);
  23. var m_phy      = m_phy_fact(ns);
  24. var m_print    = m_print_fact(ns);
  25. var m_trans    = m_trans_fact(ns);
  27. /**
  28.  * An object that defines positioning for the stiff viewport constraint.
  29.  * @typedef {Object} StiffViewportPositioning
  30.  * @property {number} [left] Offset from the left edge of the camera's viewport
  31.  * @property {number} [right] Offset from the right edge of the camera's viewport
  32.  * @property {number} [top] Offset from the top edge of the camera's viewport
  33.  * @property {number} [bottom] Offset from the bottom edge of the camera's viewport
  34.  * @property {number} [distance] Distance from the camera
  35.  * @property {Quat} [rotation] Rotation offset
  36.  * @property {string} [hor_units="widths"] Left/Right offset units: "heights" or "widths"
  37.  * @property {string} [vert_units="heights"] Top/Bottom offset units: "heights" or "widths"
  38.  * @cc_externs left right top bottom distance rotation hor_units vert_units
  39.  */
  41. /**
  42.  * Attach the object to the other object or to the armature bone using a
  43.  * stiff constraint. The child object will move, rotate and scale
  44.  * together with its parent. Examples: a sword is parented to the
  45.  * character's hand; the character is sitting in a vehicle.
  46.  *
  47.  * @method module:constraints.append_stiff
  48.  * @param {Object3D} obj Constrained object
  49.  * @param {(Object3D|Array)} target Target object or [Armature object, Bone Name]
  50.  * @param {Vec3} [offset] Offset, in the parent's local space.
  51.  * @param {Quat} [rotation_offset=null] Rotation offset, in the
  52.  * parent's local space.
  53.  * @param {number} [scale_offset=1] Scale offset, in the parent's local space.
  54.  *
  55.  * @example var m_scene = require("scenes");
  56.  * var m_const = require("constraints");
  57.  *
  58.  * var my_offset_vector = new Float32Array([2.0, 2.0, 2.0]);
  59.  *
  60.  * var my_cube = m_scene.get_object_by_name("cube");
  61.  * var my_sphere = m_scene.get_object_by_name("Icosphere");
  62.  *
  63.  * m_const.append_stiff(my_sphere, my_cube, my_offset_vector);
  64.  */
  65. exports.append_stiff = function(obj, target, offset, rotation_offset,
  66.         scale_offset) {
  68.     if (!m_obj_util.is_dynamic(obj)) {
  69.         m_print.error("Wrong object: \"" + obj.name + "\" is not dynamic.");
  70.         return;
  71.     }
  72.     if (!m_cons.check_self_applying(obj, target)) {
  73.         m_print.error("Can not apply constraint. Object and target must be different.");
  74.         return;
  75.     }
  76.     if (!m_cons.check_compatibility(obj, target)) {
  77.         m_print.error("Constraint recursion is forbidden.");
  78.         return;
  79.     }
  80.     offset = offset || new Float32Array(3);
  81.     scale_offset = scale_offset || 1;
  82.     rotation_offset =
  83.             rotation_offset ? rotation_offset : [0, 0, 0, 1];
  85.     if (target instanceof Array && target.length == 2)
  86.         m_cons.append_stiff_bone(obj, target[0], target[1], offset,
  87.                 rotation_offset, scale_offset);
  88.     else
  89.         m_cons.append_stiff_obj(obj, target, offset, rotation_offset,
  90.                 scale_offset);
  92.     m_trans.update_transform(obj);
  93.     m_phy.sync_transform(obj);
  94. }
  96. /**
  97.  * Attach the object to the other object using a
  98.  * semi-stiff constraint. The child object will move and rotate together with
  99.  * its parent, but it will be still possible to rotate it independently
  100.  * in the parent's local space. Example: a tank turret.
  101.  *
  102.  * @method module:constraints.append_semi_stiff
  103.  * @param {Object3D} obj Constrained object
  104.  * @param {Object3D} target Target object
  105.  * @param {Vec3} [offset] Offset, in the parent's local space
  106.  * @param {Quat} [rotation_offset] Initial rotation offset, in the
  107.  * parent's local space
  108.  * @param {number} [clamp_left] Left object rotation limit, in radians
  109.  * @param {number} [clamp_right] Right object rotation limit, in radians
  110.  * @param {number} [clamp_up] Upward object rotation limit, in radians
  111.  * @param {number} [clamp_down] Downward object rotation limit, in radians
  112.  *
  113.  * @example var m_scene = require("scenes");
  114.  * var m_const = require("constraints");
  115.  *
  116.  * var my_offset_vector = new Float32Array([2.0, 2.0, 2.0]);
  117.  *
  118.  * var my_cube = m_scene.get_object_by_name("cube");
  119.  * var my_sphere = m_scene.get_object_by_name("Icosphere");
  120.  *
  121.  * m_const.append_semi_stiff(my_sphere, my_cube, my_offset_vector);
  122.  */
  123. exports.append_semi_stiff = function(obj, target, offset, rotation_offset,
  124.                                             clamp_left, clamp_right,
  125.                                             clamp_up, clamp_down) {
  126.     if (!m_obj_util.is_dynamic(obj)) {
  127.         m_print.error("Wrong object: \"" + obj.name + "\" is not dynamic.");
  128.         return;
  129.     }
  130.     if (!m_cons.check_self_applying(obj, target)) {
  131.         m_print.error("Can not apply constraint. Object and target must be different.");
  132.         return;
  133.     }
  134.     if (!m_cons.check_compatibility(obj, target)) {
  135.         m_print.error("Constraint recursion is forbidden.");
  136.         return;
  137.     }
  138.     clamp_left  = m_util.isdef(clamp_left) ? clamp_left : Math.PI / 2;
  139.     clamp_right = m_util.isdef(clamp_right) ? clamp_right : -Math.PI / 2;
  140.     clamp_up    = m_util.isdef(clamp_up) ? clamp_up :  Math.PI / 2;
  141.     clamp_down  = m_util.isdef(clamp_down) ? clamp_down : -Math.PI / 2;
  142.     offset = offset || new Float32Array(3);
  143.     rotation_offset =
  144.             rotation_offset ? new Float32Array(rotation_offset) : null;
  146.     m_cons.append_semi_stiff_obj(obj, target, offset, rotation_offset,
  147.                                         clamp_left, clamp_right,
  148.                                         clamp_up, clamp_down);
  150.     m_trans.update_transform(obj);
  151.     m_phy.sync_transform(obj);
  152. }
  154. /**
  155.  * Attach the EYE camera to the object using a
  156.  * semi-stiff constraint. Also apply rotation limits to the camera.
  157.  * The camera will move and rotate together with
  158.  * its parent, but it will be still possible to rotate it independently
  159.  * in the parent's local space. The camera's UP vector will be preserved.
  160.  * Example: first-person vehicle view.
  161.  *
  162.  * @see https://www.blend4web.com/doc/en/camera.html#api
  163.  * @method module:constraints.append_semi_stiff_cam
  164.  * @param {Object3D} obj Constrained object
  165.  * @param {Object3D} target Target object
  166.  * @param {Vec3} [offset] Offset, in the parent's local space
  167.  * @param {Quat} [rotation_offset] Initial rotation offset, in the
  168.  * parent's local space
  169.  * @param {number} [clamp_left] Left camera rotation limit, in radians
  170.  * @param {number} [clamp_right] Right camera rotation limit, in radians
  171.  * @param {number} [clamp_up] Upward camera rotation limit, in radians
  172.  * @param {number} [clamp_down] Downward camera rotation limit, in radians
  173.  * @deprecated [17.06] Use {@link module:constraints.append_semi_stiff} instead
  174.  */
  175. exports.append_semi_stiff_cam = function(obj, target, offset, rotation_offset,
  176.                                             clamp_left, clamp_right,
  177.                                             clamp_up, clamp_down) {
  178.     m_print.error_deprecated("append_semi_stiff_cam", "append_semi_stiff");
  179.     if (!m_cam.is_eye_camera(obj)) {
  180.         m_print.error("append_semi_stiff_cam(): wrong object type, only EYE" +
  181.             " camera objects can be parented.");
  182.         return;
  183.     }
  184.     exports.append_semi_stiff(obj, target, offset, rotation_offset,
  185.                                             clamp_left, clamp_right,
  186.                                             clamp_up, clamp_down);
  187. }
  189. /**
  190.  * Attach the EYE camera to the object using a
  191.  * semi-soft constraint. The camera will smoothly follow the object's rear.
  192.  * Example: third-person character or vehicle views.
  193.  *
  194.  * @method module:constraints.append_semi_soft_cam
  195.  * @param {Object3D} obj Constrained object
  196.  * @param {Object3D} target Target object
  197.  * @param {Vec3} [offset] Offset, in the parent's local space
  198.  * @param {number} [softness=0.25] Camera smoothness ratio
  199.  * @deprecated [17.06] Use {@link module:constraints.append_semi_soft} instead
  200.  */
  201. exports.append_semi_soft_cam = function(obj, target, offset, softness) {
  203.     m_print.error_deprecated("append_semi_soft_cam", "append_semi_soft");
  204.     if (!m_cam.is_eye_camera(obj)) {
  205.         m_print.error("append_semi_soft_cam(): wrong object type, only EYE" +
  206.             " camera objects can be parented.");
  207.         return;
  208.     }
  209.     exports.append_semi_soft(obj, target, offset, softness);
  210. }
  212. /**
  213.  * Attach one object to another one using a
  214.  * semi-soft constraint. The object will smoothly follow the object's rear.
  215.  * Example: third-person character or vehicle views.
  216.  *
  217.  * @method module:constraints.append_semi_soft
  218.  * @param {Object3D} obj Constrained object
  219.  * @param {Object3D} target Target object
  220.  * @param {Vec3} [offset] Offset, in the parent's local space
  221.  * @param {number} [softness=0.25] Object smoothness ratio
  222.  *
  223.  * @example var m_scene = require("scenes");
  224.  * var m_const = require("constraints");
  225.  *
  226.  * var my_offset_vector = new Float32Array([2.0, 2.0, 2.0]);
  227.  * 
  228.  * var my_cube = m_scene.get_object_by_name("cube");
  229.  * var my_sphere = m_scene.get_object_by_name("Icosphere");
  230.  *
  231.  * m_const.append_semi_soft(my_sphere, my_cube, my_offset_vector, 0.5);
  232.  */
  233. exports.append_semi_soft = function(obj, target, offset, softness) {
  235.     if (!m_obj_util.is_dynamic(obj)) {
  236.         m_print.error("Wrong object: \"" + obj.name + "\" is not dynamic.");
  237.         return;
  238.     }
  239.     if (!m_cons.check_self_applying(obj, target)) {
  240.         m_print.error("Can not apply constraint. Object and target must be different.");
  241.         return;
  242.     }
  243.     if (!m_cons.check_compatibility(obj, target)) {
  244.         m_print.error("Constraint recursion is forbidden.");
  245.         return;
  246.     }
  247.     if (!m_util.isdef(softness) || softness < 0)
  248.         softness = 0.25;
  249.     offset = offset || new Float32Array(3);
  251.     m_cons.append_semi_soft_obj(obj, target, offset, softness);
  253.     m_trans.update_transform(obj);
  254.     m_phy.sync_transform(obj);
  255. }
  257. /**
  258.  * Attach the object to the other object using a
  259.  * stiff translation constraint. The child object will move together with
  260.  * its parent, but will not rotate. It will be still possible to rotate it
  261.  * independently from the parent.
  262.  * <p>
  263.  * Example: attaching the camera to the physics character in order to
  264.  * implement the first-person character view.
  265.  * </p>
  266.  * </p>
  267.  * Another example: the character
  268.  * jumps in water and splashes' particle emitter is attached to the
  269.  * first-person camera using this constraint - the bubbles will follow the
  270.  * character but will not be rotated with the camera.
  271.  * </p>
  272.  * @method module:constraints.append_stiff_trans
  273.  * @param {Object3D} obj Constrained object
  274.  * @param {Object3D} target Target object
  275.  * @param {Vec3} [offset] Offset, in the parent's local space
  276.  *
  277.  * @example var m_scene = require("scenes");
  278.  * var m_const = require("constraints");
  279.  *
  280.  * var my_offset_vector = new Float32Array([-2.0, 2.0, 2.0]);
  281.  *
  282.  * var my_cube = m_scene.get_object_by_name("cube");
  283.  * var my_sphere_4 = m_scene.get_object_by_name("Icosphere");
  284.  *
  285.  * m_const.append_stiff_trans(my_sphere, my_cube, my_offset_vector);
  286.  */
  287. exports.append_stiff_trans = function(obj, target, offset) {
  289.     if (!m_obj_util.is_dynamic(obj)) {
  290.         m_print.error("Wrong object: \"" + obj.name + "\" is not dynamic.");
  291.         return;
  292.     }
  293.     if (!m_cons.check_self_applying(obj, target)) {
  294.         m_print.error("Can not apply constraint. Object and target must be different.");
  295.         return;
  296.     }
  297.     if (!m_cons.check_compatibility(obj, target)) {
  298.         m_print.error("Constraint recursion is forbidden.");
  299.         return;
  300.     }
  301.     offset = offset || new Float32Array(3);
  302.     m_cons.append_stiff_trans_obj(obj, target, offset);
  304.     m_trans.update_transform(obj);
  305.     m_phy.sync_transform(obj);
  306. }
  308. /**
  309.  * Attach the object to the other object using a copy location constraint.
  310.  * The child object will move together with its parent, but will not rotate.
  311.  * Note that the offset is the object's location in the world space.
  312.  * <p>
  313.  * This method works similarly to the <b>Copy Location</b> constraint in Blender.
  314.  * </p>
  315.  * @method module:constraints.append_copy_loc
  316.  * @param {Object3D} obj Constrained object
  317.  * @param {Object3D} target Target object
  318.  * @param {string} [axes='XYZ'] Copy the target's location
  319.  * @param {boolean} [use_offset=false] Add original location into copied location
  320.  * @param {number} [influence=1] Amount of influence constraint will have on the final solution
  321.  *
  322.  * @example var m_scene = require("scenes");
  323.  * var m_const = require("constraints");
  324.  *
  325.  * var my_cube = m_scene.get_object_by_name("cube");
  326.  * var my_sphere = m_scene.get_object_by_name("Icosphere");
  327.  *
  328.  * m_const.append_copy_loc(my_sphere, my_cube, 'XYZ', false, 0.5);
  329.  */
  330. exports.append_copy_loc = function(obj, target, axes, use_offset, influence) {
  332.     if (!m_obj_util.is_dynamic(obj)) {
  333.         m_print.error("Wrong object: \"" + obj.name + "\" is not dynamic.");
  334.         return;
  335.     }
  336.     if (!m_cons.check_self_applying(obj, target)) {
  337.         m_print.error("Can not apply constraint. Object and target must be different.");
  338.         return;
  339.     }
  340.     if (!m_cons.check_compatibility(obj, target)) {
  341.         m_print.error("Constraint recursion is forbidden.");
  342.         return;
  343.     }
  344.     use_offset = use_offset || false;
  345.     axes = axes || "XYZ";
  346.     influence = influence || 1;
  347.     var offset = m_trans.get_translation(obj, new Float32Array(3));
  348.     var used_axes = new Float32Array(3);
  349.     used_axes[0] = axes.indexOf("-X") != -1 ? -1 : axes.indexOf("X") != -1 ? 1 : 0;
  350.     used_axes[1] = axes.indexOf("-Y") != -1 ? -1 : axes.indexOf("Y") != -1 ? 1 : 0;
  351.     used_axes[2] = axes.indexOf("-Z") != -1 ? -1 : axes.indexOf("Z") != -1 ? 1 : 0;
  352.     m_cons.append_copy_loc_obj(obj, target, offset, used_axes, use_offset, influence);
  354.     m_trans.update_transform(obj);
  355.     m_phy.sync_transform(obj);
  356. }
  358. /**
  359.  * Attach the object to the other object using a copy transforms constraint.
  360.  * The child object will move and rotate together with its parent.
  361.  * <p>
  362.  * This method works similarly to the <b>Copy Transforms</b> constraint in Blender.
  363.  * </p>
  364.  * @method module:constraints.append_copy_trans
  365.  * @param {Object3D} obj Constrained object
  366.  * @param {Object3D} target Target object
  367.  * @param {number} [influence=1] Amount of influence constraint will have on the final solution
  368.  *
  369.  * @example var m_scene = require("scenes");
  370.  * var m_const = require("constraints");
  371.  *
  372.  * var my_cube = m_scene.get_object_by_name("cube");
  373.  * var my_sphere = m_scene.get_object_by_name("Icosphere");
  374.  *
  375.  * m_const.append_copy_trans(my_sphere, my_cube, 0.5);
  376.  */
  377. exports.append_copy_trans = function(obj, target, influence) {
  379.     if (!m_obj_util.is_dynamic(obj)) {
  380.         m_print.error("Wrong object: \"" + obj.name + "\" is not dynamic.");
  381.         return;
  382.     }
  383.     if (!m_cons.check_self_applying(obj, target)) {
  384.         m_print.error("Can not apply constraint. Object and target must be different.");
  385.         return;
  386.     }
  387.     if (!m_cons.check_compatibility(obj, target)) {
  388.         m_print.error("Constraint recursion is forbidden.");
  389.         return;
  390.     }
  391.     influence = influence || 1;
  393.     m_cons.append_copy_trans_obj(obj, target, influence);
  395.     m_trans.update_transform(obj);
  396.     m_phy.sync_transform(obj);
  397. }
  399. /**
  400.  * Attach the object to the other object using a copy rotation constraint.
  401.  * The child object will rotate together with its parent, but will not move.
  402.  * Note that the offset is the object's rotation in the world space.
  403.  * <p> 
  404.  * This method works similarly to the <b>Copy Rotation</b> constraint in Blender.
  405.  * </p>
  406.  * @method module:constraints.append_copy_rot
  407.  * @param {Object3D} obj Constrained object
  408.  * @param {Object3D} target Target object
  409.  * @param {string} [axes='XYZ'] Copy the target's location
  410.  * @param {boolean} [use_offset=false] Add original location into copied location
  411.  * @param {number} [influence=1] Amount of influence constraint will have on the final solution
  412.  *
  413.  * @example var m_scene = require("scenes");
  414.  * var m_const = require("constraints");
  415.  *
  416.  * var my_cube = m_scene.get_object_by_name("cube");
  417.  * var my_sphere = m_scene.get_object_by_name("Icosphere");
  418.  *
  419.  * m_const.append_copy_rot(my_sphere, my_cube, 'XYZ', 0.5);
  420.  */
  421. exports.append_copy_rot = function(obj, target, axes, use_offset, influence) {
  423.     if (!m_obj_util.is_dynamic(obj)) {
  424.         m_print.error("Wrong object: \"" + obj.name + "\" is not dynamic.");
  425.         return;
  426.     }
  427.     if (!m_cons.check_self_applying(obj, target)) {
  428.         m_print.error("Can not apply constraint. Object and target must be different.");
  429.         return;
  430.     }
  431.     if (!m_cons.check_compatibility(obj, target)) {
  432.         m_print.error("Constraint recursion is forbidden.");
  433.         return;
  434.     }
  435.     use_offset = use_offset || false;
  436.     axes = axes || "XYZ";
  437.     influence = influence || 1;
  438.     var used_axes = new Float32Array(3);
  439.     used_axes[0] = axes.indexOf("-X") != -1 ? -1 : axes.indexOf("X") != -1 ? 1 : 0;
  440.     used_axes[1] = axes.indexOf("-Y") != -1 ? -1 : axes.indexOf("Y") != -1 ? 1 : 0;
  441.     used_axes[2] = axes.indexOf("-Z") != -1 ? -1 : axes.indexOf("Z") != -1 ? 1 : 0;
  442.     m_cons.append_copy_rot_obj(obj, target, used_axes, use_offset, influence);
  444.     m_trans.update_transform(obj);
  445.     m_phy.sync_transform(obj);
  446. }
  448. /**
  449.  * Attach the object to the other object using a
  450.  * stiff translation/rotation constraint. The child object will move and rotate
  451.  * together with its parent, but will not scale. It will be still possible to
  452.  * scale it independently from the parent.
  453.  *
  454.  * Example: smoke emitter attached to the tractor pipe; exhaustion effects
  455.  * are achieved by scaling the emitter.
  456.  *
  457.  * @method module:constraints.append_stiff_trans_rot
  458.  * @param {Object3D} obj Constrained object
  459.  * @param {Object3D} target Target object
  460.  * @param {Vec3} [offset] Offset, in the parent's local space
  461.  * @param {Quat} [rotation_offset] Rotation offset, in
  462.  * the parent's local space
  463.  *
  464.  * @example var m_scene = require("scenes");
  465.  * var m_const = require("constraints");
  466.  *
  467.  * var my_sphere = m_scene.get_object_by_name("Icosphere");
  468.  * var my_cube = m_scene.get_object_by_name("cube");
  469.  *
  470.  * var my_offset_vector = new Float32Array([-2.0, 2.0, 2.0]);
  471.  * m_const.append_stiff_trans_rot(my_sphere, my_cube, my_offset_vector);
  472.  */
  473. exports.append_stiff_trans_rot = function(obj, target, offset, rotation_offset) {
  475.     if (!m_obj_util.is_dynamic(obj)) {
  476.         m_print.error("Wrong object: \"" + obj.name + "\" is not dynamic.");
  477.         return;
  478.     }
  479.     if (!m_cons.check_self_applying(obj, target)) {
  480.         m_print.error("Can not apply constraint. Object and target must be different.");
  481.         return;
  482.     }
  483.     if (!m_cons.check_compatibility(obj, target)) {
  484.         m_print.error("Constraint recursion is forbidden.");
  485.         return;
  486.     }
  487.     offset = offset || new Float32Array(3);
  488.     rotation_offset =
  489.             rotation_offset ? new Float32Array(rotation_offset) : [0, 0, 0, 1];
  490.     m_cons.append_stiff_trans_rot_obj(obj, target, offset, rotation_offset, 1.0);
  492.     m_trans.update_transform(obj);
  493.     m_phy.sync_transform(obj);
  494. }
  496. /**
  497.  * Make the object "looking" at the target object.
  498.  *
  499.  * Example: a spot light which is tracking the character; both objects can be
  500.  * moved via API or animated.
  501.  * <p>
  502.  * This method works in a similar way to the <b>Track To</b> constraint in Blender.
  503.  * </p>
  504.  * @method module:constraints.append_track
  505.  * @param {Object3D} obj Constrained object
  506.  * @param {(Object3D)} target Target object
  507.  * @param {string} [track_axis='Y'] Axis that points to the target object
  508.  * @param {string} [up_axis='Z'] Axis that points upward
  509.  * @param {boolean} [use_target_z=false] Target's Z axis, not World Z axis, will constraint the Up direction
  510.  * @param {number} [influence=1] Amount of influence constraint will have on the final solution
  511.  *
  512.  * @example var m_scene = require("scenes");
  513.  * var m_const = require("constraints");
  514.  *
  515.  * var my_cube = m_scene.get_object_by_name("cube");  
  516.  * var my_camera = m_scene.get_object_by_name("Camera");
  517.  *
  518.  * m_const.append_track(my_camera, my_cube, "-X", "Z");
  519.  */
  520. exports.append_track = function(obj, target, track_axis, up_axis, use_target_z, influence) {
  522.     if (!m_obj_util.is_dynamic(obj)) {
  523.         m_print.error("Wrong object: \"" + obj.name + "\" is not dynamic.");
  524.         return;
  525.     }
  526.     if (!m_cons.check_self_applying(obj, target)) {
  527.         m_print.error("Can not apply constraint. Object and target must be different.");
  528.         return;
  529.     }
  530.     if (!m_cons.check_compatibility(obj, target)) {
  531.         m_print.error("Constraint recursion is forbidden.");
  532.         return;
  533.     }
  534.     var track_axis_vec = m_util.AXIS_Y;
  535.     if (track_axis == "-Y")
  536.         track_axis_vec = m_util.AXIS_MY;
  537.     else if (track_axis == "Y")
  538.         track_axis_vec = m_util.AXIS_Y;
  539.     else if (track_axis == "-X")
  540.         track_axis_vec = m_util.AXIS_MX;
  541.     else if (track_axis == "X")
  542.         track_axis_vec = m_util.AXIS_X;
  543.     else if (track_axis == "-Z")
  544.         track_axis_vec = m_util.AXIS_MZ;
  545.     else if (track_axis == "Z")
  546.         track_axis_vec = m_util.AXIS_Z;
  548.     var up_axis_vec = m_util.AXIS_Z;
  549.     if (up_axis == "X")
  550.         up_axis_vec = m_util.AXIS_X;
  551.     else if (up_axis == "Y")
  552.         up_axis_vec = m_util.AXIS_Y;
  554.     if (Math.abs(m_vec3.dot(track_axis_vec, up_axis_vec)) == 1) {
  555.         m_print.error("Can not use parallel vectors for track and up axes.");
  556.         return;
  557.     }
  559.     influence = influence || 1;
  560.     use_target_z = use_target_z || false;
  561.     m_cons.append_track_obj(obj, target, track_axis_vec, up_axis_vec,
  562.                     use_target_z, influence);
  564.     m_trans.update_transform(obj);
  565.     m_phy.sync_transform(obj);
  566. }
  568. /**
  569.  * Attach the object to the other object using a follow constraint. The child
  570.  * object will track and follow its parent position.
  571.  * <p>
  572.  * This method works similarly to the <b>Limit Distance</b> constraint in Blender, but, unlike it, does not set a precise distance.
  573.  * </p>
  574.  * Example: a follow-style camera view for the character.
  575.  *
  576.  * @method module:constraints.append_follow
  577.  * @param {Object3D} obj Constrained object
  578.  * @param {Object3D} target Target object
  579.  * @param {number} dist_min Minimum distance
  580.  * @param {number} dist_max Maximum distance
  581.  *
  582.  * @example var m_scene = require("scenes");
  583.  * var m_const = require("constraints");
  584.  *
  585.  * var my_cube = m_scene.get_object_by_name("cube");
  586.  * var my_camera = m_scene.get_object_by_name("Camera");
  587.  *
  588.  * m_const.append_follow(my_camera, my_cube, 2.0, 4.0);
  589.  */
  590. exports.append_follow = function(obj, target, dist_min, dist_max) {
  592.     if (!m_obj_util.is_dynamic(obj)) {
  593.         m_print.error("Wrong object: \"" + obj.name + "\" is not dynamic.");
  594.         return;
  595.     }
  596.     if (!m_cons.check_self_applying(obj, target)) {
  597.         m_print.error("Can not apply constraint. Object and target must be different.");
  598.         return;
  599.     }
  600.     if (!m_cons.check_compatibility(obj, target)) {
  601.         m_print.error("Constraint recursion is forbidden.");
  602.         return;
  603.     }
  604.     m_cons.append_follow_obj(obj, target, dist_min, dist_max);
  606.     m_trans.update_transform(obj);
  607.     m_phy.sync_transform(obj);
  608. }
  610. /**
  611.  * Attach the object to the camera using a stiff viewport constraint, so
  612.  * the child object will preserve its orientation in the camera viewport.
  613.  * This constraint is used to create onscreen 2D/3D user interfaces.
  614.  * @method module:constraints.append_stiff_viewport
  615.  * @param {Object3D} obj Constrained object
  616.  * @param {Object3D} camobj Camera object
  617.  * @param {StiffViewportPositioning} [positioning] Positioning
  618.  *
  619.  * @example var m_scene = require("scenes");
  620.  * var m_const = require("constraints");
  621.  *
  622.  * var sphere_1 = m_scene.get_object_by_name("Icosphere");
  623.  * var my_camera = m_scene.get_object_by_name("Camera");
  624.  *
  625.  * m_const.append_stiff_viewport(sphere_1, my_camera, { 
  626.  *      left: 150,
  627.  *      top: 100,
  628.  *      distance: 1
  629.  *  });
  630.  */
  631. exports.append_stiff_viewport = function(obj, camobj, positioning) {
  632.     if (!m_obj_util.is_dynamic(obj)) {
  633.         m_print.error("Wrong object: \"" + obj.name + "\" is not dynamic.");
  634.         return;
  635.     }
  636.     if (!m_cons.check_self_applying(obj, camobj)) {
  637.         m_print.error("Can not apply constraint. Object and target must be different.");
  638.         return;
  639.     }
  640.     if (!m_cons.check_compatibility(obj, camobj)) {
  641.         m_print.error("Constraint recursion is forbidden.");
  642.         return;
  643.     }
  644.     positioning = positioning || {};
  645.     m_cons.append_stiff_viewport(obj, camobj, positioning);
  647.     m_trans.update_transform(obj);
  648.     m_phy.sync_transform(obj);
  649. }
  651. /**
  652.  * Remove the object's constraint (if any).
  653.  * @method module:constraints.remove
  654.  * @param {Object3D} obj Constrained object
  655.  * @param {boolean} [restore_transform=false] Restore default transform
  656.  *
  657.  * @example var m_scene = require("scenes");
  658.  * var m_const = require("constraints");
  659.  *
  660.  * var my_sphere = m_scene.get_object_by_name("Icosphere");
  661.  *
  662.  * m_const.remove(my_sphere);
  663.  */
  664. exports.remove = function(obj, restore_transform) {
  665.     restore_transform = restore_transform || false;
  666.     if (obj.constraint)
  667.         m_cons.remove(obj, restore_transform);
  668.     if (restore_transform)
  669.         m_trans.update_transform(obj);
  670. }
  672. }
  674. var constraints_factory = register("constraints", Constraints);
  676. export default constraints_factory;