Source: node_modules/gl-matrix/esm/mat4.js

  1. import * as glMatrix from "./common.js";
  2. /**
  3.  * 4x4 Matrix<br>Format: column-major, when typed out it looks like row-major<br>The matrices are being post multiplied.
  4.  * @module mat4
  5.  */
  7. /**
  8.  * Creates a new identity mat4
  9.  *
  10.  * @returns {mat4} a new 4x4 matrix
  11.  */
  13. export function create() {
  14.   var out = new glMatrix.ARRAY_TYPE(16);
  16.   if (glMatrix.ARRAY_TYPE != Float32Array) {
  17.     out[1] = 0;
  18.     out[2] = 0;
  19.     out[3] = 0;
  20.     out[4] = 0;
  21.     out[6] = 0;
  22.     out[7] = 0;
  23.     out[8] = 0;
  24.     out[9] = 0;
  25.     out[11] = 0;
  26.     out[12] = 0;
  27.     out[13] = 0;
  28.     out[14] = 0;
  29.   }
  31.   out[0] = 1;
  32.   out[5] = 1;
  33.   out[10] = 1;
  34.   out[15] = 1;
  35.   return out;
  36. }
  37. /**
  38.  * Creates a new mat4 initialized with values from an existing matrix
  39.  *
  40.  * @param {ReadonlyMat4} a matrix to clone
  41.  * @returns {mat4} a new 4x4 matrix
  42.  */
  44. export function clone(a) {
  45.   var out = new glMatrix.ARRAY_TYPE(16);
  46.   out[0] = a[0];
  47.   out[1] = a[1];
  48.   out[2] = a[2];
  49.   out[3] = a[3];
  50.   out[4] = a[4];
  51.   out[5] = a[5];
  52.   out[6] = a[6];
  53.   out[7] = a[7];
  54.   out[8] = a[8];
  55.   out[9] = a[9];
  56.   out[10] = a[10];
  57.   out[11] = a[11];
  58.   out[12] = a[12];
  59.   out[13] = a[13];
  60.   out[14] = a[14];
  61.   out[15] = a[15];
  62.   return out;
  63. }
  64. /**
  65.  * Copy the values from one mat4 to another
  66.  *
  67.  * @param {mat4} out the receiving matrix
  68.  * @param {ReadonlyMat4} a the source matrix
  69.  * @returns {mat4} out
  70.  */
  72. export function copy(out, a) {
  73.   out[0] = a[0];
  74.   out[1] = a[1];
  75.   out[2] = a[2];
  76.   out[3] = a[3];
  77.   out[4] = a[4];
  78.   out[5] = a[5];
  79.   out[6] = a[6];
  80.   out[7] = a[7];
  81.   out[8] = a[8];
  82.   out[9] = a[9];
  83.   out[10] = a[10];
  84.   out[11] = a[11];
  85.   out[12] = a[12];
  86.   out[13] = a[13];
  87.   out[14] = a[14];
  88.   out[15] = a[15];
  89.   return out;
  90. }
  91. /**
  92.  * Create a new mat4 with the given values
  93.  *
  94.  * @param {Number} m00 Component in column 0, row 0 position (index 0)
  95.  * @param {Number} m01 Component in column 0, row 1 position (index 1)
  96.  * @param {Number} m02 Component in column 0, row 2 position (index 2)
  97.  * @param {Number} m03 Component in column 0, row 3 position (index 3)
  98.  * @param {Number} m10 Component in column 1, row 0 position (index 4)
  99.  * @param {Number} m11 Component in column 1, row 1 position (index 5)
  100.  * @param {Number} m12 Component in column 1, row 2 position (index 6)
  101.  * @param {Number} m13 Component in column 1, row 3 position (index 7)
  102.  * @param {Number} m20 Component in column 2, row 0 position (index 8)
  103.  * @param {Number} m21 Component in column 2, row 1 position (index 9)
  104.  * @param {Number} m22 Component in column 2, row 2 position (index 10)
  105.  * @param {Number} m23 Component in column 2, row 3 position (index 11)
  106.  * @param {Number} m30 Component in column 3, row 0 position (index 12)
  107.  * @param {Number} m31 Component in column 3, row 1 position (index 13)
  108.  * @param {Number} m32 Component in column 3, row 2 position (index 14)
  109.  * @param {Number} m33 Component in column 3, row 3 position (index 15)
  110.  * @returns {mat4} A new mat4
  111.  */
  113. export function fromValues(m00, m01, m02, m03, m10, m11, m12, m13, m20, m21, m22, m23, m30, m31, m32, m33) {
  114.   var out = new glMatrix.ARRAY_TYPE(16);
  115.   out[0] = m00;
  116.   out[1] = m01;
  117.   out[2] = m02;
  118.   out[3] = m03;
  119.   out[4] = m10;
  120.   out[5] = m11;
  121.   out[6] = m12;
  122.   out[7] = m13;
  123.   out[8] = m20;
  124.   out[9] = m21;
  125.   out[10] = m22;
  126.   out[11] = m23;
  127.   out[12] = m30;
  128.   out[13] = m31;
  129.   out[14] = m32;
  130.   out[15] = m33;
  131.   return out;
  132. }
  133. /**
  134.  * Set the components of a mat4 to the given values
  135.  *
  136.  * @param {mat4} out the receiving matrix
  137.  * @param {Number} m00 Component in column 0, row 0 position (index 0)
  138.  * @param {Number} m01 Component in column 0, row 1 position (index 1)
  139.  * @param {Number} m02 Component in column 0, row 2 position (index 2)
  140.  * @param {Number} m03 Component in column 0, row 3 position (index 3)
  141.  * @param {Number} m10 Component in column 1, row 0 position (index 4)
  142.  * @param {Number} m11 Component in column 1, row 1 position (index 5)
  143.  * @param {Number} m12 Component in column 1, row 2 position (index 6)
  144.  * @param {Number} m13 Component in column 1, row 3 position (index 7)
  145.  * @param {Number} m20 Component in column 2, row 0 position (index 8)
  146.  * @param {Number} m21 Component in column 2, row 1 position (index 9)
  147.  * @param {Number} m22 Component in column 2, row 2 position (index 10)
  148.  * @param {Number} m23 Component in column 2, row 3 position (index 11)
  149.  * @param {Number} m30 Component in column 3, row 0 position (index 12)
  150.  * @param {Number} m31 Component in column 3, row 1 position (index 13)
  151.  * @param {Number} m32 Component in column 3, row 2 position (index 14)
  152.  * @param {Number} m33 Component in column 3, row 3 position (index 15)
  153.  * @returns {mat4} out
  154.  */
  156. export function set(out, m00, m01, m02, m03, m10, m11, m12, m13, m20, m21, m22, m23, m30, m31, m32, m33) {
  157.   out[0] = m00;
  158.   out[1] = m01;
  159.   out[2] = m02;
  160.   out[3] = m03;
  161.   out[4] = m10;
  162.   out[5] = m11;
  163.   out[6] = m12;
  164.   out[7] = m13;
  165.   out[8] = m20;
  166.   out[9] = m21;
  167.   out[10] = m22;
  168.   out[11] = m23;
  169.   out[12] = m30;
  170.   out[13] = m31;
  171.   out[14] = m32;
  172.   out[15] = m33;
  173.   return out;
  174. }
  175. /**
  176.  * Set a mat4 to the identity matrix
  177.  *
  178.  * @param {mat4} out the receiving matrix
  179.  * @returns {mat4} out
  180.  */
  182. export function identity(out) {
  183.   out[0] = 1;
  184.   out[1] = 0;
  185.   out[2] = 0;
  186.   out[3] = 0;
  187.   out[4] = 0;
  188.   out[5] = 1;
  189.   out[6] = 0;
  190.   out[7] = 0;
  191.   out[8] = 0;
  192.   out[9] = 0;
  193.   out[10] = 1;
  194.   out[11] = 0;
  195.   out[12] = 0;
  196.   out[13] = 0;
  197.   out[14] = 0;
  198.   out[15] = 1;
  199.   return out;
  200. }
  201. /**
  202.  * Transpose the values of a mat4
  203.  *
  204.  * @param {mat4} out the receiving matrix
  205.  * @param {ReadonlyMat4} a the source matrix
  206.  * @returns {mat4} out
  207.  */
  209. export function transpose(out, a) {
  210.   // If we are transposing ourselves we can skip a few steps but have to cache some values
  211.   if (out === a) {
  212.     var a01 = a[1],
  213.         a02 = a[2],
  214.         a03 = a[3];
  215.     var a12 = a[6],
  216.         a13 = a[7];
  217.     var a23 = a[11];
  218.     out[1] = a[4];
  219.     out[2] = a[8];
  220.     out[3] = a[12];
  221.     out[4] = a01;
  222.     out[6] = a[9];
  223.     out[7] = a[13];
  224.     out[8] = a02;
  225.     out[9] = a12;
  226.     out[11] = a[14];
  227.     out[12] = a03;
  228.     out[13] = a13;
  229.     out[14] = a23;
  230.   } else {
  231.     out[0] = a[0];
  232.     out[1] = a[4];
  233.     out[2] = a[8];
  234.     out[3] = a[12];
  235.     out[4] = a[1];
  236.     out[5] = a[5];
  237.     out[6] = a[9];
  238.     out[7] = a[13];
  239.     out[8] = a[2];
  240.     out[9] = a[6];
  241.     out[10] = a[10];
  242.     out[11] = a[14];
  243.     out[12] = a[3];
  244.     out[13] = a[7];
  245.     out[14] = a[11];
  246.     out[15] = a[15];
  247.   }
  249.   return out;
  250. }
  251. /**
  252.  * Inverts a mat4
  253.  *
  254.  * @param {mat4} out the receiving matrix
  255.  * @param {ReadonlyMat4} a the source matrix
  256.  * @returns {mat4} out
  257.  */
  259. export function invert(out, a) {
  260.   var a00 = a[0],
  261.       a01 = a[1],
  262.       a02 = a[2],
  263.       a03 = a[3];
  264.   var a10 = a[4],
  265.       a11 = a[5],
  266.       a12 = a[6],
  267.       a13 = a[7];
  268.   var a20 = a[8],
  269.       a21 = a[9],
  270.       a22 = a[10],
  271.       a23 = a[11];
  272.   var a30 = a[12],
  273.       a31 = a[13],
  274.       a32 = a[14],
  275.       a33 = a[15];
  276.   var b00 = a00 * a11 - a01 * a10;
  277.   var b01 = a00 * a12 - a02 * a10;
  278.   var b02 = a00 * a13 - a03 * a10;
  279.   var b03 = a01 * a12 - a02 * a11;
  280.   var b04 = a01 * a13 - a03 * a11;
  281.   var b05 = a02 * a13 - a03 * a12;
  282.   var b06 = a20 * a31 - a21 * a30;
  283.   var b07 = a20 * a32 - a22 * a30;
  284.   var b08 = a20 * a33 - a23 * a30;
  285.   var b09 = a21 * a32 - a22 * a31;
  286.   var b10 = a21 * a33 - a23 * a31;
  287.   var b11 = a22 * a33 - a23 * a32; // Calculate the determinant
  289.   var det = b00 * b11 - b01 * b10 + b02 * b09 + b03 * b08 - b04 * b07 + b05 * b06;
  291.   if (!det) {
  292.     return null;
  293.   }
  295.   det = 1.0 / det;
  296.   out[0] = (a11 * b11 - a12 * b10 + a13 * b09) * det;
  297.   out[1] = (a02 * b10 - a01 * b11 - a03 * b09) * det;
  298.   out[2] = (a31 * b05 - a32 * b04 + a33 * b03) * det;
  299.   out[3] = (a22 * b04 - a21 * b05 - a23 * b03) * det;
  300.   out[4] = (a12 * b08 - a10 * b11 - a13 * b07) * det;
  301.   out[5] = (a00 * b11 - a02 * b08 + a03 * b07) * det;
  302.   out[6] = (a32 * b02 - a30 * b05 - a33 * b01) * det;
  303.   out[7] = (a20 * b05 - a22 * b02 + a23 * b01) * det;
  304.   out[8] = (a10 * b10 - a11 * b08 + a13 * b06) * det;
  305.   out[9] = (a01 * b08 - a00 * b10 - a03 * b06) * det;
  306.   out[10] = (a30 * b04 - a31 * b02 + a33 * b00) * det;
  307.   out[11] = (a21 * b02 - a20 * b04 - a23 * b00) * det;
  308.   out[12] = (a11 * b07 - a10 * b09 - a12 * b06) * det;
  309.   out[13] = (a00 * b09 - a01 * b07 + a02 * b06) * det;
  310.   out[14] = (a31 * b01 - a30 * b03 - a32 * b00) * det;
  311.   out[15] = (a20 * b03 - a21 * b01 + a22 * b00) * det;
  312.   return out;
  313. }
  314. /**
  315.  * Calculates the adjugate of a mat4
  316.  *
  317.  * @param {mat4} out the receiving matrix
  318.  * @param {ReadonlyMat4} a the source matrix
  319.  * @returns {mat4} out
  320.  */
  322. export function adjoint(out, a) {
  323.   var a00 = a[0],
  324.       a01 = a[1],
  325.       a02 = a[2],
  326.       a03 = a[3];
  327.   var a10 = a[4],
  328.       a11 = a[5],
  329.       a12 = a[6],
  330.       a13 = a[7];
  331.   var a20 = a[8],
  332.       a21 = a[9],
  333.       a22 = a[10],
  334.       a23 = a[11];
  335.   var a30 = a[12],
  336.       a31 = a[13],
  337.       a32 = a[14],
  338.       a33 = a[15];
  339.   out[0] = a11 * (a22 * a33 - a23 * a32) - a21 * (a12 * a33 - a13 * a32) + a31 * (a12 * a23 - a13 * a22);
  340.   out[1] = -(a01 * (a22 * a33 - a23 * a32) - a21 * (a02 * a33 - a03 * a32) + a31 * (a02 * a23 - a03 * a22));
  341.   out[2] = a01 * (a12 * a33 - a13 * a32) - a11 * (a02 * a33 - a03 * a32) + a31 * (a02 * a13 - a03 * a12);
  342.   out[3] = -(a01 * (a12 * a23 - a13 * a22) - a11 * (a02 * a23 - a03 * a22) + a21 * (a02 * a13 - a03 * a12));
  343.   out[4] = -(a10 * (a22 * a33 - a23 * a32) - a20 * (a12 * a33 - a13 * a32) + a30 * (a12 * a23 - a13 * a22));
  344.   out[5] = a00 * (a22 * a33 - a23 * a32) - a20 * (a02 * a33 - a03 * a32) + a30 * (a02 * a23 - a03 * a22);
  345.   out[6] = -(a00 * (a12 * a33 - a13 * a32) - a10 * (a02 * a33 - a03 * a32) + a30 * (a02 * a13 - a03 * a12));
  346.   out[7] = a00 * (a12 * a23 - a13 * a22) - a10 * (a02 * a23 - a03 * a22) + a20 * (a02 * a13 - a03 * a12);
  347.   out[8] = a10 * (a21 * a33 - a23 * a31) - a20 * (a11 * a33 - a13 * a31) + a30 * (a11 * a23 - a13 * a21);
  348.   out[9] = -(a00 * (a21 * a33 - a23 * a31) - a20 * (a01 * a33 - a03 * a31) + a30 * (a01 * a23 - a03 * a21));
  349.   out[10] = a00 * (a11 * a33 - a13 * a31) - a10 * (a01 * a33 - a03 * a31) + a30 * (a01 * a13 - a03 * a11);
  350.   out[11] = -(a00 * (a11 * a23 - a13 * a21) - a10 * (a01 * a23 - a03 * a21) + a20 * (a01 * a13 - a03 * a11));
  351.   out[12] = -(a10 * (a21 * a32 - a22 * a31) - a20 * (a11 * a32 - a12 * a31) + a30 * (a11 * a22 - a12 * a21));
  352.   out[13] = a00 * (a21 * a32 - a22 * a31) - a20 * (a01 * a32 - a02 * a31) + a30 * (a01 * a22 - a02 * a21);
  353.   out[14] = -(a00 * (a11 * a32 - a12 * a31) - a10 * (a01 * a32 - a02 * a31) + a30 * (a01 * a12 - a02 * a11));
  354.   out[15] = a00 * (a11 * a22 - a12 * a21) - a10 * (a01 * a22 - a02 * a21) + a20 * (a01 * a12 - a02 * a11);
  355.   return out;
  356. }
  357. /**
  358.  * Calculates the determinant of a mat4
  359.  *
  360.  * @param {ReadonlyMat4} a the source matrix
  361.  * @returns {Number} determinant of a
  362.  */
  364. export function determinant(a) {
  365.   var a00 = a[0],
  366.       a01 = a[1],
  367.       a02 = a[2],
  368.       a03 = a[3];
  369.   var a10 = a[4],
  370.       a11 = a[5],
  371.       a12 = a[6],
  372.       a13 = a[7];
  373.   var a20 = a[8],
  374.       a21 = a[9],
  375.       a22 = a[10],
  376.       a23 = a[11];
  377.   var a30 = a[12],
  378.       a31 = a[13],
  379.       a32 = a[14],
  380.       a33 = a[15];
  381.   var b00 = a00 * a11 - a01 * a10;
  382.   var b01 = a00 * a12 - a02 * a10;
  383.   var b02 = a00 * a13 - a03 * a10;
  384.   var b03 = a01 * a12 - a02 * a11;
  385.   var b04 = a01 * a13 - a03 * a11;
  386.   var b05 = a02 * a13 - a03 * a12;
  387.   var b06 = a20 * a31 - a21 * a30;
  388.   var b07 = a20 * a32 - a22 * a30;
  389.   var b08 = a20 * a33 - a23 * a30;
  390.   var b09 = a21 * a32 - a22 * a31;
  391.   var b10 = a21 * a33 - a23 * a31;
  392.   var b11 = a22 * a33 - a23 * a32; // Calculate the determinant
  394.   return b00 * b11 - b01 * b10 + b02 * b09 + b03 * b08 - b04 * b07 + b05 * b06;
  395. }
  396. /**
  397.  * Multiplies two mat4s
  398.  *
  399.  * @param {mat4} out the receiving matrix
  400.  * @param {ReadonlyMat4} a the first operand
  401.  * @param {ReadonlyMat4} b the second operand
  402.  * @returns {mat4} out
  403.  */
  405. export function multiply(out, a, b) {
  406.   var a00 = a[0],
  407.       a01 = a[1],
  408.       a02 = a[2],
  409.       a03 = a[3];
  410.   var a10 = a[4],
  411.       a11 = a[5],
  412.       a12 = a[6],
  413.       a13 = a[7];
  414.   var a20 = a[8],
  415.       a21 = a[9],
  416.       a22 = a[10],
  417.       a23 = a[11];
  418.   var a30 = a[12],
  419.       a31 = a[13],
  420.       a32 = a[14],
  421.       a33 = a[15]; // Cache only the current line of the second matrix
  423.   var b0 = b[0],
  424.       b1 = b[1],
  425.       b2 = b[2],
  426.       b3 = b[3];
  427.   out[0] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30;
  428.   out[1] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31;
  429.   out[2] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32;
  430.   out[3] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33;
  431.   b0 = b[4];
  432.   b1 = b[5];
  433.   b2 = b[6];
  434.   b3 = b[7];
  435.   out[4] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30;
  436.   out[5] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31;
  437.   out[6] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32;
  438.   out[7] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33;
  439.   b0 = b[8];
  440.   b1 = b[9];
  441.   b2 = b[10];
  442.   b3 = b[11];
  443.   out[8] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30;
  444.   out[9] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31;
  445.   out[10] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32;
  446.   out[11] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33;
  447.   b0 = b[12];
  448.   b1 = b[13];
  449.   b2 = b[14];
  450.   b3 = b[15];
  451.   out[12] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30;
  452.   out[13] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31;
  453.   out[14] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32;
  454.   out[15] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33;
  455.   return out;
  456. }
  457. /**
  458.  * Translate a mat4 by the given vector
  459.  *
  460.  * @param {mat4} out the receiving matrix
  461.  * @param {ReadonlyMat4} a the matrix to translate
  462.  * @param {ReadonlyVec3} v vector to translate by
  463.  * @returns {mat4} out
  464.  */
  466. export function translate(out, a, v) {
  467.   var x = v[0],
  468.       y = v[1],
  469.       z = v[2];
  470.   var a00, a01, a02, a03;
  471.   var a10, a11, a12, a13;
  472.   var a20, a21, a22, a23;
  474.   if (a === out) {
  475.     out[12] = a[0] * x + a[4] * y + a[8] * z + a[12];
  476.     out[13] = a[1] * x + a[5] * y + a[9] * z + a[13];
  477.     out[14] = a[2] * x + a[6] * y + a[10] * z + a[14];
  478.     out[15] = a[3] * x + a[7] * y + a[11] * z + a[15];
  479.   } else {
  480.     a00 = a[0];
  481.     a01 = a[1];
  482.     a02 = a[2];
  483.     a03 = a[3];
  484.     a10 = a[4];
  485.     a11 = a[5];
  486.     a12 = a[6];
  487.     a13 = a[7];
  488.     a20 = a[8];
  489.     a21 = a[9];
  490.     a22 = a[10];
  491.     a23 = a[11];
  492.     out[0] = a00;
  493.     out[1] = a01;
  494.     out[2] = a02;
  495.     out[3] = a03;
  496.     out[4] = a10;
  497.     out[5] = a11;
  498.     out[6] = a12;
  499.     out[7] = a13;
  500.     out[8] = a20;
  501.     out[9] = a21;
  502.     out[10] = a22;
  503.     out[11] = a23;
  504.     out[12] = a00 * x + a10 * y + a20 * z + a[12];
  505.     out[13] = a01 * x + a11 * y + a21 * z + a[13];
  506.     out[14] = a02 * x + a12 * y + a22 * z + a[14];
  507.     out[15] = a03 * x + a13 * y + a23 * z + a[15];
  508.   }
  510.   return out;
  511. }
  512. /**
  513.  * Scales the mat4 by the dimensions in the given vec3 not using vectorization
  514.  *
  515.  * @param {mat4} out the receiving matrix
  516.  * @param {ReadonlyMat4} a the matrix to scale
  517.  * @param {ReadonlyVec3} v the vec3 to scale the matrix by
  518.  * @returns {mat4} out
  519.  **/
  521. export function scale(out, a, v) {
  522.   var x = v[0],
  523.       y = v[1],
  524.       z = v[2];
  525.   out[0] = a[0] * x;
  526.   out[1] = a[1] * x;
  527.   out[2] = a[2] * x;
  528.   out[3] = a[3] * x;
  529.   out[4] = a[4] * y;
  530.   out[5] = a[5] * y;
  531.   out[6] = a[6] * y;
  532.   out[7] = a[7] * y;
  533.   out[8] = a[8] * z;
  534.   out[9] = a[9] * z;
  535.   out[10] = a[10] * z;
  536.   out[11] = a[11] * z;
  537.   out[12] = a[12];
  538.   out[13] = a[13];
  539.   out[14] = a[14];
  540.   out[15] = a[15];
  541.   return out;
  542. }
  543. /**
  544.  * Rotates a mat4 by the given angle around the given axis
  545.  *
  546.  * @param {mat4} out the receiving matrix
  547.  * @param {ReadonlyMat4} a the matrix to rotate
  548.  * @param {Number} rad the angle to rotate the matrix by
  549.  * @param {ReadonlyVec3} axis the axis to rotate around
  550.  * @returns {mat4} out
  551.  */
  553. export function rotate(out, a, rad, axis) {
  554.   var x = axis[0],
  555.       y = axis[1],
  556.       z = axis[2];
  557.   var len = Math.hypot(x, y, z);
  558.   var s, c, t;
  559.   var a00, a01, a02, a03;
  560.   var a10, a11, a12, a13;
  561.   var a20, a21, a22, a23;
  562.   var b00, b01, b02;
  563.   var b10, b11, b12;
  564.   var b20, b21, b22;
  566.   if (len < glMatrix.EPSILON) {
  567.     return null;
  568.   }
  570.   len = 1 / len;
  571.   x *= len;
  572.   y *= len;
  573.   z *= len;
  574.   s = Math.sin(rad);
  575.   c = Math.cos(rad);
  576.   t = 1 - c;
  577.   a00 = a[0];
  578.   a01 = a[1];
  579.   a02 = a[2];
  580.   a03 = a[3];
  581.   a10 = a[4];
  582.   a11 = a[5];
  583.   a12 = a[6];
  584.   a13 = a[7];
  585.   a20 = a[8];
  586.   a21 = a[9];
  587.   a22 = a[10];
  588.   a23 = a[11]; // Construct the elements of the rotation matrix
  590.   b00 = x * x * t + c;
  591.   b01 = y * x * t + z * s;
  592.   b02 = z * x * t - y * s;
  593.   b10 = x * y * t - z * s;
  594.   b11 = y * y * t + c;
  595.   b12 = z * y * t + x * s;
  596.   b20 = x * z * t + y * s;
  597.   b21 = y * z * t - x * s;
  598.   b22 = z * z * t + c; // Perform rotation-specific matrix multiplication
  600.   out[0] = a00 * b00 + a10 * b01 + a20 * b02;
  601.   out[1] = a01 * b00 + a11 * b01 + a21 * b02;
  602.   out[2] = a02 * b00 + a12 * b01 + a22 * b02;
  603.   out[3] = a03 * b00 + a13 * b01 + a23 * b02;
  604.   out[4] = a00 * b10 + a10 * b11 + a20 * b12;
  605.   out[5] = a01 * b10 + a11 * b11 + a21 * b12;
  606.   out[6] = a02 * b10 + a12 * b11 + a22 * b12;
  607.   out[7] = a03 * b10 + a13 * b11 + a23 * b12;
  608.   out[8] = a00 * b20 + a10 * b21 + a20 * b22;
  609.   out[9] = a01 * b20 + a11 * b21 + a21 * b22;
  610.   out[10] = a02 * b20 + a12 * b21 + a22 * b22;
  611.   out[11] = a03 * b20 + a13 * b21 + a23 * b22;
  613.   if (a !== out) {
  614.     // If the source and destination differ, copy the unchanged last row
  615.     out[12] = a[12];
  616.     out[13] = a[13];
  617.     out[14] = a[14];
  618.     out[15] = a[15];
  619.   }
  621.   return out;
  622. }
  623. /**
  624.  * Rotates a matrix by the given angle around the X axis
  625.  *
  626.  * @param {mat4} out the receiving matrix
  627.  * @param {ReadonlyMat4} a the matrix to rotate
  628.  * @param {Number} rad the angle to rotate the matrix by
  629.  * @returns {mat4} out
  630.  */
  632. export function rotateX(out, a, rad) {
  633.   var s = Math.sin(rad);
  634.   var c = Math.cos(rad);
  635.   var a10 = a[4];
  636.   var a11 = a[5];
  637.   var a12 = a[6];
  638.   var a13 = a[7];
  639.   var a20 = a[8];
  640.   var a21 = a[9];
  641.   var a22 = a[10];
  642.   var a23 = a[11];
  644.   if (a !== out) {
  645.     // If the source and destination differ, copy the unchanged rows
  646.     out[0] = a[0];
  647.     out[1] = a[1];
  648.     out[2] = a[2];
  649.     out[3] = a[3];
  650.     out[12] = a[12];
  651.     out[13] = a[13];
  652.     out[14] = a[14];
  653.     out[15] = a[15];
  654.   } // Perform axis-specific matrix multiplication
  657.   out[4] = a10 * c + a20 * s;
  658.   out[5] = a11 * c + a21 * s;
  659.   out[6] = a12 * c + a22 * s;
  660.   out[7] = a13 * c + a23 * s;
  661.   out[8] = a20 * c - a10 * s;
  662.   out[9] = a21 * c - a11 * s;
  663.   out[10] = a22 * c - a12 * s;
  664.   out[11] = a23 * c - a13 * s;
  665.   return out;
  666. }
  667. /**
  668.  * Rotates a matrix by the given angle around the Y axis
  669.  *
  670.  * @param {mat4} out the receiving matrix
  671.  * @param {ReadonlyMat4} a the matrix to rotate
  672.  * @param {Number} rad the angle to rotate the matrix by
  673.  * @returns {mat4} out
  674.  */
  676. export function rotateY(out, a, rad) {
  677.   var s = Math.sin(rad);
  678.   var c = Math.cos(rad);
  679.   var a00 = a[0];
  680.   var a01 = a[1];
  681.   var a02 = a[2];
  682.   var a03 = a[3];
  683.   var a20 = a[8];
  684.   var a21 = a[9];
  685.   var a22 = a[10];
  686.   var a23 = a[11];
  688.   if (a !== out) {
  689.     // If the source and destination differ, copy the unchanged rows
  690.     out[4] = a[4];
  691.     out[5] = a[5];
  692.     out[6] = a[6];
  693.     out[7] = a[7];
  694.     out[12] = a[12];
  695.     out[13] = a[13];
  696.     out[14] = a[14];
  697.     out[15] = a[15];
  698.   } // Perform axis-specific matrix multiplication
  701.   out[0] = a00 * c - a20 * s;
  702.   out[1] = a01 * c - a21 * s;
  703.   out[2] = a02 * c - a22 * s;
  704.   out[3] = a03 * c - a23 * s;
  705.   out[8] = a00 * s + a20 * c;
  706.   out[9] = a01 * s + a21 * c;
  707.   out[10] = a02 * s + a22 * c;
  708.   out[11] = a03 * s + a23 * c;
  709.   return out;
  710. }
  711. /**
  712.  * Rotates a matrix by the given angle around the Z axis
  713.  *
  714.  * @param {mat4} out the receiving matrix
  715.  * @param {ReadonlyMat4} a the matrix to rotate
  716.  * @param {Number} rad the angle to rotate the matrix by
  717.  * @returns {mat4} out
  718.  */
  720. export function rotateZ(out, a, rad) {
  721.   var s = Math.sin(rad);
  722.   var c = Math.cos(rad);
  723.   var a00 = a[0];
  724.   var a01 = a[1];
  725.   var a02 = a[2];
  726.   var a03 = a[3];
  727.   var a10 = a[4];
  728.   var a11 = a[5];
  729.   var a12 = a[6];
  730.   var a13 = a[7];
  732.   if (a !== out) {
  733.     // If the source and destination differ, copy the unchanged last row
  734.     out[8] = a[8];
  735.     out[9] = a[9];
  736.     out[10] = a[10];
  737.     out[11] = a[11];
  738.     out[12] = a[12];
  739.     out[13] = a[13];
  740.     out[14] = a[14];
  741.     out[15] = a[15];
  742.   } // Perform axis-specific matrix multiplication
  745.   out[0] = a00 * c + a10 * s;
  746.   out[1] = a01 * c + a11 * s;
  747.   out[2] = a02 * c + a12 * s;
  748.   out[3] = a03 * c + a13 * s;
  749.   out[4] = a10 * c - a00 * s;
  750.   out[5] = a11 * c - a01 * s;
  751.   out[6] = a12 * c - a02 * s;
  752.   out[7] = a13 * c - a03 * s;
  753.   return out;
  754. }
  755. /**
  756.  * Creates a matrix from a vector translation
  757.  * This is equivalent to (but much faster than):
  758.  *
  759.  *     mat4.identity(dest);
  760.  *     mat4.translate(dest, dest, vec);
  761.  *
  762.  * @param {mat4} out mat4 receiving operation result
  763.  * @param {ReadonlyVec3} v Translation vector
  764.  * @returns {mat4} out
  765.  */
  767. export function fromTranslation(out, v) {
  768.   out[0] = 1;
  769.   out[1] = 0;
  770.   out[2] = 0;
  771.   out[3] = 0;
  772.   out[4] = 0;
  773.   out[5] = 1;
  774.   out[6] = 0;
  775.   out[7] = 0;
  776.   out[8] = 0;
  777.   out[9] = 0;
  778.   out[10] = 1;
  779.   out[11] = 0;
  780.   out[12] = v[0];
  781.   out[13] = v[1];
  782.   out[14] = v[2];
  783.   out[15] = 1;
  784.   return out;
  785. }
  786. /**
  787.  * Creates a matrix from a vector scaling
  788.  * This is equivalent to (but much faster than):
  789.  *
  790.  *     mat4.identity(dest);
  791.  *     mat4.scale(dest, dest, vec);
  792.  *
  793.  * @param {mat4} out mat4 receiving operation result
  794.  * @param {ReadonlyVec3} v Scaling vector
  795.  * @returns {mat4} out
  796.  */
  798. export function fromScaling(out, v) {
  799.   out[0] = v[0];
  800.   out[1] = 0;
  801.   out[2] = 0;
  802.   out[3] = 0;
  803.   out[4] = 0;
  804.   out[5] = v[1];
  805.   out[6] = 0;
  806.   out[7] = 0;
  807.   out[8] = 0;
  808.   out[9] = 0;
  809.   out[10] = v[2];
  810.   out[11] = 0;
  811.   out[12] = 0;
  812.   out[13] = 0;
  813.   out[14] = 0;
  814.   out[15] = 1;
  815.   return out;
  816. }
  817. /**
  818.  * Creates a matrix from a given angle around a given axis
  819.  * This is equivalent to (but much faster than):
  820.  *
  821.  *     mat4.identity(dest);
  822.  *     mat4.rotate(dest, dest, rad, axis);
  823.  *
  824.  * @param {mat4} out mat4 receiving operation result
  825.  * @param {Number} rad the angle to rotate the matrix by
  826.  * @param {ReadonlyVec3} axis the axis to rotate around
  827.  * @returns {mat4} out
  828.  */
  830. export function fromRotation(out, rad, axis) {
  831.   var x = axis[0],
  832.       y = axis[1],
  833.       z = axis[2];
  834.   var len = Math.hypot(x, y, z);
  835.   var s, c, t;
  837.   if (len < glMatrix.EPSILON) {
  838.     return null;
  839.   }
  841.   len = 1 / len;
  842.   x *= len;
  843.   y *= len;
  844.   z *= len;
  845.   s = Math.sin(rad);
  846.   c = Math.cos(rad);
  847.   t = 1 - c; // Perform rotation-specific matrix multiplication
  849.   out[0] = x * x * t + c;
  850.   out[1] = y * x * t + z * s;
  851.   out[2] = z * x * t - y * s;
  852.   out[3] = 0;
  853.   out[4] = x * y * t - z * s;
  854.   out[5] = y * y * t + c;
  855.   out[6] = z * y * t + x * s;
  856.   out[7] = 0;
  857.   out[8] = x * z * t + y * s;
  858.   out[9] = y * z * t - x * s;
  859.   out[10] = z * z * t + c;
  860.   out[11] = 0;
  861.   out[12] = 0;
  862.   out[13] = 0;
  863.   out[14] = 0;
  864.   out[15] = 1;
  865.   return out;
  866. }
  867. /**
  868.  * Creates a matrix from the given angle around the X axis
  869.  * This is equivalent to (but much faster than):
  870.  *
  871.  *     mat4.identity(dest);
  872.  *     mat4.rotateX(dest, dest, rad);
  873.  *
  874.  * @param {mat4} out mat4 receiving operation result
  875.  * @param {Number} rad the angle to rotate the matrix by
  876.  * @returns {mat4} out
  877.  */
  879. export function fromXRotation(out, rad) {
  880.   var s = Math.sin(rad);
  881.   var c = Math.cos(rad); // Perform axis-specific matrix multiplication
  883.   out[0] = 1;
  884.   out[1] = 0;
  885.   out[2] = 0;
  886.   out[3] = 0;
  887.   out[4] = 0;
  888.   out[5] = c;
  889.   out[6] = s;
  890.   out[7] = 0;
  891.   out[8] = 0;
  892.   out[9] = -s;
  893.   out[10] = c;
  894.   out[11] = 0;
  895.   out[12] = 0;
  896.   out[13] = 0;
  897.   out[14] = 0;
  898.   out[15] = 1;
  899.   return out;
  900. }
  901. /**
  902.  * Creates a matrix from the given angle around the Y axis
  903.  * This is equivalent to (but much faster than):
  904.  *
  905.  *     mat4.identity(dest);
  906.  *     mat4.rotateY(dest, dest, rad);
  907.  *
  908.  * @param {mat4} out mat4 receiving operation result
  909.  * @param {Number} rad the angle to rotate the matrix by
  910.  * @returns {mat4} out
  911.  */
  913. export function fromYRotation(out, rad) {
  914.   var s = Math.sin(rad);
  915.   var c = Math.cos(rad); // Perform axis-specific matrix multiplication
  917.   out[0] = c;
  918.   out[1] = 0;
  919.   out[2] = -s;
  920.   out[3] = 0;
  921.   out[4] = 0;
  922.   out[5] = 1;
  923.   out[6] = 0;
  924.   out[7] = 0;
  925.   out[8] = s;
  926.   out[9] = 0;
  927.   out[10] = c;
  928.   out[11] = 0;
  929.   out[12] = 0;
  930.   out[13] = 0;
  931.   out[14] = 0;
  932.   out[15] = 1;
  933.   return out;
  934. }
  935. /**
  936.  * Creates a matrix from the given angle around the Z axis
  937.  * This is equivalent to (but much faster than):
  938.  *
  939.  *     mat4.identity(dest);
  940.  *     mat4.rotateZ(dest, dest, rad);
  941.  *
  942.  * @param {mat4} out mat4 receiving operation result
  943.  * @param {Number} rad the angle to rotate the matrix by
  944.  * @returns {mat4} out
  945.  */
  947. export function fromZRotation(out, rad) {
  948.   var s = Math.sin(rad);
  949.   var c = Math.cos(rad); // Perform axis-specific matrix multiplication
  951.   out[0] = c;
  952.   out[1] = s;
  953.   out[2] = 0;
  954.   out[3] = 0;
  955.   out[4] = -s;
  956.   out[5] = c;
  957.   out[6] = 0;
  958.   out[7] = 0;
  959.   out[8] = 0;
  960.   out[9] = 0;
  961.   out[10] = 1;
  962.   out[11] = 0;
  963.   out[12] = 0;
  964.   out[13] = 0;
  965.   out[14] = 0;
  966.   out[15] = 1;
  967.   return out;
  968. }
  969. /**
  970.  * Creates a matrix from a quaternion rotation and vector translation
  971.  * This is equivalent to (but much faster than):
  972.  *
  973.  *     mat4.identity(dest);
  974.  *     mat4.translate(dest, vec);
  975.  *     let quatMat = mat4.create();
  976.  *     quat4.toMat4(quat, quatMat);
  977.  *     mat4.multiply(dest, quatMat);
  978.  *
  979.  * @param {mat4} out mat4 receiving operation result
  980.  * @param {quat4} q Rotation quaternion
  981.  * @param {ReadonlyVec3} v Translation vector
  982.  * @returns {mat4} out
  983.  */
  985. export function fromRotationTranslation(out, q, v) {
  986.   // Quaternion math
  987.   var x = q[0],
  988.       y = q[1],
  989.       z = q[2],
  990.       w = q[3];
  991.   var x2 = x + x;
  992.   var y2 = y + y;
  993.   var z2 = z + z;
  994.   var xx = x * x2;
  995.   var xy = x * y2;
  996.   var xz = x * z2;
  997.   var yy = y * y2;
  998.   var yz = y * z2;
  999.   var zz = z * z2;
  1000.   var wx = w * x2;
  1001.   var wy = w * y2;
  1002.   var wz = w * z2;
  1003.   out[0] = 1 - (yy + zz);
  1004.   out[1] = xy + wz;
  1005.   out[2] = xz - wy;
  1006.   out[3] = 0;
  1007.   out[4] = xy - wz;
  1008.   out[5] = 1 - (xx + zz);
  1009.   out[6] = yz + wx;
  1010.   out[7] = 0;
  1011.   out[8] = xz + wy;
  1012.   out[9] = yz - wx;
  1013.   out[10] = 1 - (xx + yy);
  1014.   out[11] = 0;
  1015.   out[12] = v[0];
  1016.   out[13] = v[1];
  1017.   out[14] = v[2];
  1018.   out[15] = 1;
  1019.   return out;
  1020. }
  1021. /**
  1022.  * Creates a new mat4 from a dual quat.
  1023.  *
  1024.  * @param {mat4} out Matrix
  1025.  * @param {ReadonlyQuat2} a Dual Quaternion
  1026.  * @returns {mat4} mat4 receiving operation result
  1027.  */
  1029. export function fromQuat2(out, a) {
  1030.   var translation = new glMatrix.ARRAY_TYPE(3);
  1031.   var bx = -a[0],
  1032.       by = -a[1],
  1033.       bz = -a[2],
  1034.       bw = a[3],
  1035.       ax = a[4],
  1036.       ay = a[5],
  1037.       az = a[6],
  1038.       aw = a[7];
  1039.   var magnitude = bx * bx + by * by + bz * bz + bw * bw; //Only scale if it makes sense
  1041.   if (magnitude > 0) {
  1042.     translation[0] = (ax * bw + aw * bx + ay * bz - az * by) * 2 / magnitude;
  1043.     translation[1] = (ay * bw + aw * by + az * bx - ax * bz) * 2 / magnitude;
  1044.     translation[2] = (az * bw + aw * bz + ax * by - ay * bx) * 2 / magnitude;
  1045.   } else {
  1046.     translation[0] = (ax * bw + aw * bx + ay * bz - az * by) * 2;
  1047.     translation[1] = (ay * bw + aw * by + az * bx - ax * bz) * 2;
  1048.     translation[2] = (az * bw + aw * bz + ax * by - ay * bx) * 2;
  1049.   }
  1051.   fromRotationTranslation(out, a, translation);
  1052.   return out;
  1053. }
  1054. /**
  1055.  * Returns the translation vector component of a transformation
  1056.  *  matrix. If a matrix is built with fromRotationTranslation,
  1057.  *  the returned vector will be the same as the translation vector
  1058.  *  originally supplied.
  1059.  * @param  {vec3} out Vector to receive translation component
  1060.  * @param  {ReadonlyMat4} mat Matrix to be decomposed (input)
  1061.  * @return {vec3} out
  1062.  */
  1064. export function getTranslation(out, mat) {
  1065.   out[0] = mat[12];
  1066.   out[1] = mat[13];
  1067.   out[2] = mat[14];
  1068.   return out;
  1069. }
  1070. /**
  1071.  * Returns the scaling factor component of a transformation
  1072.  *  matrix. If a matrix is built with fromRotationTranslationScale
  1073.  *  with a normalized Quaternion paramter, the returned vector will be
  1074.  *  the same as the scaling vector
  1075.  *  originally supplied.
  1076.  * @param  {vec3} out Vector to receive scaling factor component
  1077.  * @param  {ReadonlyMat4} mat Matrix to be decomposed (input)
  1078.  * @return {vec3} out
  1079.  */
  1081. export function getScaling(out, mat) {
  1082.   var m11 = mat[0];
  1083.   var m12 = mat[1];
  1084.   var m13 = mat[2];
  1085.   var m21 = mat[4];
  1086.   var m22 = mat[5];
  1087.   var m23 = mat[6];
  1088.   var m31 = mat[8];
  1089.   var m32 = mat[9];
  1090.   var m33 = mat[10];
  1091.   out[0] = Math.hypot(m11, m12, m13);
  1092.   out[1] = Math.hypot(m21, m22, m23);
  1093.   out[2] = Math.hypot(m31, m32, m33);
  1094.   return out;
  1095. }
  1096. /**
  1097.  * Returns a quaternion representing the rotational component
  1098.  *  of a transformation matrix. If a matrix is built with
  1099.  *  fromRotationTranslation, the returned quaternion will be the
  1100.  *  same as the quaternion originally supplied.
  1101.  * @param {quat} out Quaternion to receive the rotation component
  1102.  * @param {ReadonlyMat4} mat Matrix to be decomposed (input)
  1103.  * @return {quat} out
  1104.  */
  1106. export function getRotation(out, mat) {
  1107.   var scaling = new glMatrix.ARRAY_TYPE(3);
  1108.   getScaling(scaling, mat);
  1109.   var is1 = 1 / scaling[0];
  1110.   var is2 = 1 / scaling[1];
  1111.   var is3 = 1 / scaling[2];
  1112.   var sm11 = mat[0] * is1;
  1113.   var sm12 = mat[1] * is2;
  1114.   var sm13 = mat[2] * is3;
  1115.   var sm21 = mat[4] * is1;
  1116.   var sm22 = mat[5] * is2;
  1117.   var sm23 = mat[6] * is3;
  1118.   var sm31 = mat[8] * is1;
  1119.   var sm32 = mat[9] * is2;
  1120.   var sm33 = mat[10] * is3;
  1121.   var trace = sm11 + sm22 + sm33;
  1122.   var S = 0;
  1124.   if (trace > 0) {
  1125.     S = Math.sqrt(trace + 1.0) * 2;
  1126.     out[3] = 0.25 * S;
  1127.     out[0] = (sm23 - sm32) / S;
  1128.     out[1] = (sm31 - sm13) / S;
  1129.     out[2] = (sm12 - sm21) / S;
  1130.   } else if (sm11 > sm22 && sm11 > sm33) {
  1131.     S = Math.sqrt(1.0 + sm11 - sm22 - sm33) * 2;
  1132.     out[3] = (sm23 - sm32) / S;
  1133.     out[0] = 0.25 * S;
  1134.     out[1] = (sm12 + sm21) / S;
  1135.     out[2] = (sm31 + sm13) / S;
  1136.   } else if (sm22 > sm33) {
  1137.     S = Math.sqrt(1.0 + sm22 - sm11 - sm33) * 2;
  1138.     out[3] = (sm31 - sm13) / S;
  1139.     out[0] = (sm12 + sm21) / S;
  1140.     out[1] = 0.25 * S;
  1141.     out[2] = (sm23 + sm32) / S;
  1142.   } else {
  1143.     S = Math.sqrt(1.0 + sm33 - sm11 - sm22) * 2;
  1144.     out[3] = (sm12 - sm21) / S;
  1145.     out[0] = (sm31 + sm13) / S;
  1146.     out[1] = (sm23 + sm32) / S;
  1147.     out[2] = 0.25 * S;
  1148.   }
  1150.   return out;
  1151. }
  1152. /**
  1153.  * Creates a matrix from a quaternion rotation, vector translation and vector scale
  1154.  * This is equivalent to (but much faster than):
  1155.  *
  1156.  *     mat4.identity(dest);
  1157.  *     mat4.translate(dest, vec);
  1158.  *     let quatMat = mat4.create();
  1159.  *     quat4.toMat4(quat, quatMat);
  1160.  *     mat4.multiply(dest, quatMat);
  1161.  *     mat4.scale(dest, scale)
  1162.  *
  1163.  * @param {mat4} out mat4 receiving operation result
  1164.  * @param {quat4} q Rotation quaternion
  1165.  * @param {ReadonlyVec3} v Translation vector
  1166.  * @param {ReadonlyVec3} s Scaling vector
  1167.  * @returns {mat4} out
  1168.  */
  1170. export function fromRotationTranslationScale(out, q, v, s) {
  1171.   // Quaternion math
  1172.   var x = q[0],
  1173.       y = q[1],
  1174.       z = q[2],
  1175.       w = q[3];
  1176.   var x2 = x + x;
  1177.   var y2 = y + y;
  1178.   var z2 = z + z;
  1179.   var xx = x * x2;
  1180.   var xy = x * y2;
  1181.   var xz = x * z2;
  1182.   var yy = y * y2;
  1183.   var yz = y * z2;
  1184.   var zz = z * z2;
  1185.   var wx = w * x2;
  1186.   var wy = w * y2;
  1187.   var wz = w * z2;
  1188.   var sx = s[0];
  1189.   var sy = s[1];
  1190.   var sz = s[2];
  1191.   out[0] = (1 - (yy + zz)) * sx;
  1192.   out[1] = (xy + wz) * sx;
  1193.   out[2] = (xz - wy) * sx;
  1194.   out[3] = 0;
  1195.   out[4] = (xy - wz) * sy;
  1196.   out[5] = (1 - (xx + zz)) * sy;
  1197.   out[6] = (yz + wx) * sy;
  1198.   out[7] = 0;
  1199.   out[8] = (xz + wy) * sz;
  1200.   out[9] = (yz - wx) * sz;
  1201.   out[10] = (1 - (xx + yy)) * sz;
  1202.   out[11] = 0;
  1203.   out[12] = v[0];
  1204.   out[13] = v[1];
  1205.   out[14] = v[2];
  1206.   out[15] = 1;
  1207.   return out;
  1208. }
  1209. /**
  1210.  * Creates a matrix from a quaternion rotation, vector translation and vector scale, rotating and scaling around the given origin
  1211.  * This is equivalent to (but much faster than):
  1212.  *
  1213.  *     mat4.identity(dest);
  1214.  *     mat4.translate(dest, vec);
  1215.  *     mat4.translate(dest, origin);
  1216.  *     let quatMat = mat4.create();
  1217.  *     quat4.toMat4(quat, quatMat);
  1218.  *     mat4.multiply(dest, quatMat);
  1219.  *     mat4.scale(dest, scale)
  1220.  *     mat4.translate(dest, negativeOrigin);
  1221.  *
  1222.  * @param {mat4} out mat4 receiving operation result
  1223.  * @param {quat4} q Rotation quaternion
  1224.  * @param {ReadonlyVec3} v Translation vector
  1225.  * @param {ReadonlyVec3} s Scaling vector
  1226.  * @param {ReadonlyVec3} o The origin vector around which to scale and rotate
  1227.  * @returns {mat4} out
  1228.  */
  1230. export function fromRotationTranslationScaleOrigin(out, q, v, s, o) {
  1231.   // Quaternion math
  1232.   var x = q[0],
  1233.       y = q[1],
  1234.       z = q[2],
  1235.       w = q[3];
  1236.   var x2 = x + x;
  1237.   var y2 = y + y;
  1238.   var z2 = z + z;
  1239.   var xx = x * x2;
  1240.   var xy = x * y2;
  1241.   var xz = x * z2;
  1242.   var yy = y * y2;
  1243.   var yz = y * z2;
  1244.   var zz = z * z2;
  1245.   var wx = w * x2;
  1246.   var wy = w * y2;
  1247.   var wz = w * z2;
  1248.   var sx = s[0];
  1249.   var sy = s[1];
  1250.   var sz = s[2];
  1251.   var ox = o[0];
  1252.   var oy = o[1];
  1253.   var oz = o[2];
  1254.   var out0 = (1 - (yy + zz)) * sx;
  1255.   var out1 = (xy + wz) * sx;
  1256.   var out2 = (xz - wy) * sx;
  1257.   var out4 = (xy - wz) * sy;
  1258.   var out5 = (1 - (xx + zz)) * sy;
  1259.   var out6 = (yz + wx) * sy;
  1260.   var out8 = (xz + wy) * sz;
  1261.   var out9 = (yz - wx) * sz;
  1262.   var out10 = (1 - (xx + yy)) * sz;
  1263.   out[0] = out0;
  1264.   out[1] = out1;
  1265.   out[2] = out2;
  1266.   out[3] = 0;
  1267.   out[4] = out4;
  1268.   out[5] = out5;
  1269.   out[6] = out6;
  1270.   out[7] = 0;
  1271.   out[8] = out8;
  1272.   out[9] = out9;
  1273.   out[10] = out10;
  1274.   out[11] = 0;
  1275.   out[12] = v[0] + ox - (out0 * ox + out4 * oy + out8 * oz);
  1276.   out[13] = v[1] + oy - (out1 * ox + out5 * oy + out9 * oz);
  1277.   out[14] = v[2] + oz - (out2 * ox + out6 * oy + out10 * oz);
  1278.   out[15] = 1;
  1279.   return out;
  1280. }
  1281. /**
  1282.  * Calculates a 4x4 matrix from the given quaternion
  1283.  *
  1284.  * @param {mat4} out mat4 receiving operation result
  1285.  * @param {ReadonlyQuat} q Quaternion to create matrix from
  1286.  *
  1287.  * @returns {mat4} out
  1288.  */
  1290. export function fromQuat(out, q) {
  1291.   var x = q[0],
  1292.       y = q[1],
  1293.       z = q[2],
  1294.       w = q[3];
  1295.   var x2 = x + x;
  1296.   var y2 = y + y;
  1297.   var z2 = z + z;
  1298.   var xx = x * x2;
  1299.   var yx = y * x2;
  1300.   var yy = y * y2;
  1301.   var zx = z * x2;
  1302.   var zy = z * y2;
  1303.   var zz = z * z2;
  1304.   var wx = w * x2;
  1305.   var wy = w * y2;
  1306.   var wz = w * z2;
  1307.   out[0] = 1 - yy - zz;
  1308.   out[1] = yx + wz;
  1309.   out[2] = zx - wy;
  1310.   out[3] = 0;
  1311.   out[4] = yx - wz;
  1312.   out[5] = 1 - xx - zz;
  1313.   out[6] = zy + wx;
  1314.   out[7] = 0;
  1315.   out[8] = zx + wy;
  1316.   out[9] = zy - wx;
  1317.   out[10] = 1 - xx - yy;
  1318.   out[11] = 0;
  1319.   out[12] = 0;
  1320.   out[13] = 0;
  1321.   out[14] = 0;
  1322.   out[15] = 1;
  1323.   return out;
  1324. }
  1325. /**
  1326.  * Generates a frustum matrix with the given bounds
  1327.  *
  1328.  * @param {mat4} out mat4 frustum matrix will be written into
  1329.  * @param {Number} left Left bound of the frustum
  1330.  * @param {Number} right Right bound of the frustum
  1331.  * @param {Number} bottom Bottom bound of the frustum
  1332.  * @param {Number} top Top bound of the frustum
  1333.  * @param {Number} near Near bound of the frustum
  1334.  * @param {Number} far Far bound of the frustum
  1335.  * @returns {mat4} out
  1336.  */
  1338. export function frustum(out, left, right, bottom, top, near, far) {
  1339.   var rl = 1 / (right - left);
  1340.   var tb = 1 / (top - bottom);
  1341.   var nf = 1 / (near - far);
  1342.   out[0] = near * 2 * rl;
  1343.   out[1] = 0;
  1344.   out[2] = 0;
  1345.   out[3] = 0;
  1346.   out[4] = 0;
  1347.   out[5] = near * 2 * tb;
  1348.   out[6] = 0;
  1349.   out[7] = 0;
  1350.   out[8] = (right + left) * rl;
  1351.   out[9] = (top + bottom) * tb;
  1352.   out[10] = (far + near) * nf;
  1353.   out[11] = -1;
  1354.   out[12] = 0;
  1355.   out[13] = 0;
  1356.   out[14] = far * near * 2 * nf;
  1357.   out[15] = 0;
  1358.   return out;
  1359. }
  1360. /**
  1361.  * Generates a perspective projection matrix with the given bounds.
  1362.  * The near/far clip planes correspond to a normalized device coordinate Z range of [-1, 1],
  1363.  * which matches WebGL/OpenGL's clip volume.
  1364.  * Passing null/undefined/no value for far will generate infinite projection matrix.
  1365.  *
  1366.  * @param {mat4} out mat4 frustum matrix will be written into
  1367.  * @param {number} fovy Vertical field of view in radians
  1368.  * @param {number} aspect Aspect ratio. typically viewport width/height
  1369.  * @param {number} near Near bound of the frustum
  1370.  * @param {number} far Far bound of the frustum, can be null or Infinity
  1371.  * @returns {mat4} out
  1372.  */
  1374. export function perspectiveNO(out, fovy, aspect, near, far) {
  1375.   var f = 1.0 / Math.tan(fovy / 2),
  1376.       nf;
  1377.   out[0] = f / aspect;
  1378.   out[1] = 0;
  1379.   out[2] = 0;
  1380.   out[3] = 0;
  1381.   out[4] = 0;
  1382.   out[5] = f;
  1383.   out[6] = 0;
  1384.   out[7] = 0;
  1385.   out[8] = 0;
  1386.   out[9] = 0;
  1387.   out[11] = -1;
  1388.   out[12] = 0;
  1389.   out[13] = 0;
  1390.   out[15] = 0;
  1392.   if (far != null && far !== Infinity) {
  1393.     nf = 1 / (near - far);
  1394.     out[10] = (far + near) * nf;
  1395.     out[14] = 2 * far * near * nf;
  1396.   } else {
  1397.     out[10] = -1;
  1398.     out[14] = -2 * near;
  1399.   }
  1401.   return out;
  1402. }
  1403. /**
  1404.  * Alias for {@link mat4.perspectiveNO}
  1405.  * @function
  1406.  */
  1408. export var perspective = perspectiveNO;
  1409. /**
  1410.  * Generates a perspective projection matrix suitable for WebGPU with the given bounds.
  1411.  * The near/far clip planes correspond to a normalized device coordinate Z range of [0, 1],
  1412.  * which matches WebGPU/Vulkan/DirectX/Metal's clip volume.
  1413.  * Passing null/undefined/no value for far will generate infinite projection matrix.
  1414.  *
  1415.  * @param {mat4} out mat4 frustum matrix will be written into
  1416.  * @param {number} fovy Vertical field of view in radians
  1417.  * @param {number} aspect Aspect ratio. typically viewport width/height
  1418.  * @param {number} near Near bound of the frustum
  1419.  * @param {number} far Far bound of the frustum, can be null or Infinity
  1420.  * @returns {mat4} out
  1421.  */
  1423. export function perspectiveZO(out, fovy, aspect, near, far) {
  1424.   var f = 1.0 / Math.tan(fovy / 2),
  1425.       nf;
  1426.   out[0] = f / aspect;
  1427.   out[1] = 0;
  1428.   out[2] = 0;
  1429.   out[3] = 0;
  1430.   out[4] = 0;
  1431.   out[5] = f;
  1432.   out[6] = 0;
  1433.   out[7] = 0;
  1434.   out[8] = 0;
  1435.   out[9] = 0;
  1436.   out[11] = -1;
  1437.   out[12] = 0;
  1438.   out[13] = 0;
  1439.   out[15] = 0;
  1441.   if (far != null && far !== Infinity) {
  1442.     nf = 1 / (near - far);
  1443.     out[10] = far * nf;
  1444.     out[14] = far * near * nf;
  1445.   } else {
  1446.     out[10] = -1;
  1447.     out[14] = -near;
  1448.   }
  1450.   return out;
  1451. }
  1452. /**
  1453.  * Generates a perspective projection matrix with the given field of view.
  1454.  * This is primarily useful for generating projection matrices to be used
  1455.  * with the still experiemental WebVR API.
  1456.  *
  1457.  * @param {mat4} out mat4 frustum matrix will be written into
  1458.  * @param {Object} fov Object containing the following values: upDegrees, downDegrees, leftDegrees, rightDegrees
  1459.  * @param {number} near Near bound of the frustum
  1460.  * @param {number} far Far bound of the frustum
  1461.  * @returns {mat4} out
  1462.  */
  1464. export function perspectiveFromFieldOfView(out, fov, near, far) {
  1465.   var upTan = Math.tan(fov.upDegrees * Math.PI / 180.0);
  1466.   var downTan = Math.tan(fov.downDegrees * Math.PI / 180.0);
  1467.   var leftTan = Math.tan(fov.leftDegrees * Math.PI / 180.0);
  1468.   var rightTan = Math.tan(fov.rightDegrees * Math.PI / 180.0);
  1469.   var xScale = 2.0 / (leftTan + rightTan);
  1470.   var yScale = 2.0 / (upTan + downTan);
  1471.   out[0] = xScale;
  1472.   out[1] = 0.0;
  1473.   out[2] = 0.0;
  1474.   out[3] = 0.0;
  1475.   out[4] = 0.0;
  1476.   out[5] = yScale;
  1477.   out[6] = 0.0;
  1478.   out[7] = 0.0;
  1479.   out[8] = -((leftTan - rightTan) * xScale * 0.5);
  1480.   out[9] = (upTan - downTan) * yScale * 0.5;
  1481.   out[10] = far / (near - far);
  1482.   out[11] = -1.0;
  1483.   out[12] = 0.0;
  1484.   out[13] = 0.0;
  1485.   out[14] = far * near / (near - far);
  1486.   out[15] = 0.0;
  1487.   return out;
  1488. }
  1489. /**
  1490.  * Generates a orthogonal projection matrix with the given bounds.
  1491.  * The near/far clip planes correspond to a normalized device coordinate Z range of [-1, 1],
  1492.  * which matches WebGL/OpenGL's clip volume.
  1493.  *
  1494.  * @param {mat4} out mat4 frustum matrix will be written into
  1495.  * @param {number} left Left bound of the frustum
  1496.  * @param {number} right Right bound of the frustum
  1497.  * @param {number} bottom Bottom bound of the frustum
  1498.  * @param {number} top Top bound of the frustum
  1499.  * @param {number} near Near bound of the frustum
  1500.  * @param {number} far Far bound of the frustum
  1501.  * @returns {mat4} out
  1502.  */
  1504. export function orthoNO(out, left, right, bottom, top, near, far) {
  1505.   var lr = 1 / (left - right);
  1506.   var bt = 1 / (bottom - top);
  1507.   var nf = 1 / (near - far);
  1508.   out[0] = -2 * lr;
  1509.   out[1] = 0;
  1510.   out[2] = 0;
  1511.   out[3] = 0;
  1512.   out[4] = 0;
  1513.   out[5] = -2 * bt;
  1514.   out[6] = 0;
  1515.   out[7] = 0;
  1516.   out[8] = 0;
  1517.   out[9] = 0;
  1518.   out[10] = 2 * nf;
  1519.   out[11] = 0;
  1520.   out[12] = (left + right) * lr;
  1521.   out[13] = (top + bottom) * bt;
  1522.   out[14] = (far + near) * nf;
  1523.   out[15] = 1;
  1524.   return out;
  1525. }
  1526. /**
  1527.  * Alias for {@link mat4.orthoNO}
  1528.  * @function
  1529.  */
  1531. export var ortho = orthoNO;
  1532. /**
  1533.  * Generates a orthogonal projection matrix with the given bounds.
  1534.  * The near/far clip planes correspond to a normalized device coordinate Z range of [0, 1],
  1535.  * which matches WebGPU/Vulkan/DirectX/Metal's clip volume.
  1536.  *
  1537.  * @param {mat4} out mat4 frustum matrix will be written into
  1538.  * @param {number} left Left bound of the frustum
  1539.  * @param {number} right Right bound of the frustum
  1540.  * @param {number} bottom Bottom bound of the frustum
  1541.  * @param {number} top Top bound of the frustum
  1542.  * @param {number} near Near bound of the frustum
  1543.  * @param {number} far Far bound of the frustum
  1544.  * @returns {mat4} out
  1545.  */
  1547. export function orthoZO(out, left, right, bottom, top, near, far) {
  1548.   var lr = 1 / (left - right);
  1549.   var bt = 1 / (bottom - top);
  1550.   var nf = 1 / (near - far);
  1551.   out[0] = -2 * lr;
  1552.   out[1] = 0;
  1553.   out[2] = 0;
  1554.   out[3] = 0;
  1555.   out[4] = 0;
  1556.   out[5] = -2 * bt;
  1557.   out[6] = 0;
  1558.   out[7] = 0;
  1559.   out[8] = 0;
  1560.   out[9] = 0;
  1561.   out[10] = nf;
  1562.   out[11] = 0;
  1563.   out[12] = (left + right) * lr;
  1564.   out[13] = (top + bottom) * bt;
  1565.   out[14] = near * nf;
  1566.   out[15] = 1;
  1567.   return out;
  1568. }
  1569. /**
  1570.  * Generates a look-at matrix with the given eye position, focal point, and up axis.
  1571.  * If you want a matrix that actually makes an object look at another object, you should use targetTo instead.
  1572.  *
  1573.  * @param {mat4} out mat4 frustum matrix will be written into
  1574.  * @param {ReadonlyVec3} eye Position of the viewer
  1575.  * @param {ReadonlyVec3} center Point the viewer is looking at
  1576.  * @param {ReadonlyVec3} up vec3 pointing up
  1577.  * @returns {mat4} out
  1578.  */
  1580. export function lookAt(out, eye, center, up) {
  1581.   var x0, x1, x2, y0, y1, y2, z0, z1, z2, len;
  1582.   var eyex = eye[0];
  1583.   var eyey = eye[1];
  1584.   var eyez = eye[2];
  1585.   var upx = up[0];
  1586.   var upy = up[1];
  1587.   var upz = up[2];
  1588.   var centerx = center[0];
  1589.   var centery = center[1];
  1590.   var centerz = center[2];
  1592.   if (Math.abs(eyex - centerx) < glMatrix.EPSILON && Math.abs(eyey - centery) < glMatrix.EPSILON && Math.abs(eyez - centerz) < glMatrix.EPSILON) {
  1593.     return identity(out);
  1594.   }
  1596.   z0 = eyex - centerx;
  1597.   z1 = eyey - centery;
  1598.   z2 = eyez - centerz;
  1599.   len = 1 / Math.hypot(z0, z1, z2);
  1600.   z0 *= len;
  1601.   z1 *= len;
  1602.   z2 *= len;
  1603.   x0 = upy * z2 - upz * z1;
  1604.   x1 = upz * z0 - upx * z2;
  1605.   x2 = upx * z1 - upy * z0;
  1606.   len = Math.hypot(x0, x1, x2);
  1608.   if (!len) {
  1609.     x0 = 0;
  1610.     x1 = 0;
  1611.     x2 = 0;
  1612.   } else {
  1613.     len = 1 / len;
  1614.     x0 *= len;
  1615.     x1 *= len;
  1616.     x2 *= len;
  1617.   }
  1619.   y0 = z1 * x2 - z2 * x1;
  1620.   y1 = z2 * x0 - z0 * x2;
  1621.   y2 = z0 * x1 - z1 * x0;
  1622.   len = Math.hypot(y0, y1, y2);
  1624.   if (!len) {
  1625.     y0 = 0;
  1626.     y1 = 0;
  1627.     y2 = 0;
  1628.   } else {
  1629.     len = 1 / len;
  1630.     y0 *= len;
  1631.     y1 *= len;
  1632.     y2 *= len;
  1633.   }
  1635.   out[0] = x0;
  1636.   out[1] = y0;
  1637.   out[2] = z0;
  1638.   out[3] = 0;
  1639.   out[4] = x1;
  1640.   out[5] = y1;
  1641.   out[6] = z1;
  1642.   out[7] = 0;
  1643.   out[8] = x2;
  1644.   out[9] = y2;
  1645.   out[10] = z2;
  1646.   out[11] = 0;
  1647.   out[12] = -(x0 * eyex + x1 * eyey + x2 * eyez);
  1648.   out[13] = -(y0 * eyex + y1 * eyey + y2 * eyez);
  1649.   out[14] = -(z0 * eyex + z1 * eyey + z2 * eyez);
  1650.   out[15] = 1;
  1651.   return out;
  1652. }
  1653. /**
  1654.  * Generates a matrix that makes something look at something else.
  1655.  *
  1656.  * @param {mat4} out mat4 frustum matrix will be written into
  1657.  * @param {ReadonlyVec3} eye Position of the viewer
  1658.  * @param {ReadonlyVec3} center Point the viewer is looking at
  1659.  * @param {ReadonlyVec3} up vec3 pointing up
  1660.  * @returns {mat4} out
  1661.  */
  1663. export function targetTo(out, eye, target, up) {
  1664.   var eyex = eye[0],
  1665.       eyey = eye[1],
  1666.       eyez = eye[2],
  1667.       upx = up[0],
  1668.       upy = up[1],
  1669.       upz = up[2];
  1670.   var z0 = eyex - target[0],
  1671.       z1 = eyey - target[1],
  1672.       z2 = eyez - target[2];
  1673.   var len = z0 * z0 + z1 * z1 + z2 * z2;
  1675.   if (len > 0) {
  1676.     len = 1 / Math.sqrt(len);
  1677.     z0 *= len;
  1678.     z1 *= len;
  1679.     z2 *= len;
  1680.   }
  1682.   var x0 = upy * z2 - upz * z1,
  1683.       x1 = upz * z0 - upx * z2,
  1684.       x2 = upx * z1 - upy * z0;
  1685.   len = x0 * x0 + x1 * x1 + x2 * x2;
  1687.   if (len > 0) {
  1688.     len = 1 / Math.sqrt(len);
  1689.     x0 *= len;
  1690.     x1 *= len;
  1691.     x2 *= len;
  1692.   }
  1694.   out[0] = x0;
  1695.   out[1] = x1;
  1696.   out[2] = x2;
  1697.   out[3] = 0;
  1698.   out[4] = z1 * x2 - z2 * x1;
  1699.   out[5] = z2 * x0 - z0 * x2;
  1700.   out[6] = z0 * x1 - z1 * x0;
  1701.   out[7] = 0;
  1702.   out[8] = z0;
  1703.   out[9] = z1;
  1704.   out[10] = z2;
  1705.   out[11] = 0;
  1706.   out[12] = eyex;
  1707.   out[13] = eyey;
  1708.   out[14] = eyez;
  1709.   out[15] = 1;
  1710.   return out;
  1711. }
  1712. /**
  1713.  * Returns a string representation of a mat4
  1714.  *
  1715.  * @param {ReadonlyMat4} a matrix to represent as a string
  1716.  * @returns {String} string representation of the matrix
  1717.  */
  1719. export function str(a) {
  1720.   return "mat4(" + a[0] + ", " + a[1] + ", " + a[2] + ", " + a[3] + ", " + a[4] + ", " + a[5] + ", " + a[6] + ", " + a[7] + ", " + a[8] + ", " + a[9] + ", " + a[10] + ", " + a[11] + ", " + a[12] + ", " + a[13] + ", " + a[14] + ", " + a[15] + ")";
  1721. }
  1722. /**
  1723.  * Returns Frobenius norm of a mat4
  1724.  *
  1725.  * @param {ReadonlyMat4} a the matrix to calculate Frobenius norm of
  1726.  * @returns {Number} Frobenius norm
  1727.  */
  1729. export function frob(a) {
  1730.   return Math.hypot(a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7], a[8], a[9], a[10], a[11], a[12], a[13], a[14], a[15]);
  1731. }
  1732. /**
  1733.  * Adds two mat4's
  1734.  *
  1735.  * @param {mat4} out the receiving matrix
  1736.  * @param {ReadonlyMat4} a the first operand
  1737.  * @param {ReadonlyMat4} b the second operand
  1738.  * @returns {mat4} out
  1739.  */
  1741. export function add(out, a, b) {
  1742.   out[0] = a[0] + b[0];
  1743.   out[1] = a[1] + b[1];
  1744.   out[2] = a[2] + b[2];
  1745.   out[3] = a[3] + b[3];
  1746.   out[4] = a[4] + b[4];
  1747.   out[5] = a[5] + b[5];
  1748.   out[6] = a[6] + b[6];
  1749.   out[7] = a[7] + b[7];
  1750.   out[8] = a[8] + b[8];
  1751.   out[9] = a[9] + b[9];
  1752.   out[10] = a[10] + b[10];
  1753.   out[11] = a[11] + b[11];
  1754.   out[12] = a[12] + b[12];
  1755.   out[13] = a[13] + b[13];
  1756.   out[14] = a[14] + b[14];
  1757.   out[15] = a[15] + b[15];
  1758.   return out;
  1759. }
  1760. /**
  1761.  * Subtracts matrix b from matrix a
  1762.  *
  1763.  * @param {mat4} out the receiving matrix
  1764.  * @param {ReadonlyMat4} a the first operand
  1765.  * @param {ReadonlyMat4} b the second operand
  1766.  * @returns {mat4} out
  1767.  */
  1769. export function subtract(out, a, b) {
  1770.   out[0] = a[0] - b[0];
  1771.   out[1] = a[1] - b[1];
  1772.   out[2] = a[2] - b[2];
  1773.   out[3] = a[3] - b[3];
  1774.   out[4] = a[4] - b[4];
  1775.   out[5] = a[5] - b[5];
  1776.   out[6] = a[6] - b[6];
  1777.   out[7] = a[7] - b[7];
  1778.   out[8] = a[8] - b[8];
  1779.   out[9] = a[9] - b[9];
  1780.   out[10] = a[10] - b[10];
  1781.   out[11] = a[11] - b[11];
  1782.   out[12] = a[12] - b[12];
  1783.   out[13] = a[13] - b[13];
  1784.   out[14] = a[14] - b[14];
  1785.   out[15] = a[15] - b[15];
  1786.   return out;
  1787. }
  1788. /**
  1789.  * Multiply each element of the matrix by a scalar.
  1790.  *
  1791.  * @param {mat4} out the receiving matrix
  1792.  * @param {ReadonlyMat4} a the matrix to scale
  1793.  * @param {Number} b amount to scale the matrix's elements by
  1794.  * @returns {mat4} out
  1795.  */
  1797. export function multiplyScalar(out, a, b) {
  1798.   out[0] = a[0] * b;
  1799.   out[1] = a[1] * b;
  1800.   out[2] = a[2] * b;
  1801.   out[3] = a[3] * b;
  1802.   out[4] = a[4] * b;
  1803.   out[5] = a[5] * b;
  1804.   out[6] = a[6] * b;
  1805.   out[7] = a[7] * b;
  1806.   out[8] = a[8] * b;
  1807.   out[9] = a[9] * b;
  1808.   out[10] = a[10] * b;
  1809.   out[11] = a[11] * b;
  1810.   out[12] = a[12] * b;
  1811.   out[13] = a[13] * b;
  1812.   out[14] = a[14] * b;
  1813.   out[15] = a[15] * b;
  1814.   return out;
  1815. }
  1816. /**
  1817.  * Adds two mat4's after multiplying each element of the second operand by a scalar value.
  1818.  *
  1819.  * @param {mat4} out the receiving vector
  1820.  * @param {ReadonlyMat4} a the first operand
  1821.  * @param {ReadonlyMat4} b the second operand
  1822.  * @param {Number} scale the amount to scale b's elements by before adding
  1823.  * @returns {mat4} out
  1824.  */
  1826. export function multiplyScalarAndAdd(out, a, b, scale) {
  1827.   out[0] = a[0] + b[0] * scale;
  1828.   out[1] = a[1] + b[1] * scale;
  1829.   out[2] = a[2] + b[2] * scale;
  1830.   out[3] = a[3] + b[3] * scale;
  1831.   out[4] = a[4] + b[4] * scale;
  1832.   out[5] = a[5] + b[5] * scale;
  1833.   out[6] = a[6] + b[6] * scale;
  1834.   out[7] = a[7] + b[7] * scale;
  1835.   out[8] = a[8] + b[8] * scale;
  1836.   out[9] = a[9] + b[9] * scale;
  1837.   out[10] = a[10] + b[10] * scale;
  1838.   out[11] = a[11] + b[11] * scale;
  1839.   out[12] = a[12] + b[12] * scale;
  1840.   out[13] = a[13] + b[13] * scale;
  1841.   out[14] = a[14] + b[14] * scale;
  1842.   out[15] = a[15] + b[15] * scale;
  1843.   return out;
  1844. }
  1845. /**
  1846.  * Returns whether or not the matrices have exactly the same elements in the same position (when compared with ===)
  1847.  *
  1848.  * @param {ReadonlyMat4} a The first matrix.
  1849.  * @param {ReadonlyMat4} b The second matrix.
  1850.  * @returns {Boolean} True if the matrices are equal, false otherwise.
  1851.  */
  1853. export function exactEquals(a, b) {
  1854.   return a[0] === b[0] && a[1] === b[1] && a[2] === b[2] && a[3] === b[3] && a[4] === b[4] && a[5] === b[5] && a[6] === b[6] && a[7] === b[7] && a[8] === b[8] && a[9] === b[9] && a[10] === b[10] && a[11] === b[11] && a[12] === b[12] && a[13] === b[13] && a[14] === b[14] && a[15] === b[15];
  1855. }
  1856. /**
  1857.  * Returns whether or not the matrices have approximately the same elements in the same position.
  1858.  *
  1859.  * @param {ReadonlyMat4} a The first matrix.
  1860.  * @param {ReadonlyMat4} b The second matrix.
  1861.  * @returns {Boolean} True if the matrices are equal, false otherwise.
  1862.  */
  1864. export function equals(a, b) {
  1865.   var a0 = a[0],
  1866.       a1 = a[1],
  1867.       a2 = a[2],
  1868.       a3 = a[3];
  1869.   var a4 = a[4],
  1870.       a5 = a[5],
  1871.       a6 = a[6],
  1872.       a7 = a[7];
  1873.   var a8 = a[8],
  1874.       a9 = a[9],
  1875.       a10 = a[10],
  1876.       a11 = a[11];
  1877.   var a12 = a[12],
  1878.       a13 = a[13],
  1879.       a14 = a[14],
  1880.       a15 = a[15];
  1881.   var b0 = b[0],
  1882.       b1 = b[1],
  1883.       b2 = b[2],
  1884.       b3 = b[3];
  1885.   var b4 = b[4],
  1886.       b5 = b[5],
  1887.       b6 = b[6],
  1888.       b7 = b[7];
  1889.   var b8 = b[8],
  1890.       b9 = b[9],
  1891.       b10 = b[10],
  1892.       b11 = b[11];
  1893.   var b12 = b[12],
  1894.       b13 = b[13],
  1895.       b14 = b[14],
  1896.       b15 = b[15];
  1897.   return Math.abs(a0 - b0) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a0), Math.abs(b0)) && Math.abs(a1 - b1) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a1), Math.abs(b1)) && Math.abs(a2 - b2) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a2), Math.abs(b2)) && Math.abs(a3 - b3) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a3), Math.abs(b3)) && Math.abs(a4 - b4) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a4), Math.abs(b4)) && Math.abs(a5 - b5) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a5), Math.abs(b5)) && Math.abs(a6 - b6) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a6), Math.abs(b6)) && Math.abs(a7 - b7) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a7), Math.abs(b7)) && Math.abs(a8 - b8) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a8), Math.abs(b8)) && Math.abs(a9 - b9) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a9), Math.abs(b9)) && Math.abs(a10 - b10) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a10), Math.abs(b10)) && Math.abs(a11 - b11) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a11), Math.abs(b11)) && Math.abs(a12 - b12) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a12), Math.abs(b12)) && Math.abs(a13 - b13) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a13), Math.abs(b13)) && Math.abs(a14 - b14) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a14), Math.abs(b14)) && Math.abs(a15 - b15) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a15), Math.abs(b15));
  1898. }
  1899. /**
  1900.  * Alias for {@link mat4.multiply}
  1901.  * @function
  1902.  */
  1904. export var mul = multiply;
  1905. /**
  1906.  * Alias for {@link mat4.subtract}
  1907.  * @function
  1908.  */
  1910. export var sub = subtract;