Source: mat4.js

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