Source: lib/gl-matrix/dist/esm/quat.js

  1. import * as glMatrix from "./common.js";
  2. import * as mat3 from "./mat3.js";
  3. import * as vec3 from "./vec3.js";
  4. import * as vec4 from "./vec4.js";
  5. /**
  6.  * Quaternion in the format XYZW
  7.  * @module quat
  8.  */
  10. /**
  11.  * Creates a new identity quat
  12.  *
  13.  * @returns {quat} a new quaternion
  14.  */
  16. export function create() {
  17.   var out = new glMatrix.ARRAY_TYPE(4);
  19.   if (glMatrix.ARRAY_TYPE != Float32Array) {
  20.     out[0] = 0;
  21.     out[1] = 0;
  22.     out[2] = 0;
  23.   }
  25.   out[3] = 1;
  26.   return out;
  27. }
  28. /**
  29.  * Set a quat to the identity quaternion
  30.  *
  31.  * @param {quat} out the receiving quaternion
  32.  * @returns {quat} out
  33.  */
  35. export function identity(out) {
  36.   out[0] = 0;
  37.   out[1] = 0;
  38.   out[2] = 0;
  39.   out[3] = 1;
  40.   return out;
  41. }
  42. /**
  43.  * Sets a quat from the given angle and rotation axis,
  44.  * then returns it.
  45.  *
  46.  * @param {quat} out the receiving quaternion
  47.  * @param {ReadonlyVec3} axis the axis around which to rotate
  48.  * @param {Number} rad the angle in radians
  49.  * @returns {quat} out
  50.  **/
  52. export function setAxisAngle(out, axis, rad) {
  53.   rad = rad * 0.5;
  54.   var s = Math.sin(rad);
  55.   out[0] = s * axis[0];
  56.   out[1] = s * axis[1];
  57.   out[2] = s * axis[2];
  58.   out[3] = Math.cos(rad);
  59.   return out;
  60. }
  61. /**
  62.  * Gets the rotation axis and angle for a given
  63.  *  quaternion. If a quaternion is created with
  64.  *  setAxisAngle, this method will return the same
  65.  *  values as providied in the original parameter list
  66.  *  OR functionally equivalent values.
  67.  * Example: The quaternion formed by axis [0, 0, 1] and
  68.  *  angle -90 is the same as the quaternion formed by
  69.  *  [0, 0, 1] and 270. This method favors the latter.
  70.  * @param  {vec3} out_axis  Vector receiving the axis of rotation
  71.  * @param  {ReadonlyQuat} q     Quaternion to be decomposed
  72.  * @return {Number}     Angle, in radians, of the rotation
  73.  */
  75. export function getAxisAngle(out_axis, q) {
  76.   var rad = Math.acos(q[3]) * 2.0;
  77.   var s = Math.sin(rad / 2.0);
  79.   if (s > glMatrix.EPSILON) {
  80.     out_axis[0] = q[0] / s;
  81.     out_axis[1] = q[1] / s;
  82.     out_axis[2] = q[2] / s;
  83.   } else {
  84.     // If s is zero, return any axis (no rotation - axis does not matter)
  85.     out_axis[0] = 1;
  86.     out_axis[1] = 0;
  87.     out_axis[2] = 0;
  88.   }
  90.   return rad;
  91. }
  92. /**
  93.  * Gets the angular distance between two unit quaternions
  94.  *
  95.  * @param  {ReadonlyQuat} a     Origin unit quaternion
  96.  * @param  {ReadonlyQuat} b     Destination unit quaternion
  97.  * @return {Number}     Angle, in radians, between the two quaternions
  98.  */
  100. export function getAngle(a, b) {
  101.   var dotproduct = dot(a, b);
  102.   return Math.acos(2 * dotproduct * dotproduct - 1);
  103. }
  104. /**
  105.  * Multiplies two quat's
  106.  *
  107.  * @param {quat} out the receiving quaternion
  108.  * @param {ReadonlyQuat} a the first operand
  109.  * @param {ReadonlyQuat} b the second operand
  110.  * @returns {quat} out
  111.  */
  113. export function multiply(out, a, b) {
  114.   var ax = a[0],
  115.       ay = a[1],
  116.       az = a[2],
  117.       aw = a[3];
  118.   var bx = b[0],
  119.       by = b[1],
  120.       bz = b[2],
  121.       bw = b[3];
  122.   out[0] = ax * bw + aw * bx + ay * bz - az * by;
  123.   out[1] = ay * bw + aw * by + az * bx - ax * bz;
  124.   out[2] = az * bw + aw * bz + ax * by - ay * bx;
  125.   out[3] = aw * bw - ax * bx - ay * by - az * bz;
  126.   return out;
  127. }
  128. /**
  129.  * Rotates a quaternion by the given angle about the X axis
  130.  *
  131.  * @param {quat} out quat receiving operation result
  132.  * @param {ReadonlyQuat} a quat to rotate
  133.  * @param {number} rad angle (in radians) to rotate
  134.  * @returns {quat} out
  135.  */
  137. export function rotateX(out, a, rad) {
  138.   rad *= 0.5;
  139.   var ax = a[0],
  140.       ay = a[1],
  141.       az = a[2],
  142.       aw = a[3];
  143.   var bx = Math.sin(rad),
  144.       bw = Math.cos(rad);
  145.   out[0] = ax * bw + aw * bx;
  146.   out[1] = ay * bw + az * bx;
  147.   out[2] = az * bw - ay * bx;
  148.   out[3] = aw * bw - ax * bx;
  149.   return out;
  150. }
  151. /**
  152.  * Rotates a quaternion by the given angle about the Y axis
  153.  *
  154.  * @param {quat} out quat receiving operation result
  155.  * @param {ReadonlyQuat} a quat to rotate
  156.  * @param {number} rad angle (in radians) to rotate
  157.  * @returns {quat} out
  158.  */
  160. export function rotateY(out, a, rad) {
  161.   rad *= 0.5;
  162.   var ax = a[0],
  163.       ay = a[1],
  164.       az = a[2],
  165.       aw = a[3];
  166.   var by = Math.sin(rad),
  167.       bw = Math.cos(rad);
  168.   out[0] = ax * bw - az * by;
  169.   out[1] = ay * bw + aw * by;
  170.   out[2] = az * bw + ax * by;
  171.   out[3] = aw * bw - ay * by;
  172.   return out;
  173. }
  174. /**
  175.  * Rotates a quaternion by the given angle about the Z axis
  176.  *
  177.  * @param {quat} out quat receiving operation result
  178.  * @param {ReadonlyQuat} a quat to rotate
  179.  * @param {number} rad angle (in radians) to rotate
  180.  * @returns {quat} out
  181.  */
  183. export function rotateZ(out, a, rad) {
  184.   rad *= 0.5;
  185.   var ax = a[0],
  186.       ay = a[1],
  187.       az = a[2],
  188.       aw = a[3];
  189.   var bz = Math.sin(rad),
  190.       bw = Math.cos(rad);
  191.   out[0] = ax * bw + ay * bz;
  192.   out[1] = ay * bw - ax * bz;
  193.   out[2] = az * bw + aw * bz;
  194.   out[3] = aw * bw - az * bz;
  195.   return out;
  196. }
  197. /**
  198.  * Calculates the W component of a quat from the X, Y, and Z components.
  199.  * Assumes that quaternion is 1 unit in length.
  200.  * Any existing W component will be ignored.
  201.  *
  202.  * @param {quat} out the receiving quaternion
  203.  * @param {ReadonlyQuat} a quat to calculate W component of
  204.  * @returns {quat} out
  205.  */
  207. export function calculateW(out, a) {
  208.   var x = a[0],
  209.       y = a[1],
  210.       z = a[2];
  211.   out[0] = x;
  212.   out[1] = y;
  213.   out[2] = z;
  214.   out[3] = Math.sqrt(Math.abs(1.0 - x * x - y * y - z * z));
  215.   return out;
  216. }
  217. /**
  218.  * Calculate the exponential of a unit quaternion.
  219.  *
  220.  * @param {quat} out the receiving quaternion
  221.  * @param {ReadonlyQuat} a quat to calculate the exponential of
  222.  * @returns {quat} out
  223.  */
  225. export function exp(out, a) {
  226.   var x = a[0],
  227.       y = a[1],
  228.       z = a[2],
  229.       w = a[3];
  230.   var r = Math.sqrt(x * x + y * y + z * z);
  231.   var et = Math.exp(w);
  232.   var s = r > 0 ? et * Math.sin(r) / r : 0;
  233.   out[0] = x * s;
  234.   out[1] = y * s;
  235.   out[2] = z * s;
  236.   out[3] = et * Math.cos(r);
  237.   return out;
  238. }
  239. /**
  240.  * Calculate the natural logarithm of a unit quaternion.
  241.  *
  242.  * @param {quat} out the receiving quaternion
  243.  * @param {ReadonlyQuat} a quat to calculate the exponential of
  244.  * @returns {quat} out
  245.  */
  247. export function ln(out, a) {
  248.   var x = a[0],
  249.       y = a[1],
  250.       z = a[2],
  251.       w = a[3];
  252.   var r = Math.sqrt(x * x + y * y + z * z);
  253.   var t = r > 0 ? Math.atan2(r, w) / r : 0;
  254.   out[0] = x * t;
  255.   out[1] = y * t;
  256.   out[2] = z * t;
  257.   out[3] = 0.5 * Math.log(x * x + y * y + z * z + w * w);
  258.   return out;
  259. }
  260. /**
  261.  * Calculate the scalar power of a unit quaternion.
  262.  *
  263.  * @param {quat} out the receiving quaternion
  264.  * @param {ReadonlyQuat} a quat to calculate the exponential of
  265.  * @param {Number} b amount to scale the quaternion by
  266.  * @returns {quat} out
  267.  */
  269. export function pow(out, a, b) {
  270.   ln(out, a);
  271.   scale(out, out, b);
  272.   exp(out, out);
  273.   return out;
  274. }
  275. /**
  276.  * Performs a spherical linear interpolation between two quat
  277.  *
  278.  * @param {quat} out the receiving quaternion
  279.  * @param {ReadonlyQuat} a the first operand
  280.  * @param {ReadonlyQuat} b the second operand
  281.  * @param {Number} t interpolation amount, in the range [0-1], between the two inputs
  282.  * @returns {quat} out
  283.  */
  285. export function slerp(out, a, b, t) {
  286.   // benchmarks:
  287.   //    http://jsperf.com/quaternion-slerp-implementations
  288.   var ax = a[0],
  289.       ay = a[1],
  290.       az = a[2],
  291.       aw = a[3];
  292.   var bx = b[0],
  293.       by = b[1],
  294.       bz = b[2],
  295.       bw = b[3];
  296.   var omega, cosom, sinom, scale0, scale1; // calc cosine
  298.   cosom = ax * bx + ay * by + az * bz + aw * bw; // adjust signs (if necessary)
  300.   if (cosom < 0.0) {
  301.     cosom = -cosom;
  302.     bx = -bx;
  303.     by = -by;
  304.     bz = -bz;
  305.     bw = -bw;
  306.   } // calculate coefficients
  309.   if (1.0 - cosom > glMatrix.EPSILON) {
  310.     // standard case (slerp)
  311.     omega = Math.acos(cosom);
  312.     sinom = Math.sin(omega);
  313.     scale0 = Math.sin((1.0 - t) * omega) / sinom;
  314.     scale1 = Math.sin(t * omega) / sinom;
  315.   } else {
  316.     // "from" and "to" quaternions are very close
  317.     //  ... so we can do a linear interpolation
  318.     scale0 = 1.0 - t;
  319.     scale1 = t;
  320.   } // calculate final values
  323.   out[0] = scale0 * ax + scale1 * bx;
  324.   out[1] = scale0 * ay + scale1 * by;
  325.   out[2] = scale0 * az + scale1 * bz;
  326.   out[3] = scale0 * aw + scale1 * bw;
  327.   return out;
  328. }
  329. /**
  330.  * Generates a random unit quaternion
  331.  *
  332.  * @param {quat} out the receiving quaternion
  333.  * @returns {quat} out
  334.  */
  336. export function random(out) {
  337.   // Implementation of http://planning.cs.uiuc.edu/node198.html
  338.   // TODO: Calling random 3 times is probably not the fastest solution
  339.   var u1 = glMatrix.RANDOM();
  340.   var u2 = glMatrix.RANDOM();
  341.   var u3 = glMatrix.RANDOM();
  342.   var sqrt1MinusU1 = Math.sqrt(1 - u1);
  343.   var sqrtU1 = Math.sqrt(u1);
  344.   out[0] = sqrt1MinusU1 * Math.sin(2.0 * Math.PI * u2);
  345.   out[1] = sqrt1MinusU1 * Math.cos(2.0 * Math.PI * u2);
  346.   out[2] = sqrtU1 * Math.sin(2.0 * Math.PI * u3);
  347.   out[3] = sqrtU1 * Math.cos(2.0 * Math.PI * u3);
  348.   return out;
  349. }
  350. /**
  351.  * Calculates the inverse of a quat
  352.  *
  353.  * @param {quat} out the receiving quaternion
  354.  * @param {ReadonlyQuat} a quat to calculate inverse of
  355.  * @returns {quat} out
  356.  */
  358. export function invert(out, a) {
  359.   var a0 = a[0],
  360.       a1 = a[1],
  361.       a2 = a[2],
  362.       a3 = a[3];
  363.   var dot = a0 * a0 + a1 * a1 + a2 * a2 + a3 * a3;
  364.   var invDot = dot ? 1.0 / dot : 0; // TODO: Would be faster to return [0,0,0,0] immediately if dot == 0
  366.   out[0] = -a0 * invDot;
  367.   out[1] = -a1 * invDot;
  368.   out[2] = -a2 * invDot;
  369.   out[3] = a3 * invDot;
  370.   return out;
  371. }
  372. /**
  373.  * Calculates the conjugate of a quat
  374.  * If the quaternion is normalized, this function is faster than quat.inverse and produces the same result.
  375.  *
  376.  * @param {quat} out the receiving quaternion
  377.  * @param {ReadonlyQuat} a quat to calculate conjugate of
  378.  * @returns {quat} out
  379.  */
  381. export function conjugate(out, a) {
  382.   out[0] = -a[0];
  383.   out[1] = -a[1];
  384.   out[2] = -a[2];
  385.   out[3] = a[3];
  386.   return out;
  387. }
  388. /**
  389.  * Creates a quaternion from the given 3x3 rotation matrix.
  390.  *
  391.  * NOTE: The resultant quaternion is not normalized, so you should be sure
  392.  * to renormalize the quaternion yourself where necessary.
  393.  *
  394.  * @param {quat} out the receiving quaternion
  395.  * @param {ReadonlyMat3} m rotation matrix
  396.  * @returns {quat} out
  397.  * @function
  398.  */
  400. export function fromMat3(out, m) {
  401.   // Algorithm in Ken Shoemake's article in 1987 SIGGRAPH course notes
  402.   // article "Quaternion Calculus and Fast Animation".
  403.   var fTrace = m[0] + m[4] + m[8];
  404.   var fRoot;
  406.   if (fTrace > 0.0) {
  407.     // |w| > 1/2, may as well choose w > 1/2
  408.     fRoot = Math.sqrt(fTrace + 1.0); // 2w
  410.     out[3] = 0.5 * fRoot;
  411.     fRoot = 0.5 / fRoot; // 1/(4w)
  413.     out[0] = (m[5] - m[7]) * fRoot;
  414.     out[1] = (m[6] - m[2]) * fRoot;
  415.     out[2] = (m[1] - m[3]) * fRoot;
  416.   } else {
  417.     // |w| <= 1/2
  418.     var i = 0;
  419.     if (m[4] > m[0]) i = 1;
  420.     if (m[8] > m[i * 3 + i]) i = 2;
  421.     var j = (i + 1) % 3;
  422.     var k = (i + 2) % 3;
  423.     fRoot = Math.sqrt(m[i * 3 + i] - m[j * 3 + j] - m[k * 3 + k] + 1.0);
  424.     out[i] = 0.5 * fRoot;
  425.     fRoot = 0.5 / fRoot;
  426.     out[3] = (m[j * 3 + k] - m[k * 3 + j]) * fRoot;
  427.     out[j] = (m[j * 3 + i] + m[i * 3 + j]) * fRoot;
  428.     out[k] = (m[k * 3 + i] + m[i * 3 + k]) * fRoot;
  429.   }
  431.   return out;
  432. }
  433. /**
  434.  * Creates a quaternion from the given euler angle x, y, z using the provided intrinsic order for the conversion.
  435.  *
  436.  * @param {quat} out the receiving quaternion
  437.  * @param {x} x Angle to rotate around X axis in degrees.
  438.  * @param {y} y Angle to rotate around Y axis in degrees.
  439.  * @param {z} z Angle to rotate around Z axis in degrees.
  440.  * @param {'zyx'|'xyz'|'yxz'|'yzx'|'zxy'|'zyx'} order Intrinsic order for conversion, default is zyx.
  441.  * @returns {quat} out
  442.  * @function
  443.  */
  445. export function fromEuler(out, x, y, z) {
  446.   var order = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : glMatrix.ANGLE_ORDER;
  447.   var halfToRad = Math.PI / 360;
  448.   x *= halfToRad;
  449.   z *= halfToRad;
  450.   y *= halfToRad;
  451.   var sx = Math.sin(x);
  452.   var cx = Math.cos(x);
  453.   var sy = Math.sin(y);
  454.   var cy = Math.cos(y);
  455.   var sz = Math.sin(z);
  456.   var cz = Math.cos(z);
  458.   switch (order) {
  459.     case "xyz":
  460.       out[0] = sx * cy * cz + cx * sy * sz;
  461.       out[1] = cx * sy * cz - sx * cy * sz;
  462.       out[2] = cx * cy * sz + sx * sy * cz;
  463.       out[3] = cx * cy * cz - sx * sy * sz;
  464.       break;
  466.     case "xzy":
  467.       out[0] = sx * cy * cz - cx * sy * sz;
  468.       out[1] = cx * sy * cz - sx * cy * sz;
  469.       out[2] = cx * cy * sz + sx * sy * cz;
  470.       out[3] = cx * cy * cz + sx * sy * sz;
  471.       break;
  473.     case "yxz":
  474.       out[0] = sx * cy * cz + cx * sy * sz;
  475.       out[1] = cx * sy * cz - sx * cy * sz;
  476.       out[2] = cx * cy * sz - sx * sy * cz;
  477.       out[3] = cx * cy * cz + sx * sy * sz;
  478.       break;
  480.     case "yzx":
  481.       out[0] = sx * cy * cz + cx * sy * sz;
  482.       out[1] = cx * sy * cz + sx * cy * sz;
  483.       out[2] = cx * cy * sz - sx * sy * cz;
  484.       out[3] = cx * cy * cz - sx * sy * sz;
  485.       break;
  487.     case "zxy":
  488.       out[0] = sx * cy * cz - cx * sy * sz;
  489.       out[1] = cx * sy * cz + sx * cy * sz;
  490.       out[2] = cx * cy * sz + sx * sy * cz;
  491.       out[3] = cx * cy * cz - sx * sy * sz;
  492.       break;
  494.     case "zyx":
  495.       out[0] = sx * cy * cz - cx * sy * sz;
  496.       out[1] = cx * sy * cz + sx * cy * sz;
  497.       out[2] = cx * cy * sz - sx * sy * cz;
  498.       out[3] = cx * cy * cz + sx * sy * sz;
  499.       break;
  501.     default:
  502.       throw new Error('Unknown angle order ' + order);
  503.   }
  505.   return out;
  506. }
  507. /**
  508.  * Returns a string representation of a quaternion
  509.  *
  510.  * @param {ReadonlyQuat} a vector to represent as a string
  511.  * @returns {String} string representation of the vector
  512.  */
  514. export function str(a) {
  515.   return "quat(" + a[0] + ", " + a[1] + ", " + a[2] + ", " + a[3] + ")";
  516. }
  517. /**
  518.  * Creates a new quat initialized with values from an existing quaternion
  519.  *
  520.  * @param {ReadonlyQuat} a quaternion to clone
  521.  * @returns {quat} a new quaternion
  522.  * @function
  523.  */
  525. export var clone = vec4.clone;
  526. /**
  527.  * Creates a new quat initialized with the given values
  528.  *
  529.  * @param {Number} x X component
  530.  * @param {Number} y Y component
  531.  * @param {Number} z Z component
  532.  * @param {Number} w W component
  533.  * @returns {quat} a new quaternion
  534.  * @function
  535.  */
  537. export var fromValues = vec4.fromValues;
  538. /**
  539.  * Copy the values from one quat to another
  540.  *
  541.  * @param {quat} out the receiving quaternion
  542.  * @param {ReadonlyQuat} a the source quaternion
  543.  * @returns {quat} out
  544.  * @function
  545.  */
  547. export var copy = vec4.copy;
  548. /**
  549.  * Set the components of a quat to the given values
  550.  *
  551.  * @param {quat} out the receiving quaternion
  552.  * @param {Number} x X component
  553.  * @param {Number} y Y component
  554.  * @param {Number} z Z component
  555.  * @param {Number} w W component
  556.  * @returns {quat} out
  557.  * @function
  558.  */
  560. export var set = vec4.set;
  561. /**
  562.  * Adds two quat's
  563.  *
  564.  * @param {quat} out the receiving quaternion
  565.  * @param {ReadonlyQuat} a the first operand
  566.  * @param {ReadonlyQuat} b the second operand
  567.  * @returns {quat} out
  568.  * @function
  569.  */
  571. export var add = vec4.add;
  572. /**
  573.  * Alias for {@link quat.multiply}
  574.  * @function
  575.  */
  577. export var mul = multiply;
  578. /**
  579.  * Scales a quat by a scalar number
  580.  *
  581.  * @param {quat} out the receiving vector
  582.  * @param {ReadonlyQuat} a the vector to scale
  583.  * @param {Number} b amount to scale the vector by
  584.  * @returns {quat} out
  585.  * @function
  586.  */
  588. export var scale = vec4.scale;
  589. /**
  590.  * Calculates the dot product of two quat's
  591.  *
  592.  * @param {ReadonlyQuat} a the first operand
  593.  * @param {ReadonlyQuat} b the second operand
  594.  * @returns {Number} dot product of a and b
  595.  * @function
  596.  */
  598. export var dot = vec4.dot;
  599. /**
  600.  * Performs a linear interpolation between two quat's
  601.  *
  602.  * @param {quat} out the receiving quaternion
  603.  * @param {ReadonlyQuat} a the first operand
  604.  * @param {ReadonlyQuat} b the second operand
  605.  * @param {Number} t interpolation amount, in the range [0-1], between the two inputs
  606.  * @returns {quat} out
  607.  * @function
  608.  */
  610. export var lerp = vec4.lerp;
  611. /**
  612.  * Calculates the length of a quat
  613.  *
  614.  * @param {ReadonlyQuat} a vector to calculate length of
  615.  * @returns {Number} length of a
  616.  */
  618. export var length = vec4.length;
  619. /**
  620.  * Alias for {@link quat.length}
  621.  * @function
  622.  */
  624. export var len = length;
  625. /**
  626.  * Calculates the squared length of a quat
  627.  *
  628.  * @param {ReadonlyQuat} a vector to calculate squared length of
  629.  * @returns {Number} squared length of a
  630.  * @function
  631.  */
  633. export var squaredLength = vec4.squaredLength;
  634. /**
  635.  * Alias for {@link quat.squaredLength}
  636.  * @function
  637.  */
  639. export var sqrLen = squaredLength;
  640. /**
  641.  * Normalize a quat
  642.  *
  643.  * @param {quat} out the receiving quaternion
  644.  * @param {ReadonlyQuat} a quaternion to normalize
  645.  * @returns {quat} out
  646.  * @function
  647.  */
  649. export var normalize = vec4.normalize;
  650. /**
  651.  * Returns whether or not the quaternions have exactly the same elements in the same position (when compared with ===)
  652.  *
  653.  * @param {ReadonlyQuat} a The first quaternion.
  654.  * @param {ReadonlyQuat} b The second quaternion.
  655.  * @returns {Boolean} True if the vectors are equal, false otherwise.
  656.  */
  658. export var exactEquals = vec4.exactEquals;
  659. /**
  660.  * Returns whether or not the quaternions point approximately to the same direction.
  661.  *
  662.  * Both quaternions are assumed to be unit length.
  663.  *
  664.  * @param {ReadonlyQuat} a The first unit quaternion.
  665.  * @param {ReadonlyQuat} b The second unit quaternion.
  666.  * @returns {Boolean} True if the quaternions are equal, false otherwise.
  667.  */
  669. export function equals(a, b) {
  670.   return Math.abs(vec4.dot(a, b)) >= 1 - glMatrix.EPSILON;
  671. }
  672. /**
  673.  * Sets a quaternion to represent the shortest rotation from one
  674.  * vector to another.
  675.  *
  676.  * Both vectors are assumed to be unit length.
  677.  *
  678.  * @param {quat} out the receiving quaternion.
  679.  * @param {ReadonlyVec3} a the initial vector
  680.  * @param {ReadonlyVec3} b the destination vector
  681.  * @returns {quat} out
  682.  */
  684. export var rotationTo = function () {
  685.   var tmpvec3 = vec3.create();
  686.   var xUnitVec3 = vec3.fromValues(1, 0, 0);
  687.   var yUnitVec3 = vec3.fromValues(0, 1, 0);
  688.   return function (out, a, b) {
  689.     var dot = vec3.dot(a, b);
  691.     if (dot < -0.999999) {
  692.       vec3.cross(tmpvec3, xUnitVec3, a);
  693.       if (vec3.len(tmpvec3) < 0.000001) vec3.cross(tmpvec3, yUnitVec3, a);
  694.       vec3.normalize(tmpvec3, tmpvec3);
  695.       setAxisAngle(out, tmpvec3, Math.PI);
  696.       return out;
  697.     } else if (dot > 0.999999) {
  698.       out[0] = 0;
  699.       out[1] = 0;
  700.       out[2] = 0;
  701.       out[3] = 1;
  702.       return out;
  703.     } else {
  704.       vec3.cross(tmpvec3, a, b);
  705.       out[0] = tmpvec3[0];
  706.       out[1] = tmpvec3[1];
  707.       out[2] = tmpvec3[2];
  708.       out[3] = 1 + dot;
  709.       return normalize(out, out);
  710.     }
  711.   };
  712. }();
  713. /**
  714.  * Performs a spherical linear interpolation with two control points
  715.  *
  716.  * @param {quat} out the receiving quaternion
  717.  * @param {ReadonlyQuat} a the first operand
  718.  * @param {ReadonlyQuat} b the second operand
  719.  * @param {ReadonlyQuat} c the third operand
  720.  * @param {ReadonlyQuat} d the fourth operand
  721.  * @param {Number} t interpolation amount, in the range [0-1], between the two inputs
  722.  * @returns {quat} out
  723.  */
  725. export var sqlerp = function () {
  726.   var temp1 = create();
  727.   var temp2 = create();
  728.   return function (out, a, b, c, d, t) {
  729.     slerp(temp1, a, d, t);
  730.     slerp(temp2, b, c, t);
  731.     slerp(out, temp1, temp2, 2 * t * (1 - t));
  732.     return out;
  733.   };
  734. }();
  735. /**
  736.  * Sets the specified quaternion with values corresponding to the given
  737.  * axes. Each axis is a vec3 and is expected to be unit length and
  738.  * perpendicular to all other specified axes.
  739.  *
  740.  * @param {ReadonlyVec3} view  the vector representing the viewing direction
  741.  * @param {ReadonlyVec3} right the vector representing the local "right" direction
  742.  * @param {ReadonlyVec3} up    the vector representing the local "up" direction
  743.  * @returns {quat} out
  744.  */
  746. export var setAxes = function () {
  747.   var matr = mat3.create();
  748.   return function (out, view, right, up) {
  749.     matr[0] = right[0];
  750.     matr[3] = right[1];
  751.     matr[6] = right[2];
  752.     matr[1] = up[0];
  753.     matr[4] = up[1];
  754.     matr[7] = up[2];
  755.     matr[2] = -view[0];
  756.     matr[5] = -view[1];
  757.     matr[8] = -view[2];
  758.     return normalize(out, fromMat3(out, matr));
  759.   };
  760. }();