KaneAI - World’s First E2E Software Testing Agent.Book a Demo Join TestMu Conference

How to use out method in fast-check-monorepo

Best JavaScript code snippet using fast-check-monorepo

gl-matrix-3.3.0.js

Source:gl-matrix-3.3.0.js

1/*!2@fileoverview gl-matrix - High performance matrix and vector operations3@author Brandon Jones4@author Colin MacKenzie IV5@version 3.3.06Copyright (c) 2015-2020, Brandon Jones, Colin MacKenzie IV.7Permission is hereby granted, free of charge, to any person obtaining a copy8of this software and associated documentation files (the "Software"), to deal9in the Software without restriction, including without limitation the rights10to use, copy, modify, merge, publish, distribute, sublicense, and/or sell11copies of the Software, and to permit persons to whom the Software is12furnished to do so, subject to the following conditions:13The above copyright notice and this permission notice shall be included in14all copies or substantial portions of the Software.15THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR16IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,17FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE18AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER19LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,20OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN21THE SOFTWARE.22*/23(function (global, factory) {24  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :25  typeof define === 'function' && define.amd ? define(['exports'], factory) :26  (global = global || self, factory(global.glMatrix = {}));27}(this, (function (exports) { 'use strict';28  /**29   * Common utilities30   * @module glMatrix31   */32  // Configuration Constants33  var EPSILON = 0.000001;34  var ARRAY_TYPE = typeof Float32Array !== 'undefined' ? Float32Array : Array;35  var RANDOM = Math.random;36  /**37   * Sets the type of array used when creating new vectors and matrices38   *39   * @param {Float32ArrayConstructor | ArrayConstructor} type Array type, such as Float32Array or Array40   */41  function setMatrixArrayType(type) {42    ARRAY_TYPE = type;43  }44  var degree = Math.PI / 180;45  /**46   * Convert Degree To Radian47   *48   * @param {Number} a Angle in Degrees49   */50  function toRadian(a) {51    return a * degree;52  }53  /**54   * Tests whether or not the arguments have approximately the same value, within an absolute55   * or relative tolerance of glMatrix.EPSILON (an absolute tolerance is used for values less56   * than or equal to 1.0, and a relative tolerance is used for larger values)57   *58   * @param {Number} a The first number to test.59   * @param {Number} b The second number to test.60   * @returns {Boolean} True if the numbers are approximately equal, false otherwise.61   */62  function equals(a, b) {63    return Math.abs(a - b) <= EPSILON * Math.max(1.0, Math.abs(a), Math.abs(b));64  }65  if (!Math.hypot) Math.hypot = function () {66    var y = 0,67        i = arguments.length;68    while (i--) {69      y += arguments[i] * arguments[i];70    }71    return Math.sqrt(y);72  };73  var common = /*#__PURE__*/Object.freeze({74    __proto__: null,75    EPSILON: EPSILON,76    get ARRAY_TYPE () { return ARRAY_TYPE; },77    RANDOM: RANDOM,78    setMatrixArrayType: setMatrixArrayType,79    toRadian: toRadian,80    equals: equals81  });82  /**83   * 2x2 Matrix84   * @module mat285   */86  /**87   * Creates a new identity mat288   *89   * @returns {mat2} a new 2x2 matrix90   */91  function create() {92    var out = new ARRAY_TYPE(4);93    if (ARRAY_TYPE != Float32Array) {94      out[1] = 0;95      out[2] = 0;96    }97    out[0] = 1;98    out[3] = 1;99    return out;100  }101  /**102   * Creates a new mat2 initialized with values from an existing matrix103   *104   * @param {ReadonlyMat2} a matrix to clone105   * @returns {mat2} a new 2x2 matrix106   */107  function clone(a) {108    var out = new ARRAY_TYPE(4);109    out[0] = a[0];110    out[1] = a[1];111    out[2] = a[2];112    out[3] = a[3];113    return out;114  }115  /**116   * Copy the values from one mat2 to another117   *118   * @param {mat2} out the receiving matrix119   * @param {ReadonlyMat2} a the source matrix120   * @returns {mat2} out121   */122  function copy(out, a) {123    out[0] = a[0];124    out[1] = a[1];125    out[2] = a[2];126    out[3] = a[3];127    return out;128  }129  /**130   * Set a mat2 to the identity matrix131   *132   * @param {mat2} out the receiving matrix133   * @returns {mat2} out134   */135  function identity(out) {136    out[0] = 1;137    out[1] = 0;138    out[2] = 0;139    out[3] = 1;140    return out;141  }142  /**143   * Create a new mat2 with the given values144   *145   * @param {Number} m00 Component in column 0, row 0 position (index 0)146   * @param {Number} m01 Component in column 0, row 1 position (index 1)147   * @param {Number} m10 Component in column 1, row 0 position (index 2)148   * @param {Number} m11 Component in column 1, row 1 position (index 3)149   * @returns {mat2} out A new 2x2 matrix150   */151  function fromValues(m00, m01, m10, m11) {152    var out = new ARRAY_TYPE(4);153    out[0] = m00;154    out[1] = m01;155    out[2] = m10;156    out[3] = m11;157    return out;158  }159  /**160   * Set the components of a mat2 to the given values161   *162   * @param {mat2} out the receiving matrix163   * @param {Number} m00 Component in column 0, row 0 position (index 0)164   * @param {Number} m01 Component in column 0, row 1 position (index 1)165   * @param {Number} m10 Component in column 1, row 0 position (index 2)166   * @param {Number} m11 Component in column 1, row 1 position (index 3)167   * @returns {mat2} out168   */169  function set(out, m00, m01, m10, m11) {170    out[0] = m00;171    out[1] = m01;172    out[2] = m10;173    out[3] = m11;174    return out;175  }176  /**177   * Transpose the values of a mat2178   *179   * @param {mat2} out the receiving matrix180   * @param {ReadonlyMat2} a the source matrix181   * @returns {mat2} out182   */183  function transpose(out, a) {184    // If we are transposing ourselves we can skip a few steps but have to cache185    // some values186    if (out === a) {187      var a1 = a[1];188      out[1] = a[2];189      out[2] = a1;190    } else {191      out[0] = a[0];192      out[1] = a[2];193      out[2] = a[1];194      out[3] = a[3];195    }196    return out;197  }198  /**199   * Inverts a mat2200   *201   * @param {mat2} out the receiving matrix202   * @param {ReadonlyMat2} a the source matrix203   * @returns {mat2} out204   */205  function invert(out, a) {206    var a0 = a[0],207        a1 = a[1],208        a2 = a[2],209        a3 = a[3]; // Calculate the determinant210    var det = a0 * a3 - a2 * a1;211    if (!det) {212      return null;213    }214    det = 1.0 / det;215    out[0] = a3 * det;216    out[1] = -a1 * det;217    out[2] = -a2 * det;218    out[3] = a0 * det;219    return out;220  }221  /**222   * Calculates the adjugate of a mat2223   *224   * @param {mat2} out the receiving matrix225   * @param {ReadonlyMat2} a the source matrix226   * @returns {mat2} out227   */228  function adjoint(out, a) {229    // Caching this value is nessecary if out == a230    var a0 = a[0];231    out[0] = a[3];232    out[1] = -a[1];233    out[2] = -a[2];234    out[3] = a0;235    return out;236  }237  /**238   * Calculates the determinant of a mat2239   *240   * @param {ReadonlyMat2} a the source matrix241   * @returns {Number} determinant of a242   */243  function determinant(a) {244    return a[0] * a[3] - a[2] * a[1];245  }246  /**247   * Multiplies two mat2's248   *249   * @param {mat2} out the receiving matrix250   * @param {ReadonlyMat2} a the first operand251   * @param {ReadonlyMat2} b the second operand252   * @returns {mat2} out253   */254  function multiply(out, a, b) {255    var a0 = a[0],256        a1 = a[1],257        a2 = a[2],258        a3 = a[3];259    var b0 = b[0],260        b1 = b[1],261        b2 = b[2],262        b3 = b[3];263    out[0] = a0 * b0 + a2 * b1;264    out[1] = a1 * b0 + a3 * b1;265    out[2] = a0 * b2 + a2 * b3;266    out[3] = a1 * b2 + a3 * b3;267    return out;268  }269  /**270   * Rotates a mat2 by the given angle271   *272   * @param {mat2} out the receiving matrix273   * @param {ReadonlyMat2} a the matrix to rotate274   * @param {Number} rad the angle to rotate the matrix by275   * @returns {mat2} out276   */277  function rotate(out, a, rad) {278    var a0 = a[0],279        a1 = a[1],280        a2 = a[2],281        a3 = a[3];282    var s = Math.sin(rad);283    var c = Math.cos(rad);284    out[0] = a0 * c + a2 * s;285    out[1] = a1 * c + a3 * s;286    out[2] = a0 * -s + a2 * c;287    out[3] = a1 * -s + a3 * c;288    return out;289  }290  /**291   * Scales the mat2 by the dimensions in the given vec2292   *293   * @param {mat2} out the receiving matrix294   * @param {ReadonlyMat2} a the matrix to rotate295   * @param {ReadonlyVec2} v the vec2 to scale the matrix by296   * @returns {mat2} out297   **/298  function scale(out, a, v) {299    var a0 = a[0],300        a1 = a[1],301        a2 = a[2],302        a3 = a[3];303    var v0 = v[0],304        v1 = v[1];305    out[0] = a0 * v0;306    out[1] = a1 * v0;307    out[2] = a2 * v1;308    out[3] = a3 * v1;309    return out;310  }311  /**312   * Creates a matrix from a given angle313   * This is equivalent to (but much faster than):314   *315   *     mat2.identity(dest);316   *     mat2.rotate(dest, dest, rad);317   *318   * @param {mat2} out mat2 receiving operation result319   * @param {Number} rad the angle to rotate the matrix by320   * @returns {mat2} out321   */322  function fromRotation(out, rad) {323    var s = Math.sin(rad);324    var c = Math.cos(rad);325    out[0] = c;326    out[1] = s;327    out[2] = -s;328    out[3] = c;329    return out;330  }331  /**332   * Creates a matrix from a vector scaling333   * This is equivalent to (but much faster than):334   *335   *     mat2.identity(dest);336   *     mat2.scale(dest, dest, vec);337   *338   * @param {mat2} out mat2 receiving operation result339   * @param {ReadonlyVec2} v Scaling vector340   * @returns {mat2} out341   */342  function fromScaling(out, v) {343    out[0] = v[0];344    out[1] = 0;345    out[2] = 0;346    out[3] = v[1];347    return out;348  }349  /**350   * Returns a string representation of a mat2351   *352   * @param {ReadonlyMat2} a matrix to represent as a string353   * @returns {String} string representation of the matrix354   */355  function str(a) {356    return "mat2(" + a[0] + ", " + a[1] + ", " + a[2] + ", " + a[3] + ")";357  }358  /**359   * Returns Frobenius norm of a mat2360   *361   * @param {ReadonlyMat2} a the matrix to calculate Frobenius norm of362   * @returns {Number} Frobenius norm363   */364  function frob(a) {365    return Math.hypot(a[0], a[1], a[2], a[3]);366  }367  /**368   * Returns L, D and U matrices (Lower triangular, Diagonal and Upper triangular) by factorizing the input matrix369   * @param {ReadonlyMat2} L the lower triangular matrix370   * @param {ReadonlyMat2} D the diagonal matrix371   * @param {ReadonlyMat2} U the upper triangular matrix372   * @param {ReadonlyMat2} a the input matrix to factorize373   */374  function LDU(L, D, U, a) {375    L[2] = a[2] / a[0];376    U[0] = a[0];377    U[1] = a[1];378    U[3] = a[3] - L[2] * U[1];379    return [L, D, U];380  }381  /**382   * Adds two mat2's383   *384   * @param {mat2} out the receiving matrix385   * @param {ReadonlyMat2} a the first operand386   * @param {ReadonlyMat2} b the second operand387   * @returns {mat2} out388   */389  function add(out, a, b) {390    out[0] = a[0] + b[0];391    out[1] = a[1] + b[1];392    out[2] = a[2] + b[2];393    out[3] = a[3] + b[3];394    return out;395  }396  /**397   * Subtracts matrix b from matrix a398   *399   * @param {mat2} out the receiving matrix400   * @param {ReadonlyMat2} a the first operand401   * @param {ReadonlyMat2} b the second operand402   * @returns {mat2} out403   */404  function subtract(out, a, b) {405    out[0] = a[0] - b[0];406    out[1] = a[1] - b[1];407    out[2] = a[2] - b[2];408    out[3] = a[3] - b[3];409    return out;410  }411  /**412   * Returns whether or not the matrices have exactly the same elements in the same position (when compared with ===)413   *414   * @param {ReadonlyMat2} a The first matrix.415   * @param {ReadonlyMat2} b The second matrix.416   * @returns {Boolean} True if the matrices are equal, false otherwise.417   */418  function exactEquals(a, b) {419    return a[0] === b[0] && a[1] === b[1] && a[2] === b[2] && a[3] === b[3];420  }421  /**422   * Returns whether or not the matrices have approximately the same elements in the same position.423   *424   * @param {ReadonlyMat2} a The first matrix.425   * @param {ReadonlyMat2} b The second matrix.426   * @returns {Boolean} True if the matrices are equal, false otherwise.427   */428  function equals$1(a, b) {429    var a0 = a[0],430        a1 = a[1],431        a2 = a[2],432        a3 = a[3];433    var b0 = b[0],434        b1 = b[1],435        b2 = b[2],436        b3 = b[3];437    return Math.abs(a0 - b0) <= EPSILON * Math.max(1.0, Math.abs(a0), Math.abs(b0)) && Math.abs(a1 - b1) <= EPSILON * Math.max(1.0, Math.abs(a1), Math.abs(b1)) && Math.abs(a2 - b2) <= EPSILON * Math.max(1.0, Math.abs(a2), Math.abs(b2)) && Math.abs(a3 - b3) <= EPSILON * Math.max(1.0, Math.abs(a3), Math.abs(b3));438  }439  /**440   * Multiply each element of the matrix by a scalar.441   *442   * @param {mat2} out the receiving matrix443   * @param {ReadonlyMat2} a the matrix to scale444   * @param {Number} b amount to scale the matrix's elements by445   * @returns {mat2} out446   */447  function multiplyScalar(out, a, b) {448    out[0] = a[0] * b;449    out[1] = a[1] * b;450    out[2] = a[2] * b;451    out[3] = a[3] * b;452    return out;453  }454  /**455   * Adds two mat2's after multiplying each element of the second operand by a scalar value.456   *457   * @param {mat2} out the receiving vector458   * @param {ReadonlyMat2} a the first operand459   * @param {ReadonlyMat2} b the second operand460   * @param {Number} scale the amount to scale b's elements by before adding461   * @returns {mat2} out462   */463  function multiplyScalarAndAdd(out, a, b, scale) {464    out[0] = a[0] + b[0] * scale;465    out[1] = a[1] + b[1] * scale;466    out[2] = a[2] + b[2] * scale;467    out[3] = a[3] + b[3] * scale;468    return out;469  }470  /**471   * Alias for {@link mat2.multiply}472   * @function473   */474  var mul = multiply;475  /**476   * Alias for {@link mat2.subtract}477   * @function478   */479  var sub = subtract;480  var mat2 = /*#__PURE__*/Object.freeze({481    __proto__: null,482    create: create,483    clone: clone,484    copy: copy,485    identity: identity,486    fromValues: fromValues,487    set: set,488    transpose: transpose,489    invert: invert,490    adjoint: adjoint,491    determinant: determinant,492    multiply: multiply,493    rotate: rotate,494    scale: scale,495    fromRotation: fromRotation,496    fromScaling: fromScaling,497    str: str,498    frob: frob,499    LDU: LDU,500    add: add,501    subtract: subtract,502    exactEquals: exactEquals,503    equals: equals$1,504    multiplyScalar: multiplyScalar,505    multiplyScalarAndAdd: multiplyScalarAndAdd,506    mul: mul,507    sub: sub508  });509  /**510   * 2x3 Matrix511   * @module mat2d512   * @description513   * A mat2d contains six elements defined as:514   * <pre>515   * [a, b,516   *  c, d,517   *  tx, ty]518   * </pre>519   * This is a short form for the 3x3 matrix:520   * <pre>521   * [a, b, 0,522   *  c, d, 0,523   *  tx, ty, 1]524   * </pre>525   * The last column is ignored so the array is shorter and operations are faster.526   */527  /**528   * Creates a new identity mat2d529   *530   * @returns {mat2d} a new 2x3 matrix531   */532  function create$1() {533    var out = new ARRAY_TYPE(6);534    if (ARRAY_TYPE != Float32Array) {535      out[1] = 0;536      out[2] = 0;537      out[4] = 0;538      out[5] = 0;539    }540    out[0] = 1;541    out[3] = 1;542    return out;543  }544  /**545   * Creates a new mat2d initialized with values from an existing matrix546   *547   * @param {ReadonlyMat2d} a matrix to clone548   * @returns {mat2d} a new 2x3 matrix549   */550  function clone$1(a) {551    var out = new ARRAY_TYPE(6);552    out[0] = a[0];553    out[1] = a[1];554    out[2] = a[2];555    out[3] = a[3];556    out[4] = a[4];557    out[5] = a[5];558    return out;559  }560  /**561   * Copy the values from one mat2d to another562   *563   * @param {mat2d} out the receiving matrix564   * @param {ReadonlyMat2d} a the source matrix565   * @returns {mat2d} out566   */567  function copy$1(out, a) {568    out[0] = a[0];569    out[1] = a[1];570    out[2] = a[2];571    out[3] = a[3];572    out[4] = a[4];573    out[5] = a[5];574    return out;575  }576  /**577   * Set a mat2d to the identity matrix578   *579   * @param {mat2d} out the receiving matrix580   * @returns {mat2d} out581   */582  function identity$1(out) {583    out[0] = 1;584    out[1] = 0;585    out[2] = 0;586    out[3] = 1;587    out[4] = 0;588    out[5] = 0;589    return out;590  }591  /**592   * Create a new mat2d with the given values593   *594   * @param {Number} a Component A (index 0)595   * @param {Number} b Component B (index 1)596   * @param {Number} c Component C (index 2)597   * @param {Number} d Component D (index 3)598   * @param {Number} tx Component TX (index 4)599   * @param {Number} ty Component TY (index 5)600   * @returns {mat2d} A new mat2d601   */602  function fromValues$1(a, b, c, d, tx, ty) {603    var out = new ARRAY_TYPE(6);604    out[0] = a;605    out[1] = b;606    out[2] = c;607    out[3] = d;608    out[4] = tx;609    out[5] = ty;610    return out;611  }612  /**613   * Set the components of a mat2d to the given values614   *615   * @param {mat2d} out the receiving matrix616   * @param {Number} a Component A (index 0)617   * @param {Number} b Component B (index 1)618   * @param {Number} c Component C (index 2)619   * @param {Number} d Component D (index 3)620   * @param {Number} tx Component TX (index 4)621   * @param {Number} ty Component TY (index 5)622   * @returns {mat2d} out623   */624  function set$1(out, a, b, c, d, tx, ty) {625    out[0] = a;626    out[1] = b;627    out[2] = c;628    out[3] = d;629    out[4] = tx;630    out[5] = ty;631    return out;632  }633  /**634   * Inverts a mat2d635   *636   * @param {mat2d} out the receiving matrix637   * @param {ReadonlyMat2d} a the source matrix638   * @returns {mat2d} out639   */640  function invert$1(out, a) {641    var aa = a[0],642        ab = a[1],643        ac = a[2],644        ad = a[3];645    var atx = a[4],646        aty = a[5];647    var det = aa * ad - ab * ac;648    if (!det) {649      return null;650    }651    det = 1.0 / det;652    out[0] = ad * det;653    out[1] = -ab * det;654    out[2] = -ac * det;655    out[3] = aa * det;656    out[4] = (ac * aty - ad * atx) * det;657    out[5] = (ab * atx - aa * aty) * det;658    return out;659  }660  /**661   * Calculates the determinant of a mat2d662   *663   * @param {ReadonlyMat2d} a the source matrix664   * @returns {Number} determinant of a665   */666  function determinant$1(a) {667    return a[0] * a[3] - a[1] * a[2];668  }669  /**670   * Multiplies two mat2d's671   *672   * @param {mat2d} out the receiving matrix673   * @param {ReadonlyMat2d} a the first operand674   * @param {ReadonlyMat2d} b the second operand675   * @returns {mat2d} out676   */677  function multiply$1(out, a, b) {678    var a0 = a[0],679        a1 = a[1],680        a2 = a[2],681        a3 = a[3],682        a4 = a[4],683        a5 = a[5];684    var b0 = b[0],685        b1 = b[1],686        b2 = b[2],687        b3 = b[3],688        b4 = b[4],689        b5 = b[5];690    out[0] = a0 * b0 + a2 * b1;691    out[1] = a1 * b0 + a3 * b1;692    out[2] = a0 * b2 + a2 * b3;693    out[3] = a1 * b2 + a3 * b3;694    out[4] = a0 * b4 + a2 * b5 + a4;695    out[5] = a1 * b4 + a3 * b5 + a5;696    return out;697  }698  /**699   * Rotates a mat2d by the given angle700   *701   * @param {mat2d} out the receiving matrix702   * @param {ReadonlyMat2d} a the matrix to rotate703   * @param {Number} rad the angle to rotate the matrix by704   * @returns {mat2d} out705   */706  function rotate$1(out, a, rad) {707    var a0 = a[0],708        a1 = a[1],709        a2 = a[2],710        a3 = a[3],711        a4 = a[4],712        a5 = a[5];713    var s = Math.sin(rad);714    var c = Math.cos(rad);715    out[0] = a0 * c + a2 * s;716    out[1] = a1 * c + a3 * s;717    out[2] = a0 * -s + a2 * c;718    out[3] = a1 * -s + a3 * c;719    out[4] = a4;720    out[5] = a5;721    return out;722  }723  /**724   * Scales the mat2d by the dimensions in the given vec2725   *726   * @param {mat2d} out the receiving matrix727   * @param {ReadonlyMat2d} a the matrix to translate728   * @param {ReadonlyVec2} v the vec2 to scale the matrix by729   * @returns {mat2d} out730   **/731  function scale$1(out, a, v) {732    var a0 = a[0],733        a1 = a[1],734        a2 = a[2],735        a3 = a[3],736        a4 = a[4],737        a5 = a[5];738    var v0 = v[0],739        v1 = v[1];740    out[0] = a0 * v0;741    out[1] = a1 * v0;742    out[2] = a2 * v1;743    out[3] = a3 * v1;744    out[4] = a4;745    out[5] = a5;746    return out;747  }748  /**749   * Translates the mat2d by the dimensions in the given vec2750   *751   * @param {mat2d} out the receiving matrix752   * @param {ReadonlyMat2d} a the matrix to translate753   * @param {ReadonlyVec2} v the vec2 to translate the matrix by754   * @returns {mat2d} out755   **/756  function translate(out, a, v) {757    var a0 = a[0],758        a1 = a[1],759        a2 = a[2],760        a3 = a[3],761        a4 = a[4],762        a5 = a[5];763    var v0 = v[0],764        v1 = v[1];765    out[0] = a0;766    out[1] = a1;767    out[2] = a2;768    out[3] = a3;769    out[4] = a0 * v0 + a2 * v1 + a4;770    out[5] = a1 * v0 + a3 * v1 + a5;771    return out;772  }773  /**774   * Creates a matrix from a given angle775   * This is equivalent to (but much faster than):776   *777   *     mat2d.identity(dest);778   *     mat2d.rotate(dest, dest, rad);779   *780   * @param {mat2d} out mat2d receiving operation result781   * @param {Number} rad the angle to rotate the matrix by782   * @returns {mat2d} out783   */784  function fromRotation$1(out, rad) {785    var s = Math.sin(rad),786        c = Math.cos(rad);787    out[0] = c;788    out[1] = s;789    out[2] = -s;790    out[3] = c;791    out[4] = 0;792    out[5] = 0;793    return out;794  }795  /**796   * Creates a matrix from a vector scaling797   * This is equivalent to (but much faster than):798   *799   *     mat2d.identity(dest);800   *     mat2d.scale(dest, dest, vec);801   *802   * @param {mat2d} out mat2d receiving operation result803   * @param {ReadonlyVec2} v Scaling vector804   * @returns {mat2d} out805   */806  function fromScaling$1(out, v) {807    out[0] = v[0];808    out[1] = 0;809    out[2] = 0;810    out[3] = v[1];811    out[4] = 0;812    out[5] = 0;813    return out;814  }815  /**816   * Creates a matrix from a vector translation817   * This is equivalent to (but much faster than):818   *819   *     mat2d.identity(dest);820   *     mat2d.translate(dest, dest, vec);821   *822   * @param {mat2d} out mat2d receiving operation result823   * @param {ReadonlyVec2} v Translation vector824   * @returns {mat2d} out825   */826  function fromTranslation(out, v) {827    out[0] = 1;828    out[1] = 0;829    out[2] = 0;830    out[3] = 1;831    out[4] = v[0];832    out[5] = v[1];833    return out;834  }835  /**836   * Returns a string representation of a mat2d837   *838   * @param {ReadonlyMat2d} a matrix to represent as a string839   * @returns {String} string representation of the matrix840   */841  function str$1(a) {842    return "mat2d(" + a[0] + ", " + a[1] + ", " + a[2] + ", " + a[3] + ", " + a[4] + ", " + a[5] + ")";843  }844  /**845   * Returns Frobenius norm of a mat2d846   *847   * @param {ReadonlyMat2d} a the matrix to calculate Frobenius norm of848   * @returns {Number} Frobenius norm849   */850  function frob$1(a) {851    return Math.hypot(a[0], a[1], a[2], a[3], a[4], a[5], 1);852  }853  /**854   * Adds two mat2d's855   *856   * @param {mat2d} out the receiving matrix857   * @param {ReadonlyMat2d} a the first operand858   * @param {ReadonlyMat2d} b the second operand859   * @returns {mat2d} out860   */861  function add$1(out, a, b) {862    out[0] = a[0] + b[0];863    out[1] = a[1] + b[1];864    out[2] = a[2] + b[2];865    out[3] = a[3] + b[3];866    out[4] = a[4] + b[4];867    out[5] = a[5] + b[5];868    return out;869  }870  /**871   * Subtracts matrix b from matrix a872   *873   * @param {mat2d} out the receiving matrix874   * @param {ReadonlyMat2d} a the first operand875   * @param {ReadonlyMat2d} b the second operand876   * @returns {mat2d} out877   */878  function subtract$1(out, a, b) {879    out[0] = a[0] - b[0];880    out[1] = a[1] - b[1];881    out[2] = a[2] - b[2];882    out[3] = a[3] - b[3];883    out[4] = a[4] - b[4];884    out[5] = a[5] - b[5];885    return out;886  }887  /**888   * Multiply each element of the matrix by a scalar.889   *890   * @param {mat2d} out the receiving matrix891   * @param {ReadonlyMat2d} a the matrix to scale892   * @param {Number} b amount to scale the matrix's elements by893   * @returns {mat2d} out894   */895  function multiplyScalar$1(out, a, b) {896    out[0] = a[0] * b;897    out[1] = a[1] * b;898    out[2] = a[2] * b;899    out[3] = a[3] * b;900    out[4] = a[4] * b;901    out[5] = a[5] * b;902    return out;903  }904  /**905   * Adds two mat2d's after multiplying each element of the second operand by a scalar value.906   *907   * @param {mat2d} out the receiving vector908   * @param {ReadonlyMat2d} a the first operand909   * @param {ReadonlyMat2d} b the second operand910   * @param {Number} scale the amount to scale b's elements by before adding911   * @returns {mat2d} out912   */913  function multiplyScalarAndAdd$1(out, a, b, scale) {914    out[0] = a[0] + b[0] * scale;915    out[1] = a[1] + b[1] * scale;916    out[2] = a[2] + b[2] * scale;917    out[3] = a[3] + b[3] * scale;918    out[4] = a[4] + b[4] * scale;919    out[5] = a[5] + b[5] * scale;920    return out;921  }922  /**923   * Returns whether or not the matrices have exactly the same elements in the same position (when compared with ===)924   *925   * @param {ReadonlyMat2d} a The first matrix.926   * @param {ReadonlyMat2d} b The second matrix.927   * @returns {Boolean} True if the matrices are equal, false otherwise.928   */929  function exactEquals$1(a, b) {930    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];931  }932  /**933   * Returns whether or not the matrices have approximately the same elements in the same position.934   *935   * @param {ReadonlyMat2d} a The first matrix.936   * @param {ReadonlyMat2d} b The second matrix.937   * @returns {Boolean} True if the matrices are equal, false otherwise.938   */939  function equals$2(a, b) {940    var a0 = a[0],941        a1 = a[1],942        a2 = a[2],943        a3 = a[3],944        a4 = a[4],945        a5 = a[5];946    var b0 = b[0],947        b1 = b[1],948        b2 = b[2],949        b3 = b[3],950        b4 = b[4],951        b5 = b[5];952    return Math.abs(a0 - b0) <= EPSILON * Math.max(1.0, Math.abs(a0), Math.abs(b0)) && Math.abs(a1 - b1) <= EPSILON * Math.max(1.0, Math.abs(a1), Math.abs(b1)) && Math.abs(a2 - b2) <= EPSILON * Math.max(1.0, Math.abs(a2), Math.abs(b2)) && Math.abs(a3 - b3) <= EPSILON * Math.max(1.0, Math.abs(a3), Math.abs(b3)) && Math.abs(a4 - b4) <= EPSILON * Math.max(1.0, Math.abs(a4), Math.abs(b4)) && Math.abs(a5 - b5) <= EPSILON * Math.max(1.0, Math.abs(a5), Math.abs(b5));953  }954  /**955   * Alias for {@link mat2d.multiply}956   * @function957   */958  var mul$1 = multiply$1;959  /**960   * Alias for {@link mat2d.subtract}961   * @function962   */963  var sub$1 = subtract$1;964  var mat2d = /*#__PURE__*/Object.freeze({965    __proto__: null,966    create: create$1,967    clone: clone$1,968    copy: copy$1,969    identity: identity$1,970    fromValues: fromValues$1,971    set: set$1,972    invert: invert$1,973    determinant: determinant$1,974    multiply: multiply$1,975    rotate: rotate$1,976    scale: scale$1,977    translate: translate,978    fromRotation: fromRotation$1,979    fromScaling: fromScaling$1,980    fromTranslation: fromTranslation,981    str: str$1,982    frob: frob$1,983    add: add$1,984    subtract: subtract$1,985    multiplyScalar: multiplyScalar$1,986    multiplyScalarAndAdd: multiplyScalarAndAdd$1,987    exactEquals: exactEquals$1,988    equals: equals$2,989    mul: mul$1,990    sub: sub$1991  });992  /**993   * 3x3 Matrix994   * @module mat3995   */996  /**997   * Creates a new identity mat3998   *999   * @returns {mat3} a new 3x3 matrix1000   */1001  function create$2() {1002    var out = new ARRAY_TYPE(9);1003    if (ARRAY_TYPE != Float32Array) {1004      out[1] = 0;1005      out[2] = 0;1006      out[3] = 0;1007      out[5] = 0;1008      out[6] = 0;1009      out[7] = 0;1010    }1011    out[0] = 1;1012    out[4] = 1;1013    out[8] = 1;1014    return out;1015  }1016  /**1017   * Copies the upper-left 3x3 values into the given mat3.1018   *1019   * @param {mat3} out the receiving 3x3 matrix1020   * @param {ReadonlyMat4} a   the source 4x4 matrix1021   * @returns {mat3} out1022   */1023  function fromMat4(out, a) {1024    out[0] = a[0];1025    out[1] = a[1];1026    out[2] = a[2];1027    out[3] = a[4];1028    out[4] = a[5];1029    out[5] = a[6];1030    out[6] = a[8];1031    out[7] = a[9];1032    out[8] = a[10];1033    return out;1034  }1035  /**1036   * Creates a new mat3 initialized with values from an existing matrix1037   *1038   * @param {ReadonlyMat3} a matrix to clone1039   * @returns {mat3} a new 3x3 matrix1040   */1041  function clone$2(a) {1042    var out = new ARRAY_TYPE(9);1043    out[0] = a[0];1044    out[1] = a[1];1045    out[2] = a[2];1046    out[3] = a[3];1047    out[4] = a[4];1048    out[5] = a[5];1049    out[6] = a[6];1050    out[7] = a[7];1051    out[8] = a[8];1052    return out;1053  }1054  /**1055   * Copy the values from one mat3 to another1056   *1057   * @param {mat3} out the receiving matrix1058   * @param {ReadonlyMat3} a the source matrix1059   * @returns {mat3} out1060   */1061  function copy$2(out, a) {1062    out[0] = a[0];1063    out[1] = a[1];1064    out[2] = a[2];1065    out[3] = a[3];1066    out[4] = a[4];1067    out[5] = a[5];1068    out[6] = a[6];1069    out[7] = a[7];1070    out[8] = a[8];1071    return out;1072  }1073  /**1074   * Create a new mat3 with the given values1075   *1076   * @param {Number} m00 Component in column 0, row 0 position (index 0)1077   * @param {Number} m01 Component in column 0, row 1 position (index 1)1078   * @param {Number} m02 Component in column 0, row 2 position (index 2)1079   * @param {Number} m10 Component in column 1, row 0 position (index 3)1080   * @param {Number} m11 Component in column 1, row 1 position (index 4)1081   * @param {Number} m12 Component in column 1, row 2 position (index 5)1082   * @param {Number} m20 Component in column 2, row 0 position (index 6)1083   * @param {Number} m21 Component in column 2, row 1 position (index 7)1084   * @param {Number} m22 Component in column 2, row 2 position (index 8)1085   * @returns {mat3} A new mat31086   */1087  function fromValues$2(m00, m01, m02, m10, m11, m12, m20, m21, m22) {1088    var out = new ARRAY_TYPE(9);1089    out[0] = m00;1090    out[1] = m01;1091    out[2] = m02;1092    out[3] = m10;1093    out[4] = m11;1094    out[5] = m12;1095    out[6] = m20;1096    out[7] = m21;1097    out[8] = m22;1098    return out;1099  }1100  /**1101   * Set the components of a mat3 to the given values1102   *1103   * @param {mat3} out the receiving matrix1104   * @param {Number} m00 Component in column 0, row 0 position (index 0)1105   * @param {Number} m01 Component in column 0, row 1 position (index 1)1106   * @param {Number} m02 Component in column 0, row 2 position (index 2)1107   * @param {Number} m10 Component in column 1, row 0 position (index 3)1108   * @param {Number} m11 Component in column 1, row 1 position (index 4)1109   * @param {Number} m12 Component in column 1, row 2 position (index 5)1110   * @param {Number} m20 Component in column 2, row 0 position (index 6)1111   * @param {Number} m21 Component in column 2, row 1 position (index 7)1112   * @param {Number} m22 Component in column 2, row 2 position (index 8)1113   * @returns {mat3} out1114   */1115  function set$2(out, m00, m01, m02, m10, m11, m12, m20, m21, m22) {1116    out[0] = m00;1117    out[1] = m01;1118    out[2] = m02;1119    out[3] = m10;1120    out[4] = m11;1121    out[5] = m12;1122    out[6] = m20;1123    out[7] = m21;1124    out[8] = m22;1125    return out;1126  }1127  /**1128   * Set a mat3 to the identity matrix1129   *1130   * @param {mat3} out the receiving matrix1131   * @returns {mat3} out1132   */1133  function identity$2(out) {1134    out[0] = 1;1135    out[1] = 0;1136    out[2] = 0;1137    out[3] = 0;1138    out[4] = 1;1139    out[5] = 0;1140    out[6] = 0;1141    out[7] = 0;1142    out[8] = 1;1143    return out;1144  }1145  /**1146   * Transpose the values of a mat31147   *1148   * @param {mat3} out the receiving matrix1149   * @param {ReadonlyMat3} a the source matrix1150   * @returns {mat3} out1151   */1152  function transpose$1(out, a) {1153    // If we are transposing ourselves we can skip a few steps but have to cache some values1154    if (out === a) {1155      var a01 = a[1],1156          a02 = a[2],1157          a12 = a[5];1158      out[1] = a[3];1159      out[2] = a[6];1160      out[3] = a01;1161      out[5] = a[7];1162      out[6] = a02;1163      out[7] = a12;1164    } else {1165      out[0] = a[0];1166      out[1] = a[3];1167      out[2] = a[6];1168      out[3] = a[1];1169      out[4] = a[4];1170      out[5] = a[7];1171      out[6] = a[2];1172      out[7] = a[5];1173      out[8] = a[8];1174    }1175    return out;1176  }1177  /**1178   * Inverts a mat31179   *1180   * @param {mat3} out the receiving matrix1181   * @param {ReadonlyMat3} a the source matrix1182   * @returns {mat3} out1183   */1184  function invert$2(out, a) {1185    var a00 = a[0],1186        a01 = a[1],1187        a02 = a[2];1188    var a10 = a[3],1189        a11 = a[4],1190        a12 = a[5];1191    var a20 = a[6],1192        a21 = a[7],1193        a22 = a[8];1194    var b01 = a22 * a11 - a12 * a21;1195    var b11 = -a22 * a10 + a12 * a20;1196    var b21 = a21 * a10 - a11 * a20; // Calculate the determinant1197    var det = a00 * b01 + a01 * b11 + a02 * b21;1198    if (!det) {1199      return null;1200    }1201    det = 1.0 / det;1202    out[0] = b01 * det;1203    out[1] = (-a22 * a01 + a02 * a21) * det;1204    out[2] = (a12 * a01 - a02 * a11) * det;1205    out[3] = b11 * det;1206    out[4] = (a22 * a00 - a02 * a20) * det;1207    out[5] = (-a12 * a00 + a02 * a10) * det;1208    out[6] = b21 * det;1209    out[7] = (-a21 * a00 + a01 * a20) * det;1210    out[8] = (a11 * a00 - a01 * a10) * det;1211    return out;1212  }1213  /**1214   * Calculates the adjugate of a mat31215   *1216   * @param {mat3} out the receiving matrix1217   * @param {ReadonlyMat3} a the source matrix1218   * @returns {mat3} out1219   */1220  function adjoint$1(out, a) {1221    var a00 = a[0],1222        a01 = a[1],1223        a02 = a[2];1224    var a10 = a[3],1225        a11 = a[4],1226        a12 = a[5];1227    var a20 = a[6],1228        a21 = a[7],1229        a22 = a[8];1230    out[0] = a11 * a22 - a12 * a21;1231    out[1] = a02 * a21 - a01 * a22;1232    out[2] = a01 * a12 - a02 * a11;1233    out[3] = a12 * a20 - a10 * a22;1234    out[4] = a00 * a22 - a02 * a20;1235    out[5] = a02 * a10 - a00 * a12;1236    out[6] = a10 * a21 - a11 * a20;1237    out[7] = a01 * a20 - a00 * a21;1238    out[8] = a00 * a11 - a01 * a10;1239    return out;1240  }1241  /**1242   * Calculates the determinant of a mat31243   *1244   * @param {ReadonlyMat3} a the source matrix1245   * @returns {Number} determinant of a1246   */1247  function determinant$2(a) {1248    var a00 = a[0],1249        a01 = a[1],1250        a02 = a[2];1251    var a10 = a[3],1252        a11 = a[4],1253        a12 = a[5];1254    var a20 = a[6],1255        a21 = a[7],1256        a22 = a[8];1257    return a00 * (a22 * a11 - a12 * a21) + a01 * (-a22 * a10 + a12 * a20) + a02 * (a21 * a10 - a11 * a20);1258  }1259  /**1260   * Multiplies two mat3's1261   *1262   * @param {mat3} out the receiving matrix1263   * @param {ReadonlyMat3} a the first operand1264   * @param {ReadonlyMat3} b the second operand1265   * @returns {mat3} out1266   */1267  function multiply$2(out, a, b) {1268    var a00 = a[0],1269        a01 = a[1],1270        a02 = a[2];1271    var a10 = a[3],1272        a11 = a[4],1273        a12 = a[5];1274    var a20 = a[6],1275        a21 = a[7],1276        a22 = a[8];1277    var b00 = b[0],1278        b01 = b[1],1279        b02 = b[2];1280    var b10 = b[3],1281        b11 = b[4],1282        b12 = b[5];1283    var b20 = b[6],1284        b21 = b[7],1285        b22 = b[8];1286    out[0] = b00 * a00 + b01 * a10 + b02 * a20;1287    out[1] = b00 * a01 + b01 * a11 + b02 * a21;1288    out[2] = b00 * a02 + b01 * a12 + b02 * a22;1289    out[3] = b10 * a00 + b11 * a10 + b12 * a20;1290    out[4] = b10 * a01 + b11 * a11 + b12 * a21;1291    out[5] = b10 * a02 + b11 * a12 + b12 * a22;1292    out[6] = b20 * a00 + b21 * a10 + b22 * a20;1293    out[7] = b20 * a01 + b21 * a11 + b22 * a21;1294    out[8] = b20 * a02 + b21 * a12 + b22 * a22;1295    return out;1296  }1297  /**1298   * Translate a mat3 by the given vector1299   *1300   * @param {mat3} out the receiving matrix1301   * @param {ReadonlyMat3} a the matrix to translate1302   * @param {ReadonlyVec2} v vector to translate by1303   * @returns {mat3} out1304   */1305  function translate$1(out, a, v) {1306    var a00 = a[0],1307        a01 = a[1],1308        a02 = a[2],1309        a10 = a[3],1310        a11 = a[4],1311        a12 = a[5],1312        a20 = a[6],1313        a21 = a[7],1314        a22 = a[8],1315        x = v[0],1316        y = v[1];1317    out[0] = a00;1318    out[1] = a01;1319    out[2] = a02;1320    out[3] = a10;1321    out[4] = a11;1322    out[5] = a12;1323    out[6] = x * a00 + y * a10 + a20;1324    out[7] = x * a01 + y * a11 + a21;1325    out[8] = x * a02 + y * a12 + a22;1326    return out;1327  }1328  /**1329   * Rotates a mat3 by the given angle1330   *1331   * @param {mat3} out the receiving matrix1332   * @param {ReadonlyMat3} a the matrix to rotate1333   * @param {Number} rad the angle to rotate the matrix by1334   * @returns {mat3} out1335   */1336  function rotate$2(out, a, rad) {1337    var a00 = a[0],1338        a01 = a[1],1339        a02 = a[2],1340        a10 = a[3],1341        a11 = a[4],1342        a12 = a[5],1343        a20 = a[6],1344        a21 = a[7],1345        a22 = a[8],1346        s = Math.sin(rad),1347        c = Math.cos(rad);1348    out[0] = c * a00 + s * a10;1349    out[1] = c * a01 + s * a11;1350    out[2] = c * a02 + s * a12;1351    out[3] = c * a10 - s * a00;1352    out[4] = c * a11 - s * a01;1353    out[5] = c * a12 - s * a02;1354    out[6] = a20;1355    out[7] = a21;1356    out[8] = a22;1357    return out;1358  }1359  /**1360   * Scales the mat3 by the dimensions in the given vec21361   *1362   * @param {mat3} out the receiving matrix1363   * @param {ReadonlyMat3} a the matrix to rotate1364   * @param {ReadonlyVec2} v the vec2 to scale the matrix by1365   * @returns {mat3} out1366   **/1367  function scale$2(out, a, v) {1368    var x = v[0],1369        y = v[1];1370    out[0] = x * a[0];1371    out[1] = x * a[1];1372    out[2] = x * a[2];1373    out[3] = y * a[3];1374    out[4] = y * a[4];1375    out[5] = y * a[5];1376    out[6] = a[6];1377    out[7] = a[7];1378    out[8] = a[8];1379    return out;1380  }1381  /**1382   * Creates a matrix from a vector translation1383   * This is equivalent to (but much faster than):1384   *1385   *     mat3.identity(dest);1386   *     mat3.translate(dest, dest, vec);1387   *1388   * @param {mat3} out mat3 receiving operation result1389   * @param {ReadonlyVec2} v Translation vector1390   * @returns {mat3} out1391   */1392  function fromTranslation$1(out, v) {1393    out[0] = 1;1394    out[1] = 0;1395    out[2] = 0;1396    out[3] = 0;1397    out[4] = 1;1398    out[5] = 0;1399    out[6] = v[0];1400    out[7] = v[1];1401    out[8] = 1;1402    return out;1403  }1404  /**1405   * Creates a matrix from a given angle1406   * This is equivalent to (but much faster than):1407   *1408   *     mat3.identity(dest);1409   *     mat3.rotate(dest, dest, rad);1410   *1411   * @param {mat3} out mat3 receiving operation result1412   * @param {Number} rad the angle to rotate the matrix by1413   * @returns {mat3} out1414   */1415  function fromRotation$2(out, rad) {1416    var s = Math.sin(rad),1417        c = Math.cos(rad);1418    out[0] = c;1419    out[1] = s;1420    out[2] = 0;1421    out[3] = -s;1422    out[4] = c;1423    out[5] = 0;1424    out[6] = 0;1425    out[7] = 0;1426    out[8] = 1;1427    return out;1428  }1429  /**1430   * Creates a matrix from a vector scaling1431   * This is equivalent to (but much faster than):1432   *1433   *     mat3.identity(dest);1434   *     mat3.scale(dest, dest, vec);1435   *1436   * @param {mat3} out mat3 receiving operation result1437   * @param {ReadonlyVec2} v Scaling vector1438   * @returns {mat3} out1439   */1440  function fromScaling$2(out, v) {1441    out[0] = v[0];1442    out[1] = 0;1443    out[2] = 0;1444    out[3] = 0;1445    out[4] = v[1];1446    out[5] = 0;1447    out[6] = 0;1448    out[7] = 0;1449    out[8] = 1;1450    return out;1451  }1452  /**1453   * Copies the values from a mat2d into a mat31454   *1455   * @param {mat3} out the receiving matrix1456   * @param {ReadonlyMat2d} a the matrix to copy1457   * @returns {mat3} out1458   **/1459  function fromMat2d(out, a) {1460    out[0] = a[0];1461    out[1] = a[1];1462    out[2] = 0;1463    out[3] = a[2];1464    out[4] = a[3];1465    out[5] = 0;1466    out[6] = a[4];1467    out[7] = a[5];1468    out[8] = 1;1469    return out;1470  }1471  /**1472   * Calculates a 3x3 matrix from the given quaternion1473   *1474   * @param {mat3} out mat3 receiving operation result1475   * @param {ReadonlyQuat} q Quaternion to create matrix from1476   *1477   * @returns {mat3} out1478   */1479  function fromQuat(out, q) {1480    var x = q[0],1481        y = q[1],1482        z = q[2],1483        w = q[3];1484    var x2 = x + x;1485    var y2 = y + y;1486    var z2 = z + z;1487    var xx = x * x2;1488    var yx = y * x2;1489    var yy = y * y2;1490    var zx = z * x2;1491    var zy = z * y2;1492    var zz = z * z2;1493    var wx = w * x2;1494    var wy = w * y2;1495    var wz = w * z2;1496    out[0] = 1 - yy - zz;1497    out[3] = yx - wz;1498    out[6] = zx + wy;1499    out[1] = yx + wz;1500    out[4] = 1 - xx - zz;1501    out[7] = zy - wx;1502    out[2] = zx - wy;1503    out[5] = zy + wx;1504    out[8] = 1 - xx - yy;1505    return out;1506  }1507  /**1508   * Calculates a 3x3 normal matrix (transpose inverse) from the 4x4 matrix1509   *1510   * @param {mat3} out mat3 receiving operation result1511   * @param {ReadonlyMat4} a Mat4 to derive the normal matrix from1512   *1513   * @returns {mat3} out1514   */1515  function normalFromMat4(out, a) {1516    var a00 = a[0],1517        a01 = a[1],1518        a02 = a[2],1519        a03 = a[3];1520    var a10 = a[4],1521        a11 = a[5],1522        a12 = a[6],1523        a13 = a[7];1524    var a20 = a[8],1525        a21 = a[9],1526        a22 = a[10],1527        a23 = a[11];1528    var a30 = a[12],1529        a31 = a[13],1530        a32 = a[14],1531        a33 = a[15];1532    var b00 = a00 * a11 - a01 * a10;1533    var b01 = a00 * a12 - a02 * a10;1534    var b02 = a00 * a13 - a03 * a10;1535    var b03 = a01 * a12 - a02 * a11;1536    var b04 = a01 * a13 - a03 * a11;1537    var b05 = a02 * a13 - a03 * a12;1538    var b06 = a20 * a31 - a21 * a30;1539    var b07 = a20 * a32 - a22 * a30;1540    var b08 = a20 * a33 - a23 * a30;1541    var b09 = a21 * a32 - a22 * a31;1542    var b10 = a21 * a33 - a23 * a31;1543    var b11 = a22 * a33 - a23 * a32; // Calculate the determinant1544    var det = b00 * b11 - b01 * b10 + b02 * b09 + b03 * b08 - b04 * b07 + b05 * b06;1545    if (!det) {1546      return null;1547    }1548    det = 1.0 / det;1549    out[0] = (a11 * b11 - a12 * b10 + a13 * b09) * det;1550    out[1] = (a12 * b08 - a10 * b11 - a13 * b07) * det;1551    out[2] = (a10 * b10 - a11 * b08 + a13 * b06) * det;1552    out[3] = (a02 * b10 - a01 * b11 - a03 * b09) * det;1553    out[4] = (a00 * b11 - a02 * b08 + a03 * b07) * det;1554    out[5] = (a01 * b08 - a00 * b10 - a03 * b06) * det;1555    out[6] = (a31 * b05 - a32 * b04 + a33 * b03) * det;1556    out[7] = (a32 * b02 - a30 * b05 - a33 * b01) * det;1557    out[8] = (a30 * b04 - a31 * b02 + a33 * b00) * det;1558    return out;1559  }1560  /**1561   * Generates a 2D projection matrix with the given bounds1562   *1563   * @param {mat3} out mat3 frustum matrix will be written into1564   * @param {number} width Width of your gl context1565   * @param {number} height Height of gl context1566   * @returns {mat3} out1567   */1568  function projection(out, width, height) {1569    out[0] = 2 / width;1570    out[1] = 0;1571    out[2] = 0;1572    out[3] = 0;1573    out[4] = -2 / height;1574    out[5] = 0;1575    out[6] = -1;1576    out[7] = 1;1577    out[8] = 1;1578    return out;1579  }1580  /**1581   * Returns a string representation of a mat31582   *1583   * @param {ReadonlyMat3} a matrix to represent as a string1584   * @returns {String} string representation of the matrix1585   */1586  function str$2(a) {1587    return "mat3(" + a[0] + ", " + a[1] + ", " + a[2] + ", " + a[3] + ", " + a[4] + ", " + a[5] + ", " + a[6] + ", " + a[7] + ", " + a[8] + ")";1588  }1589  /**1590   * Returns Frobenius norm of a mat31591   *1592   * @param {ReadonlyMat3} a the matrix to calculate Frobenius norm of1593   * @returns {Number} Frobenius norm1594   */1595  function frob$2(a) {1596    return Math.hypot(a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7], a[8]);1597  }1598  /**1599   * Adds two mat3's1600   *1601   * @param {mat3} out the receiving matrix1602   * @param {ReadonlyMat3} a the first operand1603   * @param {ReadonlyMat3} b the second operand1604   * @returns {mat3} out1605   */1606  function add$2(out, a, b) {1607    out[0] = a[0] + b[0];1608    out[1] = a[1] + b[1];1609    out[2] = a[2] + b[2];1610    out[3] = a[3] + b[3];1611    out[4] = a[4] + b[4];1612    out[5] = a[5] + b[5];1613    out[6] = a[6] + b[6];1614    out[7] = a[7] + b[7];1615    out[8] = a[8] + b[8];1616    return out;1617  }1618  /**1619   * Subtracts matrix b from matrix a1620   *1621   * @param {mat3} out the receiving matrix1622   * @param {ReadonlyMat3} a the first operand1623   * @param {ReadonlyMat3} b the second operand1624   * @returns {mat3} out1625   */1626  function subtract$2(out, a, b) {1627    out[0] = a[0] - b[0];1628    out[1] = a[1] - b[1];1629    out[2] = a[2] - b[2];1630    out[3] = a[3] - b[3];1631    out[4] = a[4] - b[4];1632    out[5] = a[5] - b[5];1633    out[6] = a[6] - b[6];1634    out[7] = a[7] - b[7];1635    out[8] = a[8] - b[8];1636    return out;1637  }1638  /**1639   * Multiply each element of the matrix by a scalar.1640   *1641   * @param {mat3} out the receiving matrix1642   * @param {ReadonlyMat3} a the matrix to scale1643   * @param {Number} b amount to scale the matrix's elements by1644   * @returns {mat3} out1645   */1646  function multiplyScalar$2(out, a, b) {1647    out[0] = a[0] * b;1648    out[1] = a[1] * b;1649    out[2] = a[2] * b;1650    out[3] = a[3] * b;1651    out[4] = a[4] * b;1652    out[5] = a[5] * b;1653    out[6] = a[6] * b;1654    out[7] = a[7] * b;1655    out[8] = a[8] * b;1656    return out;1657  }1658  /**1659   * Adds two mat3's after multiplying each element of the second operand by a scalar value.1660   *1661   * @param {mat3} out the receiving vector1662   * @param {ReadonlyMat3} a the first operand1663   * @param {ReadonlyMat3} b the second operand1664   * @param {Number} scale the amount to scale b's elements by before adding1665   * @returns {mat3} out1666   */1667  function multiplyScalarAndAdd$2(out, a, b, scale) {1668    out[0] = a[0] + b[0] * scale;1669    out[1] = a[1] + b[1] * scale;1670    out[2] = a[2] + b[2] * scale;1671    out[3] = a[3] + b[3] * scale;1672    out[4] = a[4] + b[4] * scale;1673    out[5] = a[5] + b[5] * scale;1674    out[6] = a[6] + b[6] * scale;1675    out[7] = a[7] + b[7] * scale;1676    out[8] = a[8] + b[8] * scale;1677    return out;1678  }1679  /**1680   * Returns whether or not the matrices have exactly the same elements in the same position (when compared with ===)1681   *1682   * @param {ReadonlyMat3} a The first matrix.1683   * @param {ReadonlyMat3} b The second matrix.1684   * @returns {Boolean} True if the matrices are equal, false otherwise.1685   */1686  function exactEquals$2(a, b) {1687    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];1688  }1689  /**1690   * Returns whether or not the matrices have approximately the same elements in the same position.1691   *1692   * @param {ReadonlyMat3} a The first matrix.1693   * @param {ReadonlyMat3} b The second matrix.1694   * @returns {Boolean} True if the matrices are equal, false otherwise.1695   */1696  function equals$3(a, b) {1697    var a0 = a[0],1698        a1 = a[1],1699        a2 = a[2],1700        a3 = a[3],1701        a4 = a[4],1702        a5 = a[5],1703        a6 = a[6],1704        a7 = a[7],1705        a8 = a[8];1706    var b0 = b[0],1707        b1 = b[1],1708        b2 = b[2],1709        b3 = b[3],1710        b4 = b[4],1711        b5 = b[5],1712        b6 = b[6],1713        b7 = b[7],1714        b8 = b[8];1715    return Math.abs(a0 - b0) <= EPSILON * Math.max(1.0, Math.abs(a0), Math.abs(b0)) && Math.abs(a1 - b1) <= EPSILON * Math.max(1.0, Math.abs(a1), Math.abs(b1)) && Math.abs(a2 - b2) <= EPSILON * Math.max(1.0, Math.abs(a2), Math.abs(b2)) && Math.abs(a3 - b3) <= EPSILON * Math.max(1.0, Math.abs(a3), Math.abs(b3)) && Math.abs(a4 - b4) <= EPSILON * Math.max(1.0, Math.abs(a4), Math.abs(b4)) && Math.abs(a5 - b5) <= EPSILON * Math.max(1.0, Math.abs(a5), Math.abs(b5)) && Math.abs(a6 - b6) <= EPSILON * Math.max(1.0, Math.abs(a6), Math.abs(b6)) && Math.abs(a7 - b7) <= EPSILON * Math.max(1.0, Math.abs(a7), Math.abs(b7)) && Math.abs(a8 - b8) <= EPSILON * Math.max(1.0, Math.abs(a8), Math.abs(b8));1716  }1717  /**1718   * Alias for {@link mat3.multiply}1719   * @function1720   */1721  var mul$2 = multiply$2;1722  /**1723   * Alias for {@link mat3.subtract}1724   * @function1725   */1726  var sub$2 = subtract$2;1727  var mat3 = /*#__PURE__*/Object.freeze({1728    __proto__: null,1729    create: create$2,1730    fromMat4: fromMat4,1731    clone: clone$2,1732    copy: copy$2,1733    fromValues: fromValues$2,1734    set: set$2,1735    identity: identity$2,1736    transpose: transpose$1,1737    invert: invert$2,1738    adjoint: adjoint$1,1739    determinant: determinant$2,1740    multiply: multiply$2,1741    translate: translate$1,1742    rotate: rotate$2,1743    scale: scale$2,1744    fromTranslation: fromTranslation$1,1745    fromRotation: fromRotation$2,1746    fromScaling: fromScaling$2,1747    fromMat2d: fromMat2d,1748    fromQuat: fromQuat,1749    normalFromMat4: normalFromMat4,1750    projection: projection,1751    str: str$2,1752    frob: frob$2,1753    add: add$2,1754    subtract: subtract$2,1755    multiplyScalar: multiplyScalar$2,1756    multiplyScalarAndAdd: multiplyScalarAndAdd$2,1757    exactEquals: exactEquals$2,1758    equals: equals$3,1759    mul: mul$2,1760    sub: sub$21761  });1762  /**1763   * 4x4 Matrix<br>Format: column-major, when typed out it looks like row-major<br>The matrices are being post multiplied.1764   * @module mat41765   */1766  /**1767   * Creates a new identity mat41768   *1769   * @returns {mat4} a new 4x4 matrix1770   */1771  function create$3() {1772    var out = new ARRAY_TYPE(16);1773    if (ARRAY_TYPE != Float32Array) {1774      out[1] = 0;1775      out[2] = 0;1776      out[3] = 0;1777      out[4] = 0;1778      out[6] = 0;1779      out[7] = 0;1780      out[8] = 0;1781      out[9] = 0;1782      out[11] = 0;1783      out[12] = 0;1784      out[13] = 0;1785      out[14] = 0;1786    }1787    out[0] = 1;1788    out[5] = 1;1789    out[10] = 1;1790    out[15] = 1;1791    return out;1792  }1793  /**1794   * Creates a new mat4 initialized with values from an existing matrix1795   *1796   * @param {ReadonlyMat4} a matrix to clone1797   * @returns {mat4} a new 4x4 matrix1798   */1799  function clone$3(a) {1800    var out = new ARRAY_TYPE(16);1801    out[0] = a[0];1802    out[1] = a[1];1803    out[2] = a[2];1804    out[3] = a[3];1805    out[4] = a[4];1806    out[5] = a[5];1807    out[6] = a[6];1808    out[7] = a[7];1809    out[8] = a[8];1810    out[9] = a[9];1811    out[10] = a[10];1812    out[11] = a[11];1813    out[12] = a[12];1814    out[13] = a[13];1815    out[14] = a[14];1816    out[15] = a[15];1817    return out;1818  }1819  /**1820   * Copy the values from one mat4 to another1821   *1822   * @param {mat4} out the receiving matrix1823   * @param {ReadonlyMat4} a the source matrix1824   * @returns {mat4} out1825   */1826  function copy$3(out, a) {1827    out[0] = a[0];1828    out[1] = a[1];1829    out[2] = a[2];1830    out[3] = a[3];1831    out[4] = a[4];1832    out[5] = a[5];1833    out[6] = a[6];1834    out[7] = a[7];1835    out[8] = a[8];1836    out[9] = a[9];1837    out[10] = a[10];1838    out[11] = a[11];1839    out[12] = a[12];1840    out[13] = a[13];1841    out[14] = a[14];1842    out[15] = a[15];1843    return out;1844  }1845  /**1846   * Create a new mat4 with the given values1847   *1848   * @param {Number} m00 Component in column 0, row 0 position (index 0)1849   * @param {Number} m01 Component in column 0, row 1 position (index 1)1850   * @param {Number} m02 Component in column 0, row 2 position (index 2)1851   * @param {Number} m03 Component in column 0, row 3 position (index 3)1852   * @param {Number} m10 Component in column 1, row 0 position (index 4)1853   * @param {Number} m11 Component in column 1, row 1 position (index 5)1854   * @param {Number} m12 Component in column 1, row 2 position (index 6)1855   * @param {Number} m13 Component in column 1, row 3 position (index 7)1856   * @param {Number} m20 Component in column 2, row 0 position (index 8)1857   * @param {Number} m21 Component in column 2, row 1 position (index 9)1858   * @param {Number} m22 Component in column 2, row 2 position (index 10)1859   * @param {Number} m23 Component in column 2, row 3 position (index 11)1860   * @param {Number} m30 Component in column 3, row 0 position (index 12)1861   * @param {Number} m31 Component in column 3, row 1 position (index 13)1862   * @param {Number} m32 Component in column 3, row 2 position (index 14)1863   * @param {Number} m33 Component in column 3, row 3 position (index 15)1864   * @returns {mat4} A new mat41865   */1866  function fromValues$3(m00, m01, m02, m03, m10, m11, m12, m13, m20, m21, m22, m23, m30, m31, m32, m33) {1867    var out = new ARRAY_TYPE(16);1868    out[0] = m00;1869    out[1] = m01;1870    out[2] = m02;1871    out[3] = m03;1872    out[4] = m10;1873    out[5] = m11;1874    out[6] = m12;1875    out[7] = m13;1876    out[8] = m20;1877    out[9] = m21;1878    out[10] = m22;1879    out[11] = m23;1880    out[12] = m30;1881    out[13] = m31;1882    out[14] = m32;1883    out[15] = m33;1884    return out;1885  }1886  /**1887   * Set the components of a mat4 to the given values1888   *1889   * @param {mat4} out the receiving matrix1890   * @param {Number} m00 Component in column 0, row 0 position (index 0)1891   * @param {Number} m01 Component in column 0, row 1 position (index 1)1892   * @param {Number} m02 Component in column 0, row 2 position (index 2)1893   * @param {Number} m03 Component in column 0, row 3 position (index 3)1894   * @param {Number} m10 Component in column 1, row 0 position (index 4)1895   * @param {Number} m11 Component in column 1, row 1 position (index 5)1896   * @param {Number} m12 Component in column 1, row 2 position (index 6)1897   * @param {Number} m13 Component in column 1, row 3 position (index 7)1898   * @param {Number} m20 Component in column 2, row 0 position (index 8)1899   * @param {Number} m21 Component in column 2, row 1 position (index 9)1900   * @param {Number} m22 Component in column 2, row 2 position (index 10)1901   * @param {Number} m23 Component in column 2, row 3 position (index 11)1902   * @param {Number} m30 Component in column 3, row 0 position (index 12)1903   * @param {Number} m31 Component in column 3, row 1 position (index 13)1904   * @param {Number} m32 Component in column 3, row 2 position (index 14)1905   * @param {Number} m33 Component in column 3, row 3 position (index 15)1906   * @returns {mat4} out1907   */1908  function set$3(out, m00, m01, m02, m03, m10, m11, m12, m13, m20, m21, m22, m23, m30, m31, m32, m33) {1909    out[0] = m00;1910    out[1] = m01;1911    out[2] = m02;1912    out[3] = m03;1913    out[4] = m10;1914    out[5] = m11;1915    out[6] = m12;1916    out[7] = m13;1917    out[8] = m20;1918    out[9] = m21;1919    out[10] = m22;1920    out[11] = m23;1921    out[12] = m30;1922    out[13] = m31;1923    out[14] = m32;1924    out[15] = m33;1925    return out;1926  }1927  /**1928   * Set a mat4 to the identity matrix1929   *1930   * @param {mat4} out the receiving matrix1931   * @returns {mat4} out1932   */1933  function identity$3(out) {1934    out[0] = 1;1935    out[1] = 0;1936    out[2] = 0;1937    out[3] = 0;1938    out[4] = 0;1939    out[5] = 1;1940    out[6] = 0;1941    out[7] = 0;1942    out[8] = 0;1943    out[9] = 0;1944    out[10] = 1;1945    out[11] = 0;1946    out[12] = 0;1947    out[13] = 0;1948    out[14] = 0;1949    out[15] = 1;1950    return out;1951  }1952  /**1953   * Transpose the values of a mat41954   *1955   * @param {mat4} out the receiving matrix1956   * @param {ReadonlyMat4} a the source matrix1957   * @returns {mat4} out1958   */1959  function transpose$2(out, a) {1960    // If we are transposing ourselves we can skip a few steps but have to cache some values1961    if (out === a) {1962      var a01 = a[1],1963          a02 = a[2],1964          a03 = a[3];1965      var a12 = a[6],1966          a13 = a[7];1967      var a23 = a[11];1968      out[1] = a[4];1969      out[2] = a[8];1970      out[3] = a[12];1971      out[4] = a01;1972      out[6] = a[9];1973      out[7] = a[13];1974      out[8] = a02;1975      out[9] = a12;1976      out[11] = a[14];1977      out[12] = a03;1978      out[13] = a13;1979      out[14] = a23;1980    } else {1981      out[0] = a[0];1982      out[1] = a[4];1983      out[2] = a[8];1984      out[3] = a[12];1985      out[4] = a[1];1986      out[5] = a[5];1987      out[6] = a[9];1988      out[7] = a[13];1989      out[8] = a[2];1990      out[9] = a[6];1991      out[10] = a[10];1992      out[11] = a[14];1993      out[12] = a[3];1994      out[13] = a[7];1995      out[14] = a[11];1996      out[15] = a[15];1997    }1998    return out;1999  }2000  /**2001   * Inverts a mat42002   *2003   * @param {mat4} out the receiving matrix2004   * @param {ReadonlyMat4} a the source matrix2005   * @returns {mat4} out2006   */2007  function invert$3(out, a) {2008    var a00 = a[0],2009        a01 = a[1],2010        a02 = a[2],2011        a03 = a[3];2012    var a10 = a[4],2013        a11 = a[5],2014        a12 = a[6],2015        a13 = a[7];2016    var a20 = a[8],2017        a21 = a[9],2018        a22 = a[10],2019        a23 = a[11];2020    var a30 = a[12],2021        a31 = a[13],2022        a32 = a[14],2023        a33 = a[15];2024    var b00 = a00 * a11 - a01 * a10;2025    var b01 = a00 * a12 - a02 * a10;2026    var b02 = a00 * a13 - a03 * a10;2027    var b03 = a01 * a12 - a02 * a11;2028    var b04 = a01 * a13 - a03 * a11;2029    var b05 = a02 * a13 - a03 * a12;2030    var b06 = a20 * a31 - a21 * a30;2031    var b07 = a20 * a32 - a22 * a30;2032    var b08 = a20 * a33 - a23 * a30;2033    var b09 = a21 * a32 - a22 * a31;2034    var b10 = a21 * a33 - a23 * a31;2035    var b11 = a22 * a33 - a23 * a32; // Calculate the determinant2036    var det = b00 * b11 - b01 * b10 + b02 * b09 + b03 * b08 - b04 * b07 + b05 * b06;2037    if (!det) {2038      return null;2039    }2040    det = 1.0 / det;2041    out[0] = (a11 * b11 - a12 * b10 + a13 * b09) * det;2042    out[1] = (a02 * b10 - a01 * b11 - a03 * b09) * det;2043    out[2] = (a31 * b05 - a32 * b04 + a33 * b03) * det;2044    out[3] = (a22 * b04 - a21 * b05 - a23 * b03) * det;2045    out[4] = (a12 * b08 - a10 * b11 - a13 * b07) * det;2046    out[5] = (a00 * b11 - a02 * b08 + a03 * b07) * det;2047    out[6] = (a32 * b02 - a30 * b05 - a33 * b01) * det;2048    out[7] = (a20 * b05 - a22 * b02 + a23 * b01) * det;2049    out[8] = (a10 * b10 - a11 * b08 + a13 * b06) * det;2050    out[9] = (a01 * b08 - a00 * b10 - a03 * b06) * det;2051    out[10] = (a30 * b04 - a31 * b02 + a33 * b00) * det;2052    out[11] = (a21 * b02 - a20 * b04 - a23 * b00) * det;2053    out[12] = (a11 * b07 - a10 * b09 - a12 * b06) * det;2054    out[13] = (a00 * b09 - a01 * b07 + a02 * b06) * det;2055    out[14] = (a31 * b01 - a30 * b03 - a32 * b00) * det;2056    out[15] = (a20 * b03 - a21 * b01 + a22 * b00) * det;2057    return out;2058  }2059  /**2060   * Calculates the adjugate of a mat42061   *2062   * @param {mat4} out the receiving matrix2063   * @param {ReadonlyMat4} a the source matrix2064   * @returns {mat4} out2065   */2066  function adjoint$2(out, a) {2067    var a00 = a[0],2068        a01 = a[1],2069        a02 = a[2],2070        a03 = a[3];2071    var a10 = a[4],2072        a11 = a[5],2073        a12 = a[6],2074        a13 = a[7];2075    var a20 = a[8],2076        a21 = a[9],2077        a22 = a[10],2078        a23 = a[11];2079    var a30 = a[12],2080        a31 = a[13],2081        a32 = a[14],2082        a33 = a[15];2083    out[0] = a11 * (a22 * a33 - a23 * a32) - a21 * (a12 * a33 - a13 * a32) + a31 * (a12 * a23 - a13 * a22);2084    out[1] = -(a01 * (a22 * a33 - a23 * a32) - a21 * (a02 * a33 - a03 * a32) + a31 * (a02 * a23 - a03 * a22));2085    out[2] = a01 * (a12 * a33 - a13 * a32) - a11 * (a02 * a33 - a03 * a32) + a31 * (a02 * a13 - a03 * a12);2086    out[3] = -(a01 * (a12 * a23 - a13 * a22) - a11 * (a02 * a23 - a03 * a22) + a21 * (a02 * a13 - a03 * a12));2087    out[4] = -(a10 * (a22 * a33 - a23 * a32) - a20 * (a12 * a33 - a13 * a32) + a30 * (a12 * a23 - a13 * a22));2088    out[5] = a00 * (a22 * a33 - a23 * a32) - a20 * (a02 * a33 - a03 * a32) + a30 * (a02 * a23 - a03 * a22);2089    out[6] = -(a00 * (a12 * a33 - a13 * a32) - a10 * (a02 * a33 - a03 * a32) + a30 * (a02 * a13 - a03 * a12));2090    out[7] = a00 * (a12 * a23 - a13 * a22) - a10 * (a02 * a23 - a03 * a22) + a20 * (a02 * a13 - a03 * a12);2091    out[8] = a10 * (a21 * a33 - a23 * a31) - a20 * (a11 * a33 - a13 * a31) + a30 * (a11 * a23 - a13 * a21);2092    out[9] = -(a00 * (a21 * a33 - a23 * a31) - a20 * (a01 * a33 - a03 * a31) + a30 * (a01 * a23 - a03 * a21));2093    out[10] = a00 * (a11 * a33 - a13 * a31) - a10 * (a01 * a33 - a03 * a31) + a30 * (a01 * a13 - a03 * a11);2094    out[11] = -(a00 * (a11 * a23 - a13 * a21) - a10 * (a01 * a23 - a03 * a21) + a20 * (a01 * a13 - a03 * a11));2095    out[12] = -(a10 * (a21 * a32 - a22 * a31) - a20 * (a11 * a32 - a12 * a31) + a30 * (a11 * a22 - a12 * a21));2096    out[13] = a00 * (a21 * a32 - a22 * a31) - a20 * (a01 * a32 - a02 * a31) + a30 * (a01 * a22 - a02 * a21);2097    out[14] = -(a00 * (a11 * a32 - a12 * a31) - a10 * (a01 * a32 - a02 * a31) + a30 * (a01 * a12 - a02 * a11));2098    out[15] = a00 * (a11 * a22 - a12 * a21) - a10 * (a01 * a22 - a02 * a21) + a20 * (a01 * a12 - a02 * a11);2099    return out;2100  }2101  /**2102   * Calculates the determinant of a mat42103   *2104   * @param {ReadonlyMat4} a the source matrix2105   * @returns {Number} determinant of a2106   */2107  function determinant$3(a) {2108    var a00 = a[0],2109        a01 = a[1],2110        a02 = a[2],2111        a03 = a[3];2112    var a10 = a[4],2113        a11 = a[5],2114        a12 = a[6],2115        a13 = a[7];2116    var a20 = a[8],2117        a21 = a[9],2118        a22 = a[10],2119        a23 = a[11];2120    var a30 = a[12],2121        a31 = a[13],2122        a32 = a[14],2123        a33 = a[15];2124    var b00 = a00 * a11 - a01 * a10;2125    var b01 = a00 * a12 - a02 * a10;2126    var b02 = a00 * a13 - a03 * a10;2127    var b03 = a01 * a12 - a02 * a11;2128    var b04 = a01 * a13 - a03 * a11;2129    var b05 = a02 * a13 - a03 * a12;2130    var b06 = a20 * a31 - a21 * a30;2131    var b07 = a20 * a32 - a22 * a30;2132    var b08 = a20 * a33 - a23 * a30;2133    var b09 = a21 * a32 - a22 * a31;2134    var b10 = a21 * a33 - a23 * a31;2135    var b11 = a22 * a33 - a23 * a32; // Calculate the determinant2136    return b00 * b11 - b01 * b10 + b02 * b09 + b03 * b08 - b04 * b07 + b05 * b06;2137  }2138  /**2139   * Multiplies two mat4s2140   *2141   * @param {mat4} out the receiving matrix2142   * @param {ReadonlyMat4} a the first operand2143   * @param {ReadonlyMat4} b the second operand2144   * @returns {mat4} out2145   */2146  function multiply$3(out, a, b) {2147    var a00 = a[0],2148        a01 = a[1],2149        a02 = a[2],2150        a03 = a[3];2151    var a10 = a[4],2152        a11 = a[5],2153        a12 = a[6],2154        a13 = a[7];2155    var a20 = a[8],2156        a21 = a[9],2157        a22 = a[10],2158        a23 = a[11];2159    var a30 = a[12],2160        a31 = a[13],2161        a32 = a[14],2162        a33 = a[15]; // Cache only the current line of the second matrix2163    var b0 = b[0],2164        b1 = b[1],2165        b2 = b[2],2166        b3 = b[3];2167    out[0] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30;2168    out[1] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31;2169    out[2] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32;2170    out[3] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33;2171    b0 = b[4];2172    b1 = b[5];2173    b2 = b[6];2174    b3 = b[7];2175    out[4] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30;2176    out[5] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31;2177    out[6] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32;2178    out[7] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33;2179    b0 = b[8];2180    b1 = b[9];2181    b2 = b[10];2182    b3 = b[11];2183    out[8] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30;2184    out[9] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31;2185    out[10] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32;2186    out[11] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33;2187    b0 = b[12];2188    b1 = b[13];2189    b2 = b[14];2190    b3 = b[15];2191    out[12] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30;2192    out[13] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31;2193    out[14] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32;2194    out[15] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33;2195    return out;2196  }2197  /**2198   * Translate a mat4 by the given vector2199   *2200   * @param {mat4} out the receiving matrix2201   * @param {ReadonlyMat4} a the matrix to translate2202   * @param {ReadonlyVec3} v vector to translate by2203   * @returns {mat4} out2204   */2205  function translate$2(out, a, v) {2206    var x = v[0],2207        y = v[1],2208        z = v[2];2209    var a00, a01, a02, a03;2210    var a10, a11, a12, a13;2211    var a20, a21, a22, a23;2212    if (a === out) {2213      out[12] = a[0] * x + a[4] * y + a[8] * z + a[12];2214      out[13] = a[1] * x + a[5] * y + a[9] * z + a[13];2215      out[14] = a[2] * x + a[6] * y + a[10] * z + a[14];2216      out[15] = a[3] * x + a[7] * y + a[11] * z + a[15];2217    } else {2218      a00 = a[0];2219      a01 = a[1];2220      a02 = a[2];2221      a03 = a[3];2222      a10 = a[4];2223      a11 = a[5];2224      a12 = a[6];2225      a13 = a[7];2226      a20 = a[8];2227      a21 = a[9];2228      a22 = a[10];2229      a23 = a[11];2230      out[0] = a00;2231      out[1] = a01;2232      out[2] = a02;2233      out[3] = a03;2234      out[4] = a10;2235      out[5] = a11;2236      out[6] = a12;2237      out[7] = a13;2238      out[8] = a20;2239      out[9] = a21;2240      out[10] = a22;2241      out[11] = a23;2242      out[12] = a00 * x + a10 * y + a20 * z + a[12];2243      out[13] = a01 * x + a11 * y + a21 * z + a[13];2244      out[14] = a02 * x + a12 * y + a22 * z + a[14];2245      out[15] = a03 * x + a13 * y + a23 * z + a[15];2246    }2247    return out;2248  }2249  /**2250   * Scales the mat4 by the dimensions in the given vec3 not using vectorization2251   *2252   * @param {mat4} out the receiving matrix2253   * @param {ReadonlyMat4} a the matrix to scale2254   * @param {ReadonlyVec3} v the vec3 to scale the matrix by2255   * @returns {mat4} out2256   **/2257  function scale$3(out, a, v) {2258    var x = v[0],2259        y = v[1],2260        z = v[2];2261    out[0] = a[0] * x;2262    out[1] = a[1] * x;2263    out[2] = a[2] * x;2264    out[3] = a[3] * x;2265    out[4] = a[4] * y;2266    out[5] = a[5] * y;2267    out[6] = a[6] * y;2268    out[7] = a[7] * y;2269    out[8] = a[8] * z;2270    out[9] = a[9] * z;2271    out[10] = a[10] * z;2272    out[11] = a[11] * z;2273    out[12] = a[12];2274    out[13] = a[13];2275    out[14] = a[14];2276    out[15] = a[15];2277    return out;2278  }2279  /**2280   * Rotates a mat4 by the given angle around the given axis2281   *2282   * @param {mat4} out the receiving matrix2283   * @param {ReadonlyMat4} a the matrix to rotate2284   * @param {Number} rad the angle to rotate the matrix by2285   * @param {ReadonlyVec3} axis the axis to rotate around2286   * @returns {mat4} out2287   */2288  function rotate$3(out, a, rad, axis) {2289    var x = axis[0],2290        y = axis[1],2291        z = axis[2];2292    var len = Math.hypot(x, y, z);2293    var s, c, t;2294    var a00, a01, a02, a03;2295    var a10, a11, a12, a13;2296    var a20, a21, a22, a23;2297    var b00, b01, b02;2298    var b10, b11, b12;2299    var b20, b21, b22;2300    if (len < EPSILON) {2301      return null;2302    }2303    len = 1 / len;2304    x *= len;2305    y *= len;2306    z *= len;2307    s = Math.sin(rad);2308    c = Math.cos(rad);2309    t = 1 - c;2310    a00 = a[0];2311    a01 = a[1];2312    a02 = a[2];2313    a03 = a[3];2314    a10 = a[4];2315    a11 = a[5];2316    a12 = a[6];2317    a13 = a[7];2318    a20 = a[8];2319    a21 = a[9];2320    a22 = a[10];2321    a23 = a[11]; // Construct the elements of the rotation matrix2322    b00 = x * x * t + c;2323    b01 = y * x * t + z * s;2324    b02 = z * x * t - y * s;2325    b10 = x * y * t - z * s;2326    b11 = y * y * t + c;2327    b12 = z * y * t + x * s;2328    b20 = x * z * t + y * s;2329    b21 = y * z * t - x * s;2330    b22 = z * z * t + c; // Perform rotation-specific matrix multiplication2331    out[0] = a00 * b00 + a10 * b01 + a20 * b02;2332    out[1] = a01 * b00 + a11 * b01 + a21 * b02;2333    out[2] = a02 * b00 + a12 * b01 + a22 * b02;2334    out[3] = a03 * b00 + a13 * b01 + a23 * b02;2335    out[4] = a00 * b10 + a10 * b11 + a20 * b12;2336    out[5] = a01 * b10 + a11 * b11 + a21 * b12;2337    out[6] = a02 * b10 + a12 * b11 + a22 * b12;2338    out[7] = a03 * b10 + a13 * b11 + a23 * b12;2339    out[8] = a00 * b20 + a10 * b21 + a20 * b22;2340    out[9] = a01 * b20 + a11 * b21 + a21 * b22;2341    out[10] = a02 * b20 + a12 * b21 + a22 * b22;2342    out[11] = a03 * b20 + a13 * b21 + a23 * b22;2343    if (a !== out) {2344      // If the source and destination differ, copy the unchanged last row2345      out[12] = a[12];2346      out[13] = a[13];2347      out[14] = a[14];2348      out[15] = a[15];2349    }2350    return out;2351  }2352  /**2353   * Rotates a matrix by the given angle around the X axis2354   *2355   * @param {mat4} out the receiving matrix2356   * @param {ReadonlyMat4} a the matrix to rotate2357   * @param {Number} rad the angle to rotate the matrix by2358   * @returns {mat4} out2359   */2360  function rotateX(out, a, rad) {2361    var s = Math.sin(rad);2362    var c = Math.cos(rad);2363    var a10 = a[4];2364    var a11 = a[5];2365    var a12 = a[6];2366    var a13 = a[7];2367    var a20 = a[8];2368    var a21 = a[9];2369    var a22 = a[10];2370    var a23 = a[11];2371    if (a !== out) {2372      // If the source and destination differ, copy the unchanged rows2373      out[0] = a[0];2374      out[1] = a[1];2375      out[2] = a[2];2376      out[3] = a[3];2377      out[12] = a[12];2378      out[13] = a[13];2379      out[14] = a[14];2380      out[15] = a[15];2381    } // Perform axis-specific matrix multiplication2382    out[4] = a10 * c + a20 * s;2383    out[5] = a11 * c + a21 * s;2384    out[6] = a12 * c + a22 * s;2385    out[7] = a13 * c + a23 * s;2386    out[8] = a20 * c - a10 * s;2387    out[9] = a21 * c - a11 * s;2388    out[10] = a22 * c - a12 * s;2389    out[11] = a23 * c - a13 * s;2390    return out;2391  }2392  /**2393   * Rotates a matrix by the given angle around the Y axis2394   *2395   * @param {mat4} out the receiving matrix2396   * @param {ReadonlyMat4} a the matrix to rotate2397   * @param {Number} rad the angle to rotate the matrix by2398   * @returns {mat4} out2399   */2400  function rotateY(out, a, rad) {2401    var s = Math.sin(rad);2402    var c = Math.cos(rad);2403    var a00 = a[0];2404    var a01 = a[1];2405    var a02 = a[2];2406    var a03 = a[3];2407    var a20 = a[8];2408    var a21 = a[9];2409    var a22 = a[10];2410    var a23 = a[11];2411    if (a !== out) {2412      // If the source and destination differ, copy the unchanged rows2413      out[4] = a[4];2414      out[5] = a[5];2415      out[6] = a[6];2416      out[7] = a[7];2417      out[12] = a[12];2418      out[13] = a[13];2419      out[14] = a[14];2420      out[15] = a[15];2421    } // Perform axis-specific matrix multiplication2422    out[0] = a00 * c - a20 * s;2423    out[1] = a01 * c - a21 * s;2424    out[2] = a02 * c - a22 * s;2425    out[3] = a03 * c - a23 * s;2426    out[8] = a00 * s + a20 * c;2427    out[9] = a01 * s + a21 * c;2428    out[10] = a02 * s + a22 * c;2429    out[11] = a03 * s + a23 * c;2430    return out;2431  }2432  /**2433   * Rotates a matrix by the given angle around the Z axis2434   *2435   * @param {mat4} out the receiving matrix2436   * @param {ReadonlyMat4} a the matrix to rotate2437   * @param {Number} rad the angle to rotate the matrix by2438   * @returns {mat4} out2439   */2440  function rotateZ(out, a, rad) {2441    var s = Math.sin(rad);2442    var c = Math.cos(rad);2443    var a00 = a[0];2444    var a01 = a[1];2445    var a02 = a[2];2446    var a03 = a[3];2447    var a10 = a[4];2448    var a11 = a[5];2449    var a12 = a[6];2450    var a13 = a[7];2451    if (a !== out) {2452      // If the source and destination differ, copy the unchanged last row2453      out[8] = a[8];2454      out[9] = a[9];2455      out[10] = a[10];2456      out[11] = a[11];2457      out[12] = a[12];2458      out[13] = a[13];2459      out[14] = a[14];2460      out[15] = a[15];2461    } // Perform axis-specific matrix multiplication2462    out[0] = a00 * c + a10 * s;2463    out[1] = a01 * c + a11 * s;2464    out[2] = a02 * c + a12 * s;2465    out[3] = a03 * c + a13 * s;2466    out[4] = a10 * c - a00 * s;2467    out[5] = a11 * c - a01 * s;2468    out[6] = a12 * c - a02 * s;2469    out[7] = a13 * c - a03 * s;2470    return out;2471  }2472  /**2473   * Creates a matrix from a vector translation2474   * This is equivalent to (but much faster than):2475   *2476   *     mat4.identity(dest);2477   *     mat4.translate(dest, dest, vec);2478   *2479   * @param {mat4} out mat4 receiving operation result2480   * @param {ReadonlyVec3} v Translation vector2481   * @returns {mat4} out2482   */2483  function fromTranslation$2(out, v) {2484    out[0] = 1;2485    out[1] = 0;2486    out[2] = 0;2487    out[3] = 0;2488    out[4] = 0;2489    out[5] = 1;2490    out[6] = 0;2491    out[7] = 0;2492    out[8] = 0;2493    out[9] = 0;2494    out[10] = 1;2495    out[11] = 0;2496    out[12] = v[0];2497    out[13] = v[1];2498    out[14] = v[2];2499    out[15] = 1;2500    return out;2501  }2502  /**2503   * Creates a matrix from a vector scaling2504   * This is equivalent to (but much faster than):2505   *2506   *     mat4.identity(dest);2507   *     mat4.scale(dest, dest, vec);2508   *2509   * @param {mat4} out mat4 receiving operation result2510   * @param {ReadonlyVec3} v Scaling vector2511   * @returns {mat4} out2512   */2513  function fromScaling$3(out, v) {2514    out[0] = v[0];2515    out[1] = 0;2516    out[2] = 0;2517    out[3] = 0;2518    out[4] = 0;2519    out[5] = v[1];2520    out[6] = 0;2521    out[7] = 0;2522    out[8] = 0;2523    out[9] = 0;2524    out[10] = v[2];2525    out[11] = 0;2526    out[12] = 0;2527    out[13] = 0;2528    out[14] = 0;2529    out[15] = 1;2530    return out;2531  }2532  /**2533   * Creates a matrix from a given angle around a given axis2534   * This is equivalent to (but much faster than):2535   *2536   *     mat4.identity(dest);2537   *     mat4.rotate(dest, dest, rad, axis);2538   *2539   * @param {mat4} out mat4 receiving operation result2540   * @param {Number} rad the angle to rotate the matrix by2541   * @param {ReadonlyVec3} axis the axis to rotate around2542   * @returns {mat4} out2543   */2544  function fromRotation$3(out, rad, axis) {2545    var x = axis[0],2546        y = axis[1],2547        z = axis[2];2548    var len = Math.hypot(x, y, z);2549    var s, c, t;2550    if (len < EPSILON) {2551      return null;2552    }2553    len = 1 / len;2554    x *= len;2555    y *= len;2556    z *= len;2557    s = Math.sin(rad);2558    c = Math.cos(rad);2559    t = 1 - c; // Perform rotation-specific matrix multiplication2560    out[0] = x * x * t + c;2561    out[1] = y * x * t + z * s;2562    out[2] = z * x * t - y * s;2563    out[3] = 0;2564    out[4] = x * y * t - z * s;2565    out[5] = y * y * t + c;2566    out[6] = z * y * t + x * s;2567    out[7] = 0;2568    out[8] = x * z * t + y * s;2569    out[9] = y * z * t - x * s;2570    out[10] = z * z * t + c;2571    out[11] = 0;2572    out[12] = 0;2573    out[13] = 0;2574    out[14] = 0;2575    out[15] = 1;2576    return out;2577  }2578  /**2579   * Creates a matrix from the given angle around the X axis2580   * This is equivalent to (but much faster than):2581   *2582   *     mat4.identity(dest);2583   *     mat4.rotateX(dest, dest, rad);2584   *2585   * @param {mat4} out mat4 receiving operation result2586   * @param {Number} rad the angle to rotate the matrix by2587   * @returns {mat4} out2588   */2589  function fromXRotation(out, rad) {2590    var s = Math.sin(rad);2591    var c = Math.cos(rad); // Perform axis-specific matrix multiplication2592    out[0] = 1;2593    out[1] = 0;2594    out[2] = 0;2595    out[3] = 0;2596    out[4] = 0;2597    out[5] = c;2598    out[6] = s;2599    out[7] = 0;2600    out[8] = 0;2601    out[9] = -s;2602    out[10] = c;2603    out[11] = 0;2604    out[12] = 0;2605    out[13] = 0;2606    out[14] = 0;2607    out[15] = 1;2608    return out;2609  }2610  /**2611   * Creates a matrix from the given angle around the Y axis2612   * This is equivalent to (but much faster than):2613   *2614   *     mat4.identity(dest);2615   *     mat4.rotateY(dest, dest, rad);2616   *2617   * @param {mat4} out mat4 receiving operation result2618   * @param {Number} rad the angle to rotate the matrix by2619   * @returns {mat4} out2620   */2621  function fromYRotation(out, rad) {2622    var s = Math.sin(rad);2623    var c = Math.cos(rad); // Perform axis-specific matrix multiplication2624    out[0] = c;2625    out[1] = 0;2626    out[2] = -s;2627    out[3] = 0;2628    out[4] = 0;2629    out[5] = 1;2630    out[6] = 0;2631    out[7] = 0;2632    out[8] = s;2633    out[9] = 0;2634    out[10] = c;2635    out[11] = 0;2636    out[12] = 0;2637    out[13] = 0;2638    out[14] = 0;2639    out[15] = 1;2640    return out;2641  }2642  /**2643   * Creates a matrix from the given angle around the Z axis2644   * This is equivalent to (but much faster than):2645   *2646   *     mat4.identity(dest);2647   *     mat4.rotateZ(dest, dest, rad);2648   *2649   * @param {mat4} out mat4 receiving operation result2650   * @param {Number} rad the angle to rotate the matrix by2651   * @returns {mat4} out2652   */2653  function fromZRotation(out, rad) {2654    var s = Math.sin(rad);2655    var c = Math.cos(rad); // Perform axis-specific matrix multiplication2656    out[0] = c;2657    out[1] = s;2658    out[2] = 0;2659    out[3] = 0;2660    out[4] = -s;2661    out[5] = c;2662    out[6] = 0;2663    out[7] = 0;2664    out[8] = 0;2665    out[9] = 0;2666    out[10] = 1;2667    out[11] = 0;2668    out[12] = 0;2669    out[13] = 0;2670    out[14] = 0;2671    out[15] = 1;2672    return out;2673  }2674  /**2675   * Creates a matrix from a quaternion rotation and vector translation2676   * This is equivalent to (but much faster than):2677   *2678   *     mat4.identity(dest);2679   *     mat4.translate(dest, vec);2680   *     let quatMat = mat4.create();2681   *     quat4.toMat4(quat, quatMat);2682   *     mat4.multiply(dest, quatMat);2683   *2684   * @param {mat4} out mat4 receiving operation result2685   * @param {quat4} q Rotation quaternion2686   * @param {ReadonlyVec3} v Translation vector2687   * @returns {mat4} out2688   */2689  function fromRotationTranslation(out, q, v) {2690    // Quaternion math2691    var x = q[0],2692        y = q[1],2693        z = q[2],2694        w = q[3];2695    var x2 = x + x;2696    var y2 = y + y;2697    var z2 = z + z;2698    var xx = x * x2;2699    var xy = x * y2;2700    var xz = x * z2;2701    var yy = y * y2;2702    var yz = y * z2;2703    var zz = z * z2;2704    var wx = w * x2;2705    var wy = w * y2;2706    var wz = w * z2;2707    out[0] = 1 - (yy + zz);2708    out[1] = xy + wz;2709    out[2] = xz - wy;2710    out[3] = 0;2711    out[4] = xy - wz;2712    out[5] = 1 - (xx + zz);2713    out[6] = yz + wx;2714    out[7] = 0;2715    out[8] = xz + wy;2716    out[9] = yz - wx;2717    out[10] = 1 - (xx + yy);2718    out[11] = 0;2719    out[12] = v[0];2720    out[13] = v[1];2721    out[14] = v[2];2722    out[15] = 1;2723    return out;2724  }2725  /**2726   * Creates a new mat4 from a dual quat.2727   *2728   * @param {mat4} out Matrix2729   * @param {ReadonlyQuat2} a Dual Quaternion2730   * @returns {mat4} mat4 receiving operation result2731   */2732  function fromQuat2(out, a) {2733    var translation = new ARRAY_TYPE(3);2734    var bx = -a[0],2735        by = -a[1],2736        bz = -a[2],2737        bw = a[3],2738        ax = a[4],2739        ay = a[5],2740        az = a[6],2741        aw = a[7];2742    var magnitude = bx * bx + by * by + bz * bz + bw * bw; //Only scale if it makes sense2743    if (magnitude > 0) {2744      translation[0] = (ax * bw + aw * bx + ay * bz - az * by) * 2 / magnitude;2745      translation[1] = (ay * bw + aw * by + az * bx - ax * bz) * 2 / magnitude;2746      translation[2] = (az * bw + aw * bz + ax * by - ay * bx) * 2 / magnitude;2747    } else {2748      translation[0] = (ax * bw + aw * bx + ay * bz - az * by) * 2;2749      translation[1] = (ay * bw + aw * by + az * bx - ax * bz) * 2;2750      translation[2] = (az * bw + aw * bz + ax * by - ay * bx) * 2;2751    }2752    fromRotationTranslation(out, a, translation);2753    return out;2754  }2755  /**2756   * Returns the translation vector component of a transformation2757   *  matrix. If a matrix is built with fromRotationTranslation,2758   *  the returned vector will be the same as the translation vector2759   *  originally supplied.2760   * @param  {vec3} out Vector to receive translation component2761   * @param  {ReadonlyMat4} mat Matrix to be decomposed (input)2762   * @return {vec3} out2763   */2764  function getTranslation(out, mat) {2765    out[0] = mat[12];2766    out[1] = mat[13];2767    out[2] = mat[14];2768    return out;2769  }2770  /**2771   * Returns the scaling factor component of a transformation2772   *  matrix. If a matrix is built with fromRotationTranslationScale2773   *  with a normalized Quaternion paramter, the returned vector will be2774   *  the same as the scaling vector2775   *  originally supplied.2776   * @param  {vec3} out Vector to receive scaling factor component2777   * @param  {ReadonlyMat4} mat Matrix to be decomposed (input)2778   * @return {vec3} out2779   */2780  function getScaling(out, mat) {2781    var m11 = mat[0];2782    var m12 = mat[1];2783    var m13 = mat[2];2784    var m21 = mat[4];2785    var m22 = mat[5];2786    var m23 = mat[6];2787    var m31 = mat[8];2788    var m32 = mat[9];2789    var m33 = mat[10];2790    out[0] = Math.hypot(m11, m12, m13);2791    out[1] = Math.hypot(m21, m22, m23);2792    out[2] = Math.hypot(m31, m32, m33);2793    return out;2794  }2795  /**2796   * Returns a quaternion representing the rotational component2797   *  of a transformation matrix. If a matrix is built with2798   *  fromRotationTranslation, the returned quaternion will be the2799   *  same as the quaternion originally supplied.2800   * @param {quat} out Quaternion to receive the rotation component2801   * @param {ReadonlyMat4} mat Matrix to be decomposed (input)2802   * @return {quat} out2803   */2804  function getRotation(out, mat) {2805    var scaling = new ARRAY_TYPE(3);2806    getScaling(scaling, mat);2807    var is1 = 1 / scaling[0];2808    var is2 = 1 / scaling[1];2809    var is3 = 1 / scaling[2];2810    var sm11 = mat[0] * is1;2811    var sm12 = mat[1] * is2;2812    var sm13 = mat[2] * is3;2813    var sm21 = mat[4] * is1;2814    var sm22 = mat[5] * is2;2815    var sm23 = mat[6] * is3;2816    var sm31 = mat[8] * is1;2817    var sm32 = mat[9] * is2;2818    var sm33 = mat[10] * is3;2819    var trace = sm11 + sm22 + sm33;2820    var S = 0;2821    if (trace > 0) {2822      S = Math.sqrt(trace + 1.0) * 2;2823      out[3] = 0.25 * S;2824      out[0] = (sm23 - sm32) / S;2825      out[1] = (sm31 - sm13) / S;2826      out[2] = (sm12 - sm21) / S;2827    } else if (sm11 > sm22 && sm11 > sm33) {2828      S = Math.sqrt(1.0 + sm11 - sm22 - sm33) * 2;2829      out[3] = (sm23 - sm32) / S;2830      out[0] = 0.25 * S;2831      out[1] = (sm12 + sm21) / S;2832      out[2] = (sm31 + sm13) / S;2833    } else if (sm22 > sm33) {2834      S = Math.sqrt(1.0 + sm22 - sm11 - sm33) * 2;2835      out[3] = (sm31 - sm13) / S;2836      out[0] = (sm12 + sm21) / S;2837      out[1] = 0.25 * S;2838      out[2] = (sm23 + sm32) / S;2839    } else {2840      S = Math.sqrt(1.0 + sm33 - sm11 - sm22) * 2;2841      out[3] = (sm12 - sm21) / S;2842      out[0] = (sm31 + sm13) / S;2843      out[1] = (sm23 + sm32) / S;2844      out[2] = 0.25 * S;2845    }2846    return out;2847  }2848  /**2849   * Creates a matrix from a quaternion rotation, vector translation and vector scale2850   * This is equivalent to (but much faster than):2851   *2852   *     mat4.identity(dest);2853   *     mat4.translate(dest, vec);2854   *     let quatMat = mat4.create();2855   *     quat4.toMat4(quat, quatMat);2856   *     mat4.multiply(dest, quatMat);2857   *     mat4.scale(dest, scale)2858   *2859   * @param {mat4} out mat4 receiving operation result2860   * @param {quat4} q Rotation quaternion2861   * @param {ReadonlyVec3} v Translation vector2862   * @param {ReadonlyVec3} s Scaling vector2863   * @returns {mat4} out2864   */2865  function fromRotationTranslationScale(out, q, v, s) {2866    // Quaternion math2867    var x = q[0],2868        y = q[1],2869        z = q[2],2870        w = q[3];2871    var x2 = x + x;2872    var y2 = y + y;2873    var z2 = z + z;2874    var xx = x * x2;2875    var xy = x * y2;2876    var xz = x * z2;2877    var yy = y * y2;2878    var yz = y * z2;2879    var zz = z * z2;2880    var wx = w * x2;2881    var wy = w * y2;2882    var wz = w * z2;2883    var sx = s[0];2884    var sy = s[1];2885    var sz = s[2];2886    out[0] = (1 - (yy + zz)) * sx;2887    out[1] = (xy + wz) * sx;2888    out[2] = (xz - wy) * sx;2889    out[3] = 0;2890    out[4] = (xy - wz) * sy;2891    out[5] = (1 - (xx + zz)) * sy;2892    out[6] = (yz + wx) * sy;2893    out[7] = 0;2894    out[8] = (xz + wy) * sz;2895    out[9] = (yz - wx) * sz;2896    out[10] = (1 - (xx + yy)) * sz;2897    out[11] = 0;2898    out[12] = v[0];2899    out[13] = v[1];2900    out[14] = v[2];2901    out[15] = 1;2902    return out;2903  }2904  /**2905   * Creates a matrix from a quaternion rotation, vector translation and vector scale, rotating and scaling around the given origin2906   * This is equivalent to (but much faster than):2907   *2908   *     mat4.identity(dest);2909   *     mat4.translate(dest, vec);2910   *     mat4.translate(dest, origin);2911   *     let quatMat = mat4.create();2912   *     quat4.toMat4(quat, quatMat);2913   *     mat4.multiply(dest, quatMat);2914   *     mat4.scale(dest, scale)2915   *     mat4.translate(dest, negativeOrigin);2916   *2917   * @param {mat4} out mat4 receiving operation result2918   * @param {quat4} q Rotation quaternion2919   * @param {ReadonlyVec3} v Translation vector2920   * @param {ReadonlyVec3} s Scaling vector2921   * @param {ReadonlyVec3} o The origin vector around which to scale and rotate2922   * @returns {mat4} out2923   */2924  function fromRotationTranslationScaleOrigin(out, q, v, s, o) {2925    // Quaternion math2926    var x = q[0],2927        y = q[1],2928        z = q[2],2929        w = q[3];2930    var x2 = x + x;2931    var y2 = y + y;2932    var z2 = z + z;2933    var xx = x * x2;2934    var xy = x * y2;2935    var xz = x * z2;2936    var yy = y * y2;2937    var yz = y * z2;2938    var zz = z * z2;2939    var wx = w * x2;2940    var wy = w * y2;2941    var wz = w * z2;2942    var sx = s[0];2943    var sy = s[1];2944    var sz = s[2];2945    var ox = o[0];2946    var oy = o[1];2947    var oz = o[2];2948    var out0 = (1 - (yy + zz)) * sx;2949    var out1 = (xy + wz) * sx;2950    var out2 = (xz - wy) * sx;2951    var out4 = (xy - wz) * sy;2952    var out5 = (1 - (xx + zz)) * sy;2953    var out6 = (yz + wx) * sy;2954    var out8 = (xz + wy) * sz;2955    var out9 = (yz - wx) * sz;2956    var out10 = (1 - (xx + yy)) * sz;2957    out[0] = out0;2958    out[1] = out1;2959    out[2] = out2;2960    out[3] = 0;2961    out[4] = out4;2962    out[5] = out5;2963    out[6] = out6;2964    out[7] = 0;2965    out[8] = out8;2966    out[9] = out9;2967    out[10] = out10;2968    out[11] = 0;2969    out[12] = v[0] + ox - (out0 * ox + out4 * oy + out8 * oz);2970    out[13] = v[1] + oy - (out1 * ox + out5 * oy + out9 * oz);2971    out[14] = v[2] + oz - (out2 * ox + out6 * oy + out10 * oz);2972    out[15] = 1;2973    return out;2974  }2975  /**2976   * Calculates a 4x4 matrix from the given quaternion2977   *2978   * @param {mat4} out mat4 receiving operation result2979   * @param {ReadonlyQuat} q Quaternion to create matrix from2980   *2981   * @returns {mat4} out2982   */2983  function fromQuat$1(out, q) {2984    var x = q[0],2985        y = q[1],2986        z = q[2],2987        w = q[3];2988    var x2 = x + x;2989    var y2 = y + y;2990    var z2 = z + z;2991    var xx = x * x2;2992    var yx = y * x2;2993    var yy = y * y2;2994    var zx = z * x2;2995    var zy = z * y2;2996    var zz = z * z2;2997    var wx = w * x2;2998    var wy = w * y2;2999    var wz = w * z2;3000    out[0] = 1 - yy - zz;3001    out[1] = yx + wz;3002    out[2] = zx - wy;3003    out[3] = 0;3004    out[4] = yx - wz;3005    out[5] = 1 - xx - zz;3006    out[6] = zy + wx;3007    out[7] = 0;3008    out[8] = zx + wy;3009    out[9] = zy - wx;3010    out[10] = 1 - xx - yy;3011    out[11] = 0;3012    out[12] = 0;3013    out[13] = 0;3014    out[14] = 0;3015    out[15] = 1;3016    return out;3017  }3018  /**3019   * Generates a frustum matrix with the given bounds3020   *3021   * @param {mat4} out mat4 frustum matrix will be written into3022   * @param {Number} left Left bound of the frustum3023   * @param {Number} right Right bound of the frustum3024   * @param {Number} bottom Bottom bound of the frustum3025   * @param {Number} top Top bound of the frustum3026   * @param {Number} near Near bound of the frustum3027   * @param {Number} far Far bound of the frustum3028   * @returns {mat4} out3029   */3030  function frustum(out, left, right, bottom, top, near, far) {3031    var rl = 1 / (right - left);3032    var tb = 1 / (top - bottom);3033    var nf = 1 / (near - far);3034    out[0] = near * 2 * rl;3035    out[1] = 0;3036    out[2] = 0;3037    out[3] = 0;3038    out[4] = 0;3039    out[5] = near * 2 * tb;3040    out[6] = 0;3041    out[7] = 0;3042    out[8] = (right + left) * rl;3043    out[9] = (top + bottom) * tb;3044    out[10] = (far + near) * nf;3045    out[11] = -1;3046    out[12] = 0;3047    out[13] = 0;3048    out[14] = far * near * 2 * nf;3049    out[15] = 0;3050    return out;3051  }3052  /**3053   * Generates a perspective projection matrix with the given bounds.3054   * Passing null/undefined/no value for far will generate infinite projection matrix.3055   *3056   * @param {mat4} out mat4 frustum matrix will be written into3057   * @param {number} fovy Vertical field of view in radians3058   * @param {number} aspect Aspect ratio. typically viewport width/height3059   * @param {number} near Near bound of the frustum3060   * @param {number} far Far bound of the frustum, can be null or Infinity3061   * @returns {mat4} out3062   */3063  function perspective(out, fovy, aspect, near, far) {3064    var f = 1.0 / Math.tan(fovy / 2),3065        nf;3066    out[0] = f / aspect;3067    out[1] = 0;3068    out[2] = 0;3069    out[3] = 0;3070    out[4] = 0;3071    out[5] = f;3072    out[6] = 0;3073    out[7] = 0;3074    out[8] = 0;3075    out[9] = 0;3076    out[11] = -1;3077    out[12] = 0;3078    out[13] = 0;3079    out[15] = 0;3080    if (far != null && far !== Infinity) {3081      nf = 1 / (near - far);3082      out[10] = (far + near) * nf;3083      out[14] = 2 * far * near * nf;3084    } else {3085      out[10] = -1;3086      out[14] = -2 * near;3087    }3088    //out[10] = -out[10];3089    //out[14] = -out[14];3090    return out;3091  }3092  /**3093   * Generates a perspective projection matrix with the given field of view.3094   * This is primarily useful for generating projection matrices to be used3095   * with the still experiemental WebVR API.3096   *3097   * @param {mat4} out mat4 frustum matrix will be written into3098   * @param {Object} fov Object containing the following values: upDegrees, downDegrees, leftDegrees, rightDegrees3099   * @param {number} near Near bound of the frustum3100   * @param {number} far Far bound of the frustum3101   * @returns {mat4} out3102   */3103  function perspectiveFromFieldOfView(out, fov, near, far) {3104    var upTan = Math.tan(fov.upDegrees * Math.PI / 180.0);3105    var downTan = Math.tan(fov.downDegrees * Math.PI / 180.0);3106    var leftTan = Math.tan(fov.leftDegrees * Math.PI / 180.0);3107    var rightTan = Math.tan(fov.rightDegrees * Math.PI / 180.0);3108    var xScale = 2.0 / (leftTan + rightTan);3109    var yScale = 2.0 / (upTan + downTan);3110    out[0] = xScale;3111    out[1] = 0.0;3112    out[2] = 0.0;3113    out[3] = 0.0;3114    out[4] = 0.0;3115    out[5] = yScale;3116    out[6] = 0.0;3117    out[7] = 0.0;3118    out[8] = -((leftTan - rightTan) * xScale * 0.5);3119    out[9] = (upTan - downTan) * yScale * 0.5;3120    out[10] = far / (near - far);3121    out[11] = -1.0;3122    out[12] = 0.0;3123    out[13] = 0.0;3124    out[14] = far * near / (near - far);3125    out[15] = 0.0;3126    return out;3127  }3128  /**3129   * Generates a orthogonal projection matrix with the given bounds3130   *3131   * @param {mat4} out mat4 frustum matrix will be written into3132   * @param {number} left Left bound of the frustum3133   * @param {number} right Right bound of the frustum3134   * @param {number} bottom Bottom bound of the frustum3135   * @param {number} top Top bound of the frustum3136   * @param {number} near Near bound of the frustum3137   * @param {number} far Far bound of the frustum3138   * @returns {mat4} out3139   */3140  function ortho(out, left, right, bottom, top, near, far) {3141    var lr = 1 / (left - right);3142    var bt = 1 / (bottom - top);3143    var nf = 1 / (near - far);3144    out[0] = -2 * lr;3145    out[1] = 0;3146    out[2] = 0;3147    out[3] = 0;3148    out[4] = 0;3149    out[5] = -2 * bt;3150    out[6] = 0;3151    out[7] = 0;3152    out[8] = 0;3153    out[9] = 0;3154    out[10] = 2 * nf;3155    out[11] = 0;3156    out[12] = (left + right) * lr;3157    out[13] = (top + bottom) * bt;3158    out[14] = (far + near) * nf;3159    out[15] = 1;3160    return out;3161  }3162  /**3163   * Generates a look-at matrix with the given eye position, focal point, and up axis.3164   * If you want a matrix that actually makes an object look at another object, you should use targetTo instead.3165   *3166   * @param {mat4} out mat4 frustum matrix will be written into3167   * @param {ReadonlyVec3} eye Position of the viewer3168   * @param {ReadonlyVec3} center Point the viewer is looking at3169   * @param {ReadonlyVec3} up vec3 pointing up3170   * @returns {mat4} out3171   */3172  function lookAt(out, eye, center, up) {3173    var x0, x1, x2, y0, y1, y2, z0, z1, z2, len;3174    var eyex = eye[0];3175    var eyey = eye[1];3176    var eyez = eye[2];3177    var upx = up[0];3178    var upy = up[1];3179    var upz = up[2];3180    var centerx = center[0];3181    var centery = center[1];3182    var centerz = center[2];3183    if (Math.abs(eyex - centerx) < EPSILON && Math.abs(eyey - centery) < EPSILON && Math.abs(eyez - centerz) < EPSILON) {3184      return identity$3(out);3185    }3186    z0 = eyex - centerx;3187    z1 = eyey - centery;3188    z2 = eyez - centerz;3189    len = 1 / Math.hypot(z0, z1, z2);3190    z0 *= len;3191    z1 *= len;3192    z2 *= len;3193    x0 = upy * z2 - upz * z1;3194    x1 = upz * z0 - upx * z2;3195    x2 = upx * z1 - upy * z0;3196    len = Math.hypot(x0, x1, x2);3197    if (!len) {3198      x0 = 0;3199      x1 = 0;3200      x2 = 0;3201    } else {3202      len = 1 / len;3203      x0 *= len;3204      x1 *= len;3205      x2 *= len;3206    }3207    y0 = z1 * x2 - z2 * x1;3208    y1 = z2 * x0 - z0 * x2;3209    y2 = z0 * x1 - z1 * x0;3210    len = Math.hypot(y0, y1, y2);3211    if (!len) {3212      y0 = 0;3213      y1 = 0;3214      y2 = 0;3215    } else {3216      len = 1 / len;3217      y0 *= len;3218      y1 *= len;3219      y2 *= len;3220    }3221    out[0] = x0;3222    out[1] = y0;3223    out[2] = z0;3224    out[3] = 0;3225    out[4] = x1;3226    out[5] = y1;3227    out[6] = z1;3228    out[7] = 0;3229    out[8] = x2;3230    out[9] = y2;3231    out[10] = z2;3232    out[11] = 0;3233    out[12] = -(x0 * eyex + x1 * eyey + x2 * eyez);3234    out[13] = -(y0 * eyex + y1 * eyey + y2 * eyez);3235    out[14] = -(z0 * eyex + z1 * eyey + z2 * eyez);3236    out[15] = 1;3237    return out;3238  }3239  /**3240   * Generates a matrix that makes something look at something else.3241   *3242   * @param {mat4} out mat4 frustum matrix will be written into3243   * @param {ReadonlyVec3} eye Position of the viewer3244   * @param {ReadonlyVec3} center Point the viewer is looking at3245   * @param {ReadonlyVec3} up vec3 pointing up3246   * @returns {mat4} out3247   */3248  function targetTo(out, eye, target, up) {3249    var eyex = eye[0],3250        eyey = eye[1],3251        eyez = eye[2],3252        upx = up[0],3253        upy = up[1],3254        upz = up[2];3255    var z0 = eyex - target[0],3256        z1 = eyey - target[1],3257        z2 = eyez - target[2];3258    var len = z0 * z0 + z1 * z1 + z2 * z2;3259    if (len > 0) {3260      len = 1 / Math.sqrt(len);3261      z0 *= len;3262      z1 *= len;3263      z2 *= len;3264    }3265    var x0 = upy * z2 - upz * z1,3266        x1 = upz * z0 - upx * z2,3267        x2 = upx * z1 - upy * z0;3268    len = x0 * x0 + x1 * x1 + x2 * x2;3269    if (len > 0) {3270      len = 1 / Math.sqrt(len);3271      x0 *= len;3272      x1 *= len;3273      x2 *= len;3274    }3275    out[0] = x0;3276    out[1] = x1;3277    out[2] = x2;3278    out[3] = 0;3279    out[4] = z1 * x2 - z2 * x1;3280    out[5] = z2 * x0 - z0 * x2;3281    out[6] = z0 * x1 - z1 * x0;3282    out[7] = 0;3283    out[8] = z0;3284    out[9] = z1;3285    out[10] = z2;3286    out[11] = 0;3287    out[12] = eyex;3288    out[13] = eyey;3289    out[14] = eyez;3290    out[15] = 1;3291    return out;3292  }3293  /**3294   * Returns a string representation of a mat43295   *3296   * @param {ReadonlyMat4} a matrix to represent as a string3297   * @returns {String} string representation of the matrix3298   */3299  function str$3(a) {3300    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] + ")";3301  }3302  /**3303   * Returns Frobenius norm of a mat43304   *3305   * @param {ReadonlyMat4} a the matrix to calculate Frobenius norm of3306   * @returns {Number} Frobenius norm3307   */3308  function frob$3(a) {3309    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]);3310  }3311  /**3312   * Adds two mat4's3313   *3314   * @param {mat4} out the receiving matrix3315   * @param {ReadonlyMat4} a the first operand3316   * @param {ReadonlyMat4} b the second operand3317   * @returns {mat4} out3318   */3319  function add$3(out, a, b) {3320    out[0] = a[0] + b[0];3321    out[1] = a[1] + b[1];3322    out[2] = a[2] + b[2];3323    out[3] = a[3] + b[3];3324    out[4] = a[4] + b[4];3325    out[5] = a[5] + b[5];3326    out[6] = a[6] + b[6];3327    out[7] = a[7] + b[7];3328    out[8] = a[8] + b[8];3329    out[9] = a[9] + b[9];3330    out[10] = a[10] + b[10];3331    out[11] = a[11] + b[11];3332    out[12] = a[12] + b[12];3333    out[13] = a[13] + b[13];3334    out[14] = a[14] + b[14];3335    out[15] = a[15] + b[15];3336    return out;3337  }3338  /**3339   * Subtracts matrix b from matrix a3340   *3341   * @param {mat4} out the receiving matrix3342   * @param {ReadonlyMat4} a the first operand3343   * @param {ReadonlyMat4} b the second operand3344   * @returns {mat4} out3345   */3346  function subtract$3(out, a, b) {3347    out[0] = a[0] - b[0];3348    out[1] = a[1] - b[1];3349    out[2] = a[2] - b[2];3350    out[3] = a[3] - b[3];3351    out[4] = a[4] - b[4];3352    out[5] = a[5] - b[5];3353    out[6] = a[6] - b[6];3354    out[7] = a[7] - b[7];3355    out[8] = a[8] - b[8];3356    out[9] = a[9] - b[9];3357    out[10] = a[10] - b[10];3358    out[11] = a[11] - b[11];3359    out[12] = a[12] - b[12];3360    out[13] = a[13] - b[13];3361    out[14] = a[14] - b[14];3362    out[15] = a[15] - b[15];3363    return out;3364  }3365  /**3366   * Multiply each element of the matrix by a scalar.3367   *3368   * @param {mat4} out the receiving matrix3369   * @param {ReadonlyMat4} a the matrix to scale3370   * @param {Number} b amount to scale the matrix's elements by3371   * @returns {mat4} out3372   */3373  function multiplyScalar$3(out, a, b) {3374    out[0] = a[0] * b;3375    out[1] = a[1] * b;3376    out[2] = a[2] * b;3377    out[3] = a[3] * b;3378    out[4] = a[4] * b;3379    out[5] = a[5] * b;3380    out[6] = a[6] * b;3381    out[7] = a[7] * b;3382    out[8] = a[8] * b;3383    out[9] = a[9] * b;3384    out[10] = a[10] * b;3385    out[11] = a[11] * b;3386    out[12] = a[12] * b;3387    out[13] = a[13] * b;3388    out[14] = a[14] * b;3389    out[15] = a[15] * b;3390    return out;3391  }3392  /**3393   * Adds two mat4's after multiplying each element of the second operand by a scalar value.3394   *3395   * @param {mat4} out the receiving vector3396   * @param {ReadonlyMat4} a the first operand3397   * @param {ReadonlyMat4} b the second operand3398   * @param {Number} scale the amount to scale b's elements by before adding3399   * @returns {mat4} out3400   */3401  function multiplyScalarAndAdd$3(out, a, b, scale) {3402    out[0] = a[0] + b[0] * scale;3403    out[1] = a[1] + b[1] * scale;3404    out[2] = a[2] + b[2] * scale;3405    out[3] = a[3] + b[3] * scale;3406    out[4] = a[4] + b[4] * scale;3407    out[5] = a[5] + b[5] * scale;3408    out[6] = a[6] + b[6] * scale;3409    out[7] = a[7] + b[7] * scale;3410    out[8] = a[8] + b[8] * scale;3411    out[9] = a[9] + b[9] * scale;3412    out[10] = a[10] + b[10] * scale;3413    out[11] = a[11] + b[11] * scale;3414    out[12] = a[12] + b[12] * scale;3415    out[13] = a[13] + b[13] * scale;3416    out[14] = a[14] + b[14] * scale;3417    out[15] = a[15] + b[15] * scale;3418    return out;3419  }3420  /**3421   * Returns whether or not the matrices have exactly the same elements in the same position (when compared with ===)3422   *3423   * @param {ReadonlyMat4} a The first matrix.3424   * @param {ReadonlyMat4} b The second matrix.3425   * @returns {Boolean} True if the matrices are equal, false otherwise.3426   */3427  function exactEquals$3(a, b) {3428    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];3429  }3430  /**3431   * Returns whether or not the matrices have approximately the same elements in the same position.3432   *3433   * @param {ReadonlyMat4} a The first matrix.3434   * @param {ReadonlyMat4} b The second matrix.3435   * @returns {Boolean} True if the matrices are equal, false otherwise.3436   */3437  function equals$4(a, b) {3438    var a0 = a[0],3439        a1 = a[1],3440        a2 = a[2],3441        a3 = a[3];3442    var a4 = a[4],3443        a5 = a[5],3444        a6 = a[6],3445        a7 = a[7];3446    var a8 = a[8],3447        a9 = a[9],3448        a10 = a[10],3449        a11 = a[11];3450    var a12 = a[12],3451        a13 = a[13],3452        a14 = a[14],3453        a15 = a[15];3454    var b0 = b[0],3455        b1 = b[1],3456        b2 = b[2],3457        b3 = b[3];3458    var b4 = b[4],3459        b5 = b[5],3460        b6 = b[6],3461        b7 = b[7];3462    var b8 = b[8],3463        b9 = b[9],3464        b10 = b[10],3465        b11 = b[11];3466    var b12 = b[12],3467        b13 = b[13],3468        b14 = b[14],3469        b15 = b[15];3470    return Math.abs(a0 - b0) <= EPSILON * Math.max(1.0, Math.abs(a0), Math.abs(b0)) && Math.abs(a1 - b1) <= EPSILON * Math.max(1.0, Math.abs(a1), Math.abs(b1)) && Math.abs(a2 - b2) <= EPSILON * Math.max(1.0, Math.abs(a2), Math.abs(b2)) && Math.abs(a3 - b3) <= EPSILON * Math.max(1.0, Math.abs(a3), Math.abs(b3)) && Math.abs(a4 - b4) <= EPSILON * Math.max(1.0, Math.abs(a4), Math.abs(b4)) && Math.abs(a5 - b5) <= EPSILON * Math.max(1.0, Math.abs(a5), Math.abs(b5)) && Math.abs(a6 - b6) <= EPSILON * Math.max(1.0, Math.abs(a6), Math.abs(b6)) && Math.abs(a7 - b7) <= EPSILON * Math.max(1.0, Math.abs(a7), Math.abs(b7)) && Math.abs(a8 - b8) <= EPSILON * Math.max(1.0, Math.abs(a8), Math.abs(b8)) && Math.abs(a9 - b9) <= EPSILON * Math.max(1.0, Math.abs(a9), Math.abs(b9)) && Math.abs(a10 - b10) <= EPSILON * Math.max(1.0, Math.abs(a10), Math.abs(b10)) && Math.abs(a11 - b11) <= EPSILON * Math.max(1.0, Math.abs(a11), Math.abs(b11)) && Math.abs(a12 - b12) <= EPSILON * Math.max(1.0, Math.abs(a12), Math.abs(b12)) && Math.abs(a13 - b13) <= EPSILON * Math.max(1.0, Math.abs(a13), Math.abs(b13)) && Math.abs(a14 - b14) <= EPSILON * Math.max(1.0, Math.abs(a14), Math.abs(b14)) && Math.abs(a15 - b15) <= EPSILON * Math.max(1.0, Math.abs(a15), Math.abs(b15));3471  }3472  /**3473   * Alias for {@link mat4.multiply}3474   * @function3475   */3476  var mul$3 = multiply$3;3477  /**3478   * Alias for {@link mat4.subtract}3479   * @function3480   */3481  var sub$3 = subtract$3;3482  var mat4 = /*#__PURE__*/Object.freeze({3483    __proto__: null,3484    create: create$3,3485    clone: clone$3,3486    copy: copy$3,3487    fromValues: fromValues$3,3488    set: set$3,3489    identity: identity$3,3490    transpose: transpose$2,3491    invert: invert$3,3492    adjoint: adjoint$2,3493    determinant: determinant$3,3494    multiply: multiply$3,3495    translate: translate$2,3496    scale: scale$3,3497    rotate: rotate$3,3498    rotateX: rotateX,3499    rotateY: rotateY,3500    rotateZ: rotateZ,3501    fromTranslation: fromTranslation$2,3502    fromScaling: fromScaling$3,3503    fromRotation: fromRotation$3,3504    fromXRotation: fromXRotation,3505    fromYRotation: fromYRotation,3506    fromZRotation: fromZRotation,3507    fromRotationTranslation: fromRotationTranslation,3508    fromQuat2: fromQuat2,3509    getTranslation: getTranslation,3510    getScaling: getScaling,3511    getRotation: getRotation,3512    fromRotationTranslationScale: fromRotationTranslationScale,3513    fromRotationTranslationScaleOrigin: fromRotationTranslationScaleOrigin,3514    fromQuat: fromQuat$1,3515    frustum: frustum,3516    perspective: perspective,3517    perspectiveFromFieldOfView: perspectiveFromFieldOfView,3518    ortho: ortho,3519    lookAt: lookAt,3520    targetTo: targetTo,3521    str: str$3,3522    frob: frob$3,3523    add: add$3,3524    subtract: subtract$3,3525    multiplyScalar: multiplyScalar$3,3526    multiplyScalarAndAdd: multiplyScalarAndAdd$3,3527    exactEquals: exactEquals$3,3528    equals: equals$4,3529    mul: mul$3,3530    sub: sub$33531  });3532  /**3533   * 3 Dimensional Vector3534   * @module vec33535   */3536  /**3537   * Creates a new, empty vec33538   *3539   * @returns {vec3} a new 3D vector3540   */3541  function create$4() {3542    var out = new ARRAY_TYPE(3);3543    if (ARRAY_TYPE != Float32Array) {3544      out[0] = 0;3545      out[1] = 0;3546      out[2] = 0;3547    }3548    return out;3549  }3550  /**3551   * Creates a new vec3 initialized with values from an existing vector3552   *3553   * @param {ReadonlyVec3} a vector to clone3554   * @returns {vec3} a new 3D vector3555   */3556  function clone$4(a) {3557    var out = new ARRAY_TYPE(3);3558    out[0] = a[0];3559    out[1] = a[1];3560    out[2] = a[2];3561    return out;3562  }3563  /**3564   * Calculates the length of a vec33565   *3566   * @param {ReadonlyVec3} a vector to calculate length of3567   * @returns {Number} length of a3568   */3569  function length(a) {3570    var x = a[0];3571    var y = a[1];3572    var z = a[2];3573    return Math.hypot(x, y, z);3574  }3575  /**3576   * Creates a new vec3 initialized with the given values3577   *3578   * @param {Number} x X component3579   * @param {Number} y Y component3580   * @param {Number} z Z component3581   * @returns {vec3} a new 3D vector3582   */3583  function fromValues$4(x, y, z) {3584    var out = new ARRAY_TYPE(3);3585    out[0] = x;3586    out[1] = y;3587    out[2] = z;3588    return out;3589  }3590  /**3591   * Copy the values from one vec3 to another3592   *3593   * @param {vec3} out the receiving vector3594   * @param {ReadonlyVec3} a the source vector3595   * @returns {vec3} out3596   */3597  function copy$4(out, a) {3598    out[0] = a[0];3599    out[1] = a[1];3600    out[2] = a[2];3601    return out;3602  }3603  /**3604   * Set the components of a vec3 to the given values3605   *3606   * @param {vec3} out the receiving vector3607   * @param {Number} x X component3608   * @param {Number} y Y component3609   * @param {Number} z Z component3610   * @returns {vec3} out3611   */3612  function set$4(out, x, y, z) {3613    out[0] = x;3614    out[1] = y;3615    out[2] = z;3616    return out;3617  }3618  /**3619   * Adds two vec3's3620   *3621   * @param {vec3} out the receiving vector3622   * @param {ReadonlyVec3} a the first operand3623   * @param {ReadonlyVec3} b the second operand3624   * @returns {vec3} out3625   */3626  function add$4(out, a, b) {3627    out[0] = a[0] + b[0];3628    out[1] = a[1] + b[1];3629    out[2] = a[2] + b[2];3630    return out;3631  }3632  /**3633   * Subtracts vector b from vector a3634   *3635   * @param {vec3} out the receiving vector3636   * @param {ReadonlyVec3} a the first operand3637   * @param {ReadonlyVec3} b the second operand3638   * @returns {vec3} out3639   */3640  function subtract$4(out, a, b) {3641    out[0] = a[0] - b[0];3642    out[1] = a[1] - b[1];3643    out[2] = a[2] - b[2];3644    return out;3645  }3646  /**3647   * Multiplies two vec3's3648   *3649   * @param {vec3} out the receiving vector3650   * @param {ReadonlyVec3} a the first operand3651   * @param {ReadonlyVec3} b the second operand3652   * @returns {vec3} out3653   */3654  function multiply$4(out, a, b) {3655    out[0] = a[0] * b[0];3656    out[1] = a[1] * b[1];3657    out[2] = a[2] * b[2];3658    return out;3659  }3660  /**3661   * Divides two vec3's3662   *3663   * @param {vec3} out the receiving vector3664   * @param {ReadonlyVec3} a the first operand3665   * @param {ReadonlyVec3} b the second operand3666   * @returns {vec3} out3667   */3668  function divide(out, a, b) {3669    out[0] = a[0] / b[0];3670    out[1] = a[1] / b[1];3671    out[2] = a[2] / b[2];3672    return out;3673  }3674  /**3675   * Math.ceil the components of a vec33676   *3677   * @param {vec3} out the receiving vector3678   * @param {ReadonlyVec3} a vector to ceil3679   * @returns {vec3} out3680   */3681  function ceil(out, a) {3682    out[0] = Math.ceil(a[0]);3683    out[1] = Math.ceil(a[1]);3684    out[2] = Math.ceil(a[2]);3685    return out;3686  }3687  /**3688   * Math.floor the components of a vec33689   *3690   * @param {vec3} out the receiving vector3691   * @param {ReadonlyVec3} a vector to floor3692   * @returns {vec3} out3693   */3694  function floor(out, a) {3695    out[0] = Math.floor(a[0]);3696    out[1] = Math.floor(a[1]);3697    out[2] = Math.floor(a[2]);3698    return out;3699  }3700  /**3701   * Returns the minimum of two vec3's3702   *3703   * @param {vec3} out the receiving vector3704   * @param {ReadonlyVec3} a the first operand3705   * @param {ReadonlyVec3} b the second operand3706   * @returns {vec3} out3707   */3708  function min(out, a, b) {3709    out[0] = Math.min(a[0], b[0]);3710    out[1] = Math.min(a[1], b[1]);3711    out[2] = Math.min(a[2], b[2]);3712    return out;3713  }3714  /**3715   * Returns the maximum of two vec3's3716   *3717   * @param {vec3} out the receiving vector3718   * @param {ReadonlyVec3} a the first operand3719   * @param {ReadonlyVec3} b the second operand3720   * @returns {vec3} out3721   */3722  function max(out, a, b) {3723    out[0] = Math.max(a[0], b[0]);3724    out[1] = Math.max(a[1], b[1]);3725    out[2] = Math.max(a[2], b[2]);3726    return out;3727  }3728  /**3729   * Math.round the components of a vec33730   *3731   * @param {vec3} out the receiving vector3732   * @param {ReadonlyVec3} a vector to round3733   * @returns {vec3} out3734   */3735  function round(out, a) {3736    out[0] = Math.round(a[0]);3737    out[1] = Math.round(a[1]);3738    out[2] = Math.round(a[2]);3739    return out;3740  }3741  /**3742   * Scales a vec3 by a scalar number3743   *3744   * @param {vec3} out the receiving vector3745   * @param {ReadonlyVec3} a the vector to scale3746   * @param {Number} b amount to scale the vector by3747   * @returns {vec3} out3748   */3749  function scale$4(out, a, b) {3750    out[0] = a[0] * b;3751    out[1] = a[1] * b;3752    out[2] = a[2] * b;3753    return out;3754  }3755  /**3756   * Adds two vec3's after scaling the second operand by a scalar value3757   *3758   * @param {vec3} out the receiving vector3759   * @param {ReadonlyVec3} a the first operand3760   * @param {ReadonlyVec3} b the second operand3761   * @param {Number} scale the amount to scale b by before adding3762   * @returns {vec3} out3763   */3764  function scaleAndAdd(out, a, b, scale) {3765    out[0] = a[0] + b[0] * scale;3766    out[1] = a[1] + b[1] * scale;3767    out[2] = a[2] + b[2] * scale;3768    return out;3769  }3770  /**3771   * Calculates the euclidian distance between two vec3's3772   *3773   * @param {ReadonlyVec3} a the first operand3774   * @param {ReadonlyVec3} b the second operand3775   * @returns {Number} distance between a and b3776   */3777  function distance(a, b) {3778    var x = b[0] - a[0];3779    var y = b[1] - a[1];3780    var z = b[2] - a[2];3781    return Math.hypot(x, y, z);3782  }3783  /**3784   * Calculates the squared euclidian distance between two vec3's3785   *3786   * @param {ReadonlyVec3} a the first operand3787   * @param {ReadonlyVec3} b the second operand3788   * @returns {Number} squared distance between a and b3789   */3790  function squaredDistance(a, b) {3791    var x = b[0] - a[0];3792    var y = b[1] - a[1];3793    var z = b[2] - a[2];3794    return x * x + y * y + z * z;3795  }3796  /**3797   * Calculates the squared length of a vec33798   *3799   * @param {ReadonlyVec3} a vector to calculate squared length of3800   * @returns {Number} squared length of a3801   */3802  function squaredLength(a) {3803    var x = a[0];3804    var y = a[1];3805    var z = a[2];3806    return x * x + y * y + z * z;3807  }3808  /**3809   * Negates the components of a vec33810   *3811   * @param {vec3} out the receiving vector3812   * @param {ReadonlyVec3} a vector to negate3813   * @returns {vec3} out3814   */3815  function negate(out, a) {3816    out[0] = -a[0];3817    out[1] = -a[1];3818    out[2] = -a[2];3819    return out;3820  }3821  /**3822   * Returns the inverse of the components of a vec33823   *3824   * @param {vec3} out the receiving vector3825   * @param {ReadonlyVec3} a vector to invert3826   * @returns {vec3} out3827   */3828  function inverse(out, a) {3829    out[0] = 1.0 / a[0];3830    out[1] = 1.0 / a[1];3831    out[2] = 1.0 / a[2];3832    return out;3833  }3834  /**3835   * Normalize a vec33836   *3837   * @param {vec3} out the receiving vector3838   * @param {ReadonlyVec3} a vector to normalize3839   * @returns {vec3} out3840   */3841  function normalize(out, a) {3842    var x = a[0];3843    var y = a[1];3844    var z = a[2];3845    var len = x * x + y * y + z * z;3846    if (len > 0) {3847      //TODO: evaluate use of glm_invsqrt here?3848      len = 1 / Math.sqrt(len);3849    }3850    out[0] = a[0] * len;3851    out[1] = a[1] * len;3852    out[2] = a[2] * len;3853    return out;3854  }3855  /**3856   * Calculates the dot product of two vec3's3857   *3858   * @param {ReadonlyVec3} a the first operand3859   * @param {ReadonlyVec3} b the second operand3860   * @returns {Number} dot product of a and b3861   */3862  function dot(a, b) {3863    return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];3864  }3865  /**3866   * Computes the cross product of two vec3's3867   *3868   * @param {vec3} out the receiving vector3869   * @param {ReadonlyVec3} a the first operand3870   * @param {ReadonlyVec3} b the second operand3871   * @returns {vec3} out3872   */3873  function cross(out, a, b) {3874    var ax = a[0],3875        ay = a[1],3876        az = a[2];3877    var bx = b[0],3878        by = b[1],3879        bz = b[2];3880    out[0] = ay * bz - az * by;3881    out[1] = az * bx - ax * bz;3882    out[2] = ax * by - ay * bx;3883    return out;3884  }3885  /**3886   * Performs a linear interpolation between two vec3's3887   *3888   * @param {vec3} out the receiving vector3889   * @param {ReadonlyVec3} a the first operand3890   * @param {ReadonlyVec3} b the second operand3891   * @param {Number} t interpolation amount, in the range [0-1], between the two inputs3892   * @returns {vec3} out3893   */3894  function lerp(out, a, b, t) {3895    var ax = a[0];3896    var ay = a[1];3897    var az = a[2];3898    out[0] = ax + t * (b[0] - ax);3899    out[1] = ay + t * (b[1] - ay);3900    out[2] = az + t * (b[2] - az);3901    return out;3902  }3903  /**3904   * Performs a hermite interpolation with two control points3905   *3906   * @param {vec3} out the receiving vector3907   * @param {ReadonlyVec3} a the first operand3908   * @param {ReadonlyVec3} b the second operand3909   * @param {ReadonlyVec3} c the third operand3910   * @param {ReadonlyVec3} d the fourth operand3911   * @param {Number} t interpolation amount, in the range [0-1], between the two inputs3912   * @returns {vec3} out3913   */3914  function hermite(out, a, b, c, d, t) {3915    var factorTimes2 = t * t;3916    var factor1 = factorTimes2 * (2 * t - 3) + 1;3917    var factor2 = factorTimes2 * (t - 2) + t;3918    var factor3 = factorTimes2 * (t - 1);3919    var factor4 = factorTimes2 * (3 - 2 * t);3920    out[0] = a[0] * factor1 + b[0] * factor2 + c[0] * factor3 + d[0] * factor4;3921    out[1] = a[1] * factor1 + b[1] * factor2 + c[1] * factor3 + d[1] * factor4;3922    out[2] = a[2] * factor1 + b[2] * factor2 + c[2] * factor3 + d[2] * factor4;3923    return out;3924  }3925  /**3926   * Performs a bezier interpolation with two control points3927   *3928   * @param {vec3} out the receiving vector3929   * @param {ReadonlyVec3} a the first operand3930   * @param {ReadonlyVec3} b the second operand3931   * @param {ReadonlyVec3} c the third operand3932   * @param {ReadonlyVec3} d the fourth operand3933   * @param {Number} t interpolation amount, in the range [0-1], between the two inputs3934   * @returns {vec3} out3935   */3936  function bezier(out, a, b, c, d, t) {3937    var inverseFactor = 1 - t;3938    var inverseFactorTimesTwo = inverseFactor * inverseFactor;3939    var factorTimes2 = t * t;3940    var factor1 = inverseFactorTimesTwo * inverseFactor;3941    var factor2 = 3 * t * inverseFactorTimesTwo;3942    var factor3 = 3 * factorTimes2 * inverseFactor;3943    var factor4 = factorTimes2 * t;3944    out[0] = a[0] * factor1 + b[0] * factor2 + c[0] * factor3 + d[0] * factor4;3945    out[1] = a[1] * factor1 + b[1] * factor2 + c[1] * factor3 + d[1] * factor4;3946    out[2] = a[2] * factor1 + b[2] * factor2 + c[2] * factor3 + d[2] * factor4;3947    return out;3948  }3949  /**3950   * Generates a random vector with the given scale3951   *3952   * @param {vec3} out the receiving vector3953   * @param {Number} [scale] Length of the resulting vector. If ommitted, a unit vector will be returned3954   * @returns {vec3} out3955   */3956  function random(out, scale) {3957    scale = scale || 1.0;3958    var r = RANDOM() * 2.0 * Math.PI;3959    var z = RANDOM() * 2.0 - 1.0;3960    var zScale = Math.sqrt(1.0 - z * z) * scale;3961    out[0] = Math.cos(r) * zScale;3962    out[1] = Math.sin(r) * zScale;3963    out[2] = z * scale;3964    return out;3965  }3966  /**3967   * Transforms the vec3 with a mat4.3968   * 4th vector component is implicitly '1'3969   *3970   * @param {vec3} out the receiving vector3971   * @param {ReadonlyVec3} a the vector to transform3972   * @param {ReadonlyMat4} m matrix to transform with3973   * @returns {vec3} out3974   */3975  function transformMat4(out, a, m) {3976    var x = a[0],3977        y = a[1],3978        z = a[2];3979    var w = m[3] * x + m[7] * y + m[11] * z + m[15];3980    w = w || 1.0;3981    out[0] = (m[0] * x + m[4] * y + m[8] * z + m[12]) / w;3982    out[1] = (m[1] * x + m[5] * y + m[9] * z + m[13]) / w;3983    out[2] = (m[2] * x + m[6] * y + m[10] * z + m[14]) / w;3984    return out;3985  }3986  /**3987   * Transforms the vec3 with a mat3.3988   *3989   * @param {vec3} out the receiving vector3990   * @param {ReadonlyVec3} a the vector to transform3991   * @param {ReadonlyMat3} m the 3x3 matrix to transform with3992   * @returns {vec3} out3993   */3994  function transformMat3(out, a, m) {3995    var x = a[0],3996        y = a[1],3997        z = a[2];3998    out[0] = x * m[0] + y * m[3] + z * m[6];3999    out[1] = x * m[1] + y * m[4] + z * m[7];4000    out[2] = x * m[2] + y * m[5] + z * m[8];4001    return out;4002  }4003  /**4004   * Transforms the vec3 with a quat4005   * Can also be used for dual quaternions. (Multiply it with the real part)4006   *4007   * @param {vec3} out the receiving vector4008   * @param {ReadonlyVec3} a the vector to transform4009   * @param {ReadonlyQuat} q quaternion to transform with4010   * @returns {vec3} out4011   */4012  function transformQuat(out, a, q) {4013    // benchmarks: https://jsperf.com/quaternion-transform-vec3-implementations-fixed4014    var qx = q[0],4015        qy = q[1],4016        qz = q[2],4017        qw = q[3];4018    var x = a[0],4019        y = a[1],4020        z = a[2]; // var qvec = [qx, qy, qz];4021    // var uv = vec3.cross([], qvec, a);4022    var uvx = qy * z - qz * y,4023        uvy = qz * x - qx * z,4024        uvz = qx * y - qy * x; // var uuv = vec3.cross([], qvec, uv);4025    var uuvx = qy * uvz - qz * uvy,4026        uuvy = qz * uvx - qx * uvz,4027        uuvz = qx * uvy - qy * uvx; // vec3.scale(uv, uv, 2 * w);4028    var w2 = qw * 2;4029    uvx *= w2;4030    uvy *= w2;4031    uvz *= w2; // vec3.scale(uuv, uuv, 2);4032    uuvx *= 2;4033    uuvy *= 2;4034    uuvz *= 2; // return vec3.add(out, a, vec3.add(out, uv, uuv));4035    out[0] = x + uvx + uuvx;4036    out[1] = y + uvy + uuvy;4037    out[2] = z + uvz + uuvz;4038    return out;4039  }4040  /**4041   * Rotate a 3D vector around the x-axis4042   * @param {vec3} out The receiving vec34043   * @param {ReadonlyVec3} a The vec3 point to rotate4044   * @param {ReadonlyVec3} b The origin of the rotation4045   * @param {Number} rad The angle of rotation in radians4046   * @returns {vec3} out4047   */4048  function rotateX$1(out, a, b, rad) {4049    var p = [],4050        r = []; //Translate point to the origin4051    p[0] = a[0] - b[0];4052    p[1] = a[1] - b[1];4053    p[2] = a[2] - b[2]; //perform rotation4054    r[0] = p[0];4055    r[1] = p[1] * Math.cos(rad) - p[2] * Math.sin(rad);4056    r[2] = p[1] * Math.sin(rad) + p[2] * Math.cos(rad); //translate to correct position4057    out[0] = r[0] + b[0];4058    out[1] = r[1] + b[1];4059    out[2] = r[2] + b[2];4060    return out;4061  }4062  /**4063   * Rotate a 3D vector around the y-axis4064   * @param {vec3} out The receiving vec34065   * @param {ReadonlyVec3} a The vec3 point to rotate4066   * @param {ReadonlyVec3} b The origin of the rotation4067   * @param {Number} rad The angle of rotation in radians4068   * @returns {vec3} out4069   */4070  function rotateY$1(out, a, b, rad) {4071    var p = [],4072        r = []; //Translate point to the origin4073    p[0] = a[0] - b[0];4074    p[1] = a[1] - b[1];4075    p[2] = a[2] - b[2]; //perform rotation4076    r[0] = p[2] * Math.sin(rad) + p[0] * Math.cos(rad);4077    r[1] = p[1];4078    r[2] = p[2] * Math.cos(rad) - p[0] * Math.sin(rad); //translate to correct position4079    out[0] = r[0] + b[0];4080    out[1] = r[1] + b[1];4081    out[2] = r[2] + b[2];4082    return out;4083  }4084  /**4085   * Rotate a 3D vector around the z-axis4086   * @param {vec3} out The receiving vec34087   * @param {ReadonlyVec3} a The vec3 point to rotate4088   * @param {ReadonlyVec3} b The origin of the rotation4089   * @param {Number} rad The angle of rotation in radians4090   * @returns {vec3} out4091   */4092  function rotateZ$1(out, a, b, rad) {4093    var p = [],4094        r = []; //Translate point to the origin4095    p[0] = a[0] - b[0];4096    p[1] = a[1] - b[1];4097    p[2] = a[2] - b[2]; //perform rotation4098    r[0] = p[0] * Math.cos(rad) - p[1] * Math.sin(rad);4099    r[1] = p[0] * Math.sin(rad) + p[1] * Math.cos(rad);4100    r[2] = p[2]; //translate to correct position4101    out[0] = r[0] + b[0];4102    out[1] = r[1] + b[1];4103    out[2] = r[2] + b[2];4104    return out;4105  }4106  /**4107   * Get the angle between two 3D vectors4108   * @param {ReadonlyVec3} a The first operand4109   * @param {ReadonlyVec3} b The second operand4110   * @returns {Number} The angle in radians4111   */4112  function angle(a, b) {4113    var ax = a[0],4114        ay = a[1],4115        az = a[2],4116        bx = b[0],4117        by = b[1],4118        bz = b[2],4119        mag1 = Math.sqrt(ax * ax + ay * ay + az * az),4120        mag2 = Math.sqrt(bx * bx + by * by + bz * bz),4121        mag = mag1 * mag2,4122        cosine = mag && dot(a, b) / mag;4123    return Math.acos(Math.min(Math.max(cosine, -1), 1));4124  }4125  /**4126   * Set the components of a vec3 to zero4127   *4128   * @param {vec3} out the receiving vector4129   * @returns {vec3} out4130   */4131  function zero(out) {4132    out[0] = 0.0;4133    out[1] = 0.0;4134    out[2] = 0.0;4135    return out;4136  }4137  /**4138   * Returns a string representation of a vector4139   *4140   * @param {ReadonlyVec3} a vector to represent as a string4141   * @returns {String} string representation of the vector4142   */4143  function str$4(a) {4144    return "vec3(" + a[0] + ", " + a[1] + ", " + a[2] + ")";4145  }4146  /**4147   * Returns whether or not the vectors have exactly the same elements in the same position (when compared with ===)4148   *4149   * @param {ReadonlyVec3} a The first vector.4150   * @param {ReadonlyVec3} b The second vector.4151   * @returns {Boolean} True if the vectors are equal, false otherwise.4152   */4153  function exactEquals$4(a, b) {4154    return a[0] === b[0] && a[1] === b[1] && a[2] === b[2];4155  }4156  /**4157   * Returns whether or not the vectors have approximately the same elements in the same position.4158   *4159   * @param {ReadonlyVec3} a The first vector.4160   * @param {ReadonlyVec3} b The second vector.4161   * @returns {Boolean} True if the vectors are equal, false otherwise.4162   */4163  function equals$5(a, b) {4164    var a0 = a[0],4165        a1 = a[1],4166        a2 = a[2];4167    var b0 = b[0],4168        b1 = b[1],4169        b2 = b[2];4170    return Math.abs(a0 - b0) <= EPSILON * Math.max(1.0, Math.abs(a0), Math.abs(b0)) && Math.abs(a1 - b1) <= EPSILON * Math.max(1.0, Math.abs(a1), Math.abs(b1)) && Math.abs(a2 - b2) <= EPSILON * Math.max(1.0, Math.abs(a2), Math.abs(b2));4171  }4172  /**4173   * Alias for {@link vec3.subtract}4174   * @function4175   */4176  var sub$4 = subtract$4;4177  /**4178   * Alias for {@link vec3.multiply}4179   * @function4180   */4181  var mul$4 = multiply$4;4182  /**4183   * Alias for {@link vec3.divide}4184   * @function4185   */4186  var div = divide;4187  /**4188   * Alias for {@link vec3.distance}4189   * @function4190   */4191  var dist = distance;4192  /**4193   * Alias for {@link vec3.squaredDistance}4194   * @function4195   */4196  var sqrDist = squaredDistance;4197  /**4198   * Alias for {@link vec3.length}4199   * @function4200   */4201  var len = length;4202  /**4203   * Alias for {@link vec3.squaredLength}4204   * @function4205   */4206  var sqrLen = squaredLength;4207  /**4208   * Perform some operation over an array of vec3s.4209   *4210   * @param {Array} a the array of vectors to iterate over4211   * @param {Number} stride Number of elements between the start of each vec3. If 0 assumes tightly packed4212   * @param {Number} offset Number of elements to skip at the beginning of the array4213   * @param {Number} count Number of vec3s to iterate over. If 0 iterates over entire array4214   * @param {Function} fn Function to call for each vector in the array4215   * @param {Object} [arg] additional argument to pass to fn4216   * @returns {Array} a4217   * @function4218   */4219  var forEach = function () {4220    var vec = create$4();4221    return function (a, stride, offset, count, fn, arg) {4222      var i, l;4223      if (!stride) {4224        stride = 3;4225      }4226      if (!offset) {4227        offset = 0;4228      }4229      if (count) {4230        l = Math.min(count * stride + offset, a.length);4231      } else {4232        l = a.length;4233      }4234      for (i = offset; i < l; i += stride) {4235        vec[0] = a[i];4236        vec[1] = a[i + 1];4237        vec[2] = a[i + 2];4238        fn(vec, vec, arg);4239        a[i] = vec[0];4240        a[i + 1] = vec[1];4241        a[i + 2] = vec[2];4242      }4243      return a;4244    };4245  }();4246  var vec3 = /*#__PURE__*/Object.freeze({4247    __proto__: null,4248    create: create$4,4249    clone: clone$4,4250    length: length,4251    fromValues: fromValues$4,4252    copy: copy$4,4253    set: set$4,4254    add: add$4,4255    subtract: subtract$4,4256    multiply: multiply$4,4257    divide: divide,4258    ceil: ceil,4259    floor: floor,4260    min: min,4261    max: max,4262    round: round,4263    scale: scale$4,4264    scaleAndAdd: scaleAndAdd,4265    distance: distance,4266    squaredDistance: squaredDistance,4267    squaredLength: squaredLength,4268    negate: negate,4269    inverse: inverse,4270    normalize: normalize,4271    dot: dot,4272    cross: cross,4273    lerp: lerp,4274    hermite: hermite,4275    bezier: bezier,4276    random: random,4277    transformMat4: transformMat4,4278    transformMat3: transformMat3,4279    transformQuat: transformQuat,4280    rotateX: rotateX$1,4281    rotateY: rotateY$1,4282    rotateZ: rotateZ$1,4283    angle: angle,4284    zero: zero,4285    str: str$4,4286    exactEquals: exactEquals$4,4287    equals: equals$5,4288    sub: sub$4,4289    mul: mul$4,4290    div: div,4291    dist: dist,4292    sqrDist: sqrDist,4293    len: len,4294    sqrLen: sqrLen,4295    forEach: forEach4296  });4297  /**4298   * 4 Dimensional Vector4299   * @module vec44300   */4301  /**4302   * Creates a new, empty vec44303   *4304   * @returns {vec4} a new 4D vector4305   */4306  function create$5() {4307    var out = new ARRAY_TYPE(4);4308    if (ARRAY_TYPE != Float32Array) {4309      out[0] = 0;4310      out[1] = 0;4311      out[2] = 0;4312      out[3] = 0;4313    }4314    return out;4315  }4316  /**4317   * Creates a new vec4 initialized with values from an existing vector4318   *4319   * @param {ReadonlyVec4} a vector to clone4320   * @returns {vec4} a new 4D vector4321   */4322  function clone$5(a) {4323    var out = new ARRAY_TYPE(4);4324    out[0] = a[0];4325    out[1] = a[1];4326    out[2] = a[2];4327    out[3] = a[3];4328    return out;4329  }4330  /**4331   * Creates a new vec4 initialized with the given values4332   *4333   * @param {Number} x X component4334   * @param {Number} y Y component4335   * @param {Number} z Z component4336   * @param {Number} w W component4337   * @returns {vec4} a new 4D vector4338   */4339  function fromValues$5(x, y, z, w) {4340    var out = new ARRAY_TYPE(4);4341    out[0] = x;4342    out[1] = y;4343    out[2] = z;4344    out[3] = w;4345    return out;4346  }4347  /**4348   * Copy the values from one vec4 to another4349   *4350   * @param {vec4} out the receiving vector4351   * @param {ReadonlyVec4} a the source vector4352   * @returns {vec4} out4353   */4354  function copy$5(out, a) {4355    out[0] = a[0];4356    out[1] = a[1];4357    out[2] = a[2];4358    out[3] = a[3];4359    return out;4360  }4361  /**4362   * Set the components of a vec4 to the given values4363   *4364   * @param {vec4} out the receiving vector4365   * @param {Number} x X component4366   * @param {Number} y Y component4367   * @param {Number} z Z component4368   * @param {Number} w W component4369   * @returns {vec4} out4370   */4371  function set$5(out, x, y, z, w) {4372    out[0] = x;4373    out[1] = y;4374    out[2] = z;4375    out[3] = w;4376    return out;4377  }4378  /**4379   * Adds two vec4's4380   *4381   * @param {vec4} out the receiving vector4382   * @param {ReadonlyVec4} a the first operand4383   * @param {ReadonlyVec4} b the second operand4384   * @returns {vec4} out4385   */4386  function add$5(out, a, b) {4387    out[0] = a[0] + b[0];4388    out[1] = a[1] + b[1];4389    out[2] = a[2] + b[2];4390    out[3] = a[3] + b[3];4391    return out;4392  }4393  /**4394   * Subtracts vector b from vector a4395   *4396   * @param {vec4} out the receiving vector4397   * @param {ReadonlyVec4} a the first operand4398   * @param {ReadonlyVec4} b the second operand4399   * @returns {vec4} out4400   */4401  function subtract$5(out, a, b) {4402    out[0] = a[0] - b[0];4403    out[1] = a[1] - b[1];4404    out[2] = a[2] - b[2];4405    out[3] = a[3] - b[3];4406    return out;4407  }4408  /**4409   * Multiplies two vec4's4410   *4411   * @param {vec4} out the receiving vector4412   * @param {ReadonlyVec4} a the first operand4413   * @param {ReadonlyVec4} b the second operand4414   * @returns {vec4} out4415   */4416  function multiply$5(out, a, b) {4417    out[0] = a[0] * b[0];4418    out[1] = a[1] * b[1];4419    out[2] = a[2] * b[2];4420    out[3] = a[3] * b[3];4421    return out;4422  }4423  /**4424   * Divides two vec4's4425   *4426   * @param {vec4} out the receiving vector4427   * @param {ReadonlyVec4} a the first operand4428   * @param {ReadonlyVec4} b the second operand4429   * @returns {vec4} out4430   */4431  function divide$1(out, a, b) {4432    out[0] = a[0] / b[0];4433    out[1] = a[1] / b[1];4434    out[2] = a[2] / b[2];4435    out[3] = a[3] / b[3];4436    return out;4437  }4438  /**4439   * Math.ceil the components of a vec44440   *4441   * @param {vec4} out the receiving vector4442   * @param {ReadonlyVec4} a vector to ceil4443   * @returns {vec4} out4444   */4445  function ceil$1(out, a) {4446    out[0] = Math.ceil(a[0]);4447    out[1] = Math.ceil(a[1]);4448    out[2] = Math.ceil(a[2]);4449    out[3] = Math.ceil(a[3]);4450    return out;4451  }4452  /**4453   * Math.floor the components of a vec44454   *4455   * @param {vec4} out the receiving vector4456   * @param {ReadonlyVec4} a vector to floor4457   * @returns {vec4} out4458   */4459  function floor$1(out, a) {4460    out[0] = Math.floor(a[0]);4461    out[1] = Math.floor(a[1]);4462    out[2] = Math.floor(a[2]);4463    out[3] = Math.floor(a[3]);4464    return out;4465  }4466  /**4467   * Returns the minimum of two vec4's4468   *4469   * @param {vec4} out the receiving vector4470   * @param {ReadonlyVec4} a the first operand4471   * @param {ReadonlyVec4} b the second operand4472   * @returns {vec4} out4473   */4474  function min$1(out, a, b) {4475    out[0] = Math.min(a[0], b[0]);4476    out[1] = Math.min(a[1], b[1]);4477    out[2] = Math.min(a[2], b[2]);4478    out[3] = Math.min(a[3], b[3]);4479    return out;4480  }4481  /**4482   * Returns the maximum of two vec4's4483   *4484   * @param {vec4} out the receiving vector4485   * @param {ReadonlyVec4} a the first operand4486   * @param {ReadonlyVec4} b the second operand4487   * @returns {vec4} out4488   */4489  function max$1(out, a, b) {4490    out[0] = Math.max(a[0], b[0]);4491    out[1] = Math.max(a[1], b[1]);4492    out[2] = Math.max(a[2], b[2]);4493    out[3] = Math.max(a[3], b[3]);4494    return out;4495  }4496  /**4497   * Math.round the components of a vec44498   *4499   * @param {vec4} out the receiving vector4500   * @param {ReadonlyVec4} a vector to round4501   * @returns {vec4} out4502   */4503  function round$1(out, a) {4504    out[0] = Math.round(a[0]);4505    out[1] = Math.round(a[1]);4506    out[2] = Math.round(a[2]);4507    out[3] = Math.round(a[3]);4508    return out;4509  }4510  /**4511   * Scales a vec4 by a scalar number4512   *4513   * @param {vec4} out the receiving vector4514   * @param {ReadonlyVec4} a the vector to scale4515   * @param {Number} b amount to scale the vector by4516   * @returns {vec4} out4517   */4518  function scale$5(out, a, b) {4519    out[0] = a[0] * b;4520    out[1] = a[1] * b;4521    out[2] = a[2] * b;4522    out[3] = a[3] * b;4523    return out;4524  }4525  /**4526   * Adds two vec4's after scaling the second operand by a scalar value4527   *4528   * @param {vec4} out the receiving vector4529   * @param {ReadonlyVec4} a the first operand4530   * @param {ReadonlyVec4} b the second operand4531   * @param {Number} scale the amount to scale b by before adding4532   * @returns {vec4} out4533   */4534  function scaleAndAdd$1(out, a, b, scale) {4535    out[0] = a[0] + b[0] * scale;4536    out[1] = a[1] + b[1] * scale;4537    out[2] = a[2] + b[2] * scale;4538    out[3] = a[3] + b[3] * scale;4539    return out;4540  }4541  /**4542   * Calculates the euclidian distance between two vec4's4543   *4544   * @param {ReadonlyVec4} a the first operand4545   * @param {ReadonlyVec4} b the second operand4546   * @returns {Number} distance between a and b4547   */4548  function distance$1(a, b) {4549    var x = b[0] - a[0];4550    var y = b[1] - a[1];4551    var z = b[2] - a[2];4552    var w = b[3] - a[3];4553    return Math.hypot(x, y, z, w);4554  }4555  /**4556   * Calculates the squared euclidian distance between two vec4's4557   *4558   * @param {ReadonlyVec4} a the first operand4559   * @param {ReadonlyVec4} b the second operand4560   * @returns {Number} squared distance between a and b4561   */4562  function squaredDistance$1(a, b) {4563    var x = b[0] - a[0];4564    var y = b[1] - a[1];4565    var z = b[2] - a[2];4566    var w = b[3] - a[3];4567    return x * x + y * y + z * z + w * w;4568  }4569  /**4570   * Calculates the length of a vec44571   *4572   * @param {ReadonlyVec4} a vector to calculate length of4573   * @returns {Number} length of a4574   */4575  function length$1(a) {4576    var x = a[0];4577    var y = a[1];4578    var z = a[2];4579    var w = a[3];4580    return Math.hypot(x, y, z, w);4581  }4582  /**4583   * Calculates the squared length of a vec44584   *4585   * @param {ReadonlyVec4} a vector to calculate squared length of4586   * @returns {Number} squared length of a4587   */4588  function squaredLength$1(a) {4589    var x = a[0];4590    var y = a[1];4591    var z = a[2];4592    var w = a[3];4593    return x * x + y * y + z * z + w * w;4594  }4595  /**4596   * Negates the components of a vec44597   *4598   * @param {vec4} out the receiving vector4599   * @param {ReadonlyVec4} a vector to negate4600   * @returns {vec4} out4601   */4602  function negate$1(out, a) {4603    out[0] = -a[0];4604    out[1] = -a[1];4605    out[2] = -a[2];4606    out[3] = -a[3];4607    return out;4608  }4609  /**4610   * Returns the inverse of the components of a vec44611   *4612   * @param {vec4} out the receiving vector4613   * @param {ReadonlyVec4} a vector to invert4614   * @returns {vec4} out4615   */4616  function inverse$1(out, a) {4617    out[0] = 1.0 / a[0];4618    out[1] = 1.0 / a[1];4619    out[2] = 1.0 / a[2];4620    out[3] = 1.0 / a[3];4621    return out;4622  }4623  /**4624   * Normalize a vec44625   *4626   * @param {vec4} out the receiving vector4627   * @param {ReadonlyVec4} a vector to normalize4628   * @returns {vec4} out4629   */4630  function normalize$1(out, a) {4631    var x = a[0];4632    var y = a[1];4633    var z = a[2];4634    var w = a[3];4635    var len = x * x + y * y + z * z + w * w;4636    if (len > 0) {4637      len = 1 / Math.sqrt(len);4638    }4639    out[0] = x * len;4640    out[1] = y * len;4641    out[2] = z * len;4642    out[3] = w * len;4643    return out;4644  }4645  /**4646   * Calculates the dot product of two vec4's4647   *4648   * @param {ReadonlyVec4} a the first operand4649   * @param {ReadonlyVec4} b the second operand4650   * @returns {Number} dot product of a and b4651   */4652  function dot$1(a, b) {4653    return a[0] * b[0] + a[1] * b[1] + a[2] * b[2] + a[3] * b[3];4654  }4655  /**4656   * Returns the cross-product of three vectors in a 4-dimensional space4657   *4658   * @param {ReadonlyVec4} result the receiving vector4659   * @param {ReadonlyVec4} U the first vector4660   * @param {ReadonlyVec4} V the second vector4661   * @param {ReadonlyVec4} W the third vector4662   * @returns {vec4} result4663   */4664  function cross$1(out, u, v, w) {4665    var A = v[0] * w[1] - v[1] * w[0],4666        B = v[0] * w[2] - v[2] * w[0],4667        C = v[0] * w[3] - v[3] * w[0],4668        D = v[1] * w[2] - v[2] * w[1],4669        E = v[1] * w[3] - v[3] * w[1],4670        F = v[2] * w[3] - v[3] * w[2];4671    var G = u[0];4672    var H = u[1];4673    var I = u[2];4674    var J = u[3];4675    out[0] = H * F - I * E + J * D;4676    out[1] = -(G * F) + I * C - J * B;4677    out[2] = G * E - H * C + J * A;4678    out[3] = -(G * D) + H * B - I * A;4679    return out;4680  }4681  /**4682   * Performs a linear interpolation between two vec4's4683   *4684   * @param {vec4} out the receiving vector4685   * @param {ReadonlyVec4} a the first operand4686   * @param {ReadonlyVec4} b the second operand4687   * @param {Number} t interpolation amount, in the range [0-1], between the two inputs4688   * @returns {vec4} out4689   */4690  function lerp$1(out, a, b, t) {4691    var ax = a[0];4692    var ay = a[1];4693    var az = a[2];4694    var aw = a[3];4695    out[0] = ax + t * (b[0] - ax);4696    out[1] = ay + t * (b[1] - ay);4697    out[2] = az + t * (b[2] - az);4698    out[3] = aw + t * (b[3] - aw);4699    return out;4700  }4701  /**4702   * Generates a random vector with the given scale4703   *4704   * @param {vec4} out the receiving vector4705   * @param {Number} [scale] Length of the resulting vector. If ommitted, a unit vector will be returned4706   * @returns {vec4} out4707   */4708  function random$1(out, scale) {4709    scale = scale || 1.0; // Marsaglia, George. Choosing a Point from the Surface of a4710    // Sphere. Ann. Math. Statist. 43 (1972), no. 2, 645--646.4711    // http://projecteuclid.org/euclid.aoms/1177692644;4712    var v1, v2, v3, v4;4713    var s1, s2;4714    do {4715      v1 = RANDOM() * 2 - 1;4716      v2 = RANDOM() * 2 - 1;4717      s1 = v1 * v1 + v2 * v2;4718    } while (s1 >= 1);4719    do {4720      v3 = RANDOM() * 2 - 1;4721      v4 = RANDOM() * 2 - 1;4722      s2 = v3 * v3 + v4 * v4;4723    } while (s2 >= 1);4724    var d = Math.sqrt((1 - s1) / s2);4725    out[0] = scale * v1;4726    out[1] = scale * v2;4727    out[2] = scale * v3 * d;4728    out[3] = scale * v4 * d;4729    return out;4730  }4731  /**4732   * Transforms the vec4 with a mat4.4733   *4734   * @param {vec4} out the receiving vector4735   * @param {ReadonlyVec4} a the vector to transform4736   * @param {ReadonlyMat4} m matrix to transform with4737   * @returns {vec4} out4738   */4739  function transformMat4$1(out, a, m) {4740    var x = a[0],4741        y = a[1],4742        z = a[2],4743        w = a[3];4744    out[0] = m[0] * x + m[4] * y + m[8] * z + m[12] * w;4745    out[1] = m[1] * x + m[5] * y + m[9] * z + m[13] * w;4746    out[2] = m[2] * x + m[6] * y + m[10] * z + m[14] * w;4747    out[3] = m[3] * x + m[7] * y + m[11] * z + m[15] * w;4748    return out;4749  }4750  /**4751   * Transforms the vec4 with a quat4752   *4753   * @param {vec4} out the receiving vector4754   * @param {ReadonlyVec4} a the vector to transform4755   * @param {ReadonlyQuat} q quaternion to transform with4756   * @returns {vec4} out4757   */4758  function transformQuat$1(out, a, q) {4759    var x = a[0],4760        y = a[1],4761        z = a[2];4762    var qx = q[0],4763        qy = q[1],4764        qz = q[2],4765        qw = q[3]; // calculate quat * vec4766    var ix = qw * x + qy * z - qz * y;4767    var iy = qw * y + qz * x - qx * z;4768    var iz = qw * z + qx * y - qy * x;4769    var iw = -qx * x - qy * y - qz * z; // calculate result * inverse quat4770    out[0] = ix * qw + iw * -qx + iy * -qz - iz * -qy;4771    out[1] = iy * qw + iw * -qy + iz * -qx - ix * -qz;4772    out[2] = iz * qw + iw * -qz + ix * -qy - iy * -qx;4773    out[3] = a[3];4774    return out;4775  }4776  /**4777   * Set the components of a vec4 to zero4778   *4779   * @param {vec4} out the receiving vector4780   * @returns {vec4} out4781   */4782  function zero$1(out) {4783    out[0] = 0.0;4784    out[1] = 0.0;4785    out[2] = 0.0;4786    out[3] = 0.0;4787    return out;4788  }4789  /**4790   * Returns a string representation of a vector4791   *4792   * @param {ReadonlyVec4} a vector to represent as a string4793   * @returns {String} string representation of the vector4794   */4795  function str$5(a) {4796    return "vec4(" + a[0] + ", " + a[1] + ", " + a[2] + ", " + a[3] + ")";4797  }4798  /**4799   * Returns whether or not the vectors have exactly the same elements in the same position (when compared with ===)4800   *4801   * @param {ReadonlyVec4} a The first vector.4802   * @param {ReadonlyVec4} b The second vector.4803   * @returns {Boolean} True if the vectors are equal, false otherwise.4804   */4805  function exactEquals$5(a, b) {4806    return a[0] === b[0] && a[1] === b[1] && a[2] === b[2] && a[3] === b[3];4807  }4808  /**4809   * Returns whether or not the vectors have approximately the same elements in the same position.4810   *4811   * @param {ReadonlyVec4} a The first vector.4812   * @param {ReadonlyVec4} b The second vector.4813   * @returns {Boolean} True if the vectors are equal, false otherwise.4814   */4815  function equals$6(a, b) {4816    var a0 = a[0],4817        a1 = a[1],4818        a2 = a[2],4819        a3 = a[3];4820    var b0 = b[0],4821        b1 = b[1],4822        b2 = b[2],4823        b3 = b[3];4824    return Math.abs(a0 - b0) <= EPSILON * Math.max(1.0, Math.abs(a0), Math.abs(b0)) && Math.abs(a1 - b1) <= EPSILON * Math.max(1.0, Math.abs(a1), Math.abs(b1)) && Math.abs(a2 - b2) <= EPSILON * Math.max(1.0, Math.abs(a2), Math.abs(b2)) && Math.abs(a3 - b3) <= EPSILON * Math.max(1.0, Math.abs(a3), Math.abs(b3));4825  }4826  /**4827   * Alias for {@link vec4.subtract}4828   * @function4829   */4830  var sub$5 = subtract$5;4831  /**4832   * Alias for {@link vec4.multiply}4833   * @function4834   */4835  var mul$5 = multiply$5;4836  /**4837   * Alias for {@link vec4.divide}4838   * @function4839   */4840  var div$1 = divide$1;4841  /**4842   * Alias for {@link vec4.distance}4843   * @function4844   */4845  var dist$1 = distance$1;4846  /**4847   * Alias for {@link vec4.squaredDistance}4848   * @function4849   */4850  var sqrDist$1 = squaredDistance$1;4851  /**4852   * Alias for {@link vec4.length}4853   * @function4854   */4855  var len$1 = length$1;4856  /**4857   * Alias for {@link vec4.squaredLength}4858   * @function4859   */4860  var sqrLen$1 = squaredLength$1;4861  /**4862   * Perform some operation over an array of vec4s.4863   *4864   * @param {Array} a the array of vectors to iterate over4865   * @param {Number} stride Number of elements between the start of each vec4. If 0 assumes tightly packed4866   * @param {Number} offset Number of elements to skip at the beginning of the array4867   * @param {Number} count Number of vec4s to iterate over. If 0 iterates over entire array4868   * @param {Function} fn Function to call for each vector in the array4869   * @param {Object} [arg] additional argument to pass to fn4870   * @returns {Array} a4871   * @function4872   */4873  var forEach$1 = function () {4874    var vec = create$5();4875    return function (a, stride, offset, count, fn, arg) {4876      var i, l;4877      if (!stride) {4878        stride = 4;4879      }4880      if (!offset) {4881        offset = 0;4882      }4883      if (count) {4884        l = Math.min(count * stride + offset, a.length);4885      } else {4886        l = a.length;4887      }4888      for (i = offset; i < l; i += stride) {4889        vec[0] = a[i];4890        vec[1] = a[i + 1];4891        vec[2] = a[i + 2];4892        vec[3] = a[i + 3];4893        fn(vec, vec, arg);4894        a[i] = vec[0];4895        a[i + 1] = vec[1];4896        a[i + 2] = vec[2];4897        a[i + 3] = vec[3];4898      }4899      return a;4900    };4901  }();4902  var vec4 = /*#__PURE__*/Object.freeze({4903    __proto__: null,4904    create: create$5,4905    clone: clone$5,4906    fromValues: fromValues$5,4907    copy: copy$5,4908    set: set$5,4909    add: add$5,4910    subtract: subtract$5,4911    multiply: multiply$5,4912    divide: divide$1,4913    ceil: ceil$1,4914    floor: floor$1,4915    min: min$1,4916    max: max$1,4917    round: round$1,4918    scale: scale$5,4919    scaleAndAdd: scaleAndAdd$1,4920    distance: distance$1,4921    squaredDistance: squaredDistance$1,4922    length: length$1,4923    squaredLength: squaredLength$1,4924    negate: negate$1,4925    inverse: inverse$1,4926    normalize: normalize$1,4927    dot: dot$1,4928    cross: cross$1,4929    lerp: lerp$1,4930    random: random$1,4931    transformMat4: transformMat4$1,4932    transformQuat: transformQuat$1,4933    zero: zero$1,4934    str: str$5,4935    exactEquals: exactEquals$5,4936    equals: equals$6,4937    sub: sub$5,4938    mul: mul$5,4939    div: div$1,4940    dist: dist$1,4941    sqrDist: sqrDist$1,4942    len: len$1,4943    sqrLen: sqrLen$1,4944    forEach: forEach$14945  });4946  /**4947   * Quaternion4948   * @module quat4949   */4950  /**4951   * Creates a new identity quat4952   *4953   * @returns {quat} a new quaternion4954   */4955  function create$6() {4956    var out = new ARRAY_TYPE(4);4957    if (ARRAY_TYPE != Float32Array) {4958      out[0] = 0;4959      out[1] = 0;4960      out[2] = 0;4961    }4962    out[3] = 1;4963    return out;4964  }4965  /**4966   * Set a quat to the identity quaternion4967   *4968   * @param {quat} out the receiving quaternion4969   * @returns {quat} out4970   */4971  function identity$4(out) {4972    out[0] = 0;4973    out[1] = 0;4974    out[2] = 0;4975    out[3] = 1;4976    return out;4977  }4978  /**4979   * Sets a quat from the given angle and rotation axis,4980   * then returns it.4981   *4982   * @param {quat} out the receiving quaternion4983   * @param {ReadonlyVec3} axis the axis around which to rotate4984   * @param {Number} rad the angle in radians4985   * @returns {quat} out4986   **/4987  function setAxisAngle(out, axis, rad) {4988    rad = rad * 0.5;4989    var s = Math.sin(rad);4990    out[0] = s * axis[0];4991    out[1] = s * axis[1];4992    out[2] = s * axis[2];4993    out[3] = Math.cos(rad);4994    return out;4995  }4996  /**4997   * Gets the rotation axis and angle for a given4998   *  quaternion. If a quaternion is created with4999   *  setAxisAngle, this method will return the same5000   *  values as providied in the original parameter list5001   *  OR functionally equivalent values.5002   * Example: The quaternion formed by axis [0, 0, 1] and5003   *  angle -90 is the same as the quaternion formed by5004   *  [0, 0, 1] and 270. This method favors the latter.5005   * @param  {vec3} out_axis  Vector receiving the axis of rotation5006   * @param  {ReadonlyQuat} q     Quaternion to be decomposed5007   * @return {Number}     Angle, in radians, of the rotation5008   */5009  function getAxisAngle(out_axis, q) {5010    var rad = Math.acos(q[3]) * 2.0;5011    var s = Math.sin(rad / 2.0);5012    if (s > EPSILON) {5013      out_axis[0] = q[0] / s;5014      out_axis[1] = q[1] / s;5015      out_axis[2] = q[2] / s;5016    } else {5017      // If s is zero, return any axis (no rotation - axis does not matter)5018      out_axis[0] = 1;5019      out_axis[1] = 0;5020      out_axis[2] = 0;5021    }5022    return rad;5023  }5024  /**5025   * Gets the angular distance between two unit quaternions5026   *5027   * @param  {ReadonlyQuat} a     Origin unit quaternion5028   * @param  {ReadonlyQuat} b     Destination unit quaternion5029   * @return {Number}     Angle, in radians, between the two quaternions5030   */5031  function getAngle(a, b) {5032    var dotproduct = dot$2(a, b);5033    return Math.acos(2 * dotproduct * dotproduct - 1);5034  }5035  /**5036   * Multiplies two quat's5037   *5038   * @param {quat} out the receiving quaternion5039   * @param {ReadonlyQuat} a the first operand5040   * @param {ReadonlyQuat} b the second operand5041   * @returns {quat} out5042   */5043  function multiply$6(out, a, b) {5044    var ax = a[0],5045        ay = a[1],5046        az = a[2],5047        aw = a[3];5048    var bx = b[0],5049        by = b[1],5050        bz = b[2],5051        bw = b[3];5052    out[0] = ax * bw + aw * bx + ay * bz - az * by;5053    out[1] = ay * bw + aw * by + az * bx - ax * bz;5054    out[2] = az * bw + aw * bz + ax * by - ay * bx;5055    out[3] = aw * bw - ax * bx - ay * by - az * bz;5056    return out;5057  }5058  /**5059   * Rotates a quaternion by the given angle about the X axis5060   *5061   * @param {quat} out quat receiving operation result5062   * @param {ReadonlyQuat} a quat to rotate5063   * @param {number} rad angle (in radians) to rotate5064   * @returns {quat} out5065   */5066  function rotateX$2(out, a, rad) {5067    rad *= 0.5;5068    var ax = a[0],5069        ay = a[1],5070        az = a[2],5071        aw = a[3];5072    var bx = Math.sin(rad),5073        bw = Math.cos(rad);5074    out[0] = ax * bw + aw * bx;5075    out[1] = ay * bw + az * bx;5076    out[2] = az * bw - ay * bx;5077    out[3] = aw * bw - ax * bx;5078    return out;5079  }5080  /**5081   * Rotates a quaternion by the given angle about the Y axis5082   *5083   * @param {quat} out quat receiving operation result5084   * @param {ReadonlyQuat} a quat to rotate5085   * @param {number} rad angle (in radians) to rotate5086   * @returns {quat} out5087   */5088  function rotateY$2(out, a, rad) {5089    rad *= 0.5;5090    var ax = a[0],5091        ay = a[1],5092        az = a[2],5093        aw = a[3];5094    var by = Math.sin(rad),5095        bw = Math.cos(rad);5096    out[0] = ax * bw - az * by;5097    out[1] = ay * bw + aw * by;5098    out[2] = az * bw + ax * by;5099    out[3] = aw * bw - ay * by;5100    return out;5101  }5102  /**5103   * Rotates a quaternion by the given angle about the Z axis5104   *5105   * @param {quat} out quat receiving operation result5106   * @param {ReadonlyQuat} a quat to rotate5107   * @param {number} rad angle (in radians) to rotate5108   * @returns {quat} out5109   */5110  function rotateZ$2(out, a, rad) {5111    rad *= 0.5;5112    var ax = a[0],5113        ay = a[1],5114        az = a[2],5115        aw = a[3];5116    var bz = Math.sin(rad),5117        bw = Math.cos(rad);5118    out[0] = ax * bw + ay * bz;5119    out[1] = ay * bw - ax * bz;5120    out[2] = az * bw + aw * bz;5121    out[3] = aw * bw - az * bz;5122    return out;5123  }5124  /**5125   * Calculates the W component of a quat from the X, Y, and Z components.5126   * Assumes that quaternion is 1 unit in length.5127   * Any existing W component will be ignored.5128   *5129   * @param {quat} out the receiving quaternion5130   * @param {ReadonlyQuat} a quat to calculate W component of5131   * @returns {quat} out5132   */5133  function calculateW(out, a) {5134    var x = a[0],5135        y = a[1],5136        z = a[2];5137    out[0] = x;5138    out[1] = y;5139    out[2] = z;5140    out[3] = Math.sqrt(Math.abs(1.0 - x * x - y * y - z * z));5141    return out;5142  }5143  /**5144   * Calculate the exponential of a unit quaternion.5145   *5146   * @param {quat} out the receiving quaternion5147   * @param {ReadonlyQuat} a quat to calculate the exponential of5148   * @returns {quat} out5149   */5150  function exp(out, a) {5151    var x = a[0],5152        y = a[1],5153        z = a[2],5154        w = a[3];5155    var r = Math.sqrt(x * x + y * y + z * z);5156    var et = Math.exp(w);5157    var s = r > 0 ? et * Math.sin(r) / r : 0;5158    out[0] = x * s;5159    out[1] = y * s;5160    out[2] = z * s;5161    out[3] = et * Math.cos(r);5162    return out;5163  }5164  /**5165   * Calculate the natural logarithm of a unit quaternion.5166   *5167   * @param {quat} out the receiving quaternion5168   * @param {ReadonlyQuat} a quat to calculate the exponential of5169   * @returns {quat} out5170   */5171  function ln(out, a) {5172    var x = a[0],5173        y = a[1],5174        z = a[2],5175        w = a[3];5176    var r = Math.sqrt(x * x + y * y + z * z);5177    var t = r > 0 ? Math.atan2(r, w) / r : 0;5178    out[0] = x * t;5179    out[1] = y * t;5180    out[2] = z * t;5181    out[3] = 0.5 * Math.log(x * x + y * y + z * z + w * w);5182    return out;5183  }5184  /**5185   * Calculate the scalar power of a unit quaternion.5186   *5187   * @param {quat} out the receiving quaternion5188   * @param {ReadonlyQuat} a quat to calculate the exponential of5189   * @param {Number} b amount to scale the quaternion by5190   * @returns {quat} out5191   */5192  function pow(out, a, b) {5193    ln(out, a);5194    scale$6(out, out, b);5195    exp(out, out);5196    return out;5197  }5198  /**5199   * Performs a spherical linear interpolation between two quat5200   *5201   * @param {quat} out the receiving quaternion5202   * @param {ReadonlyQuat} a the first operand5203   * @param {ReadonlyQuat} b the second operand5204   * @param {Number} t interpolation amount, in the range [0-1], between the two inputs5205   * @returns {quat} out5206   */5207  function slerp(out, a, b, t) {5208    // benchmarks:5209    //    http://jsperf.com/quaternion-slerp-implementations5210    var ax = a[0],5211        ay = a[1],5212        az = a[2],5213        aw = a[3];5214    var bx = b[0],5215        by = b[1],5216        bz = b[2],5217        bw = b[3];5218    var omega, cosom, sinom, scale0, scale1; // calc cosine5219    cosom = ax * bx + ay * by + az * bz + aw * bw; // adjust signs (if necessary)5220    if (cosom < 0.0) {5221      cosom = -cosom;5222      bx = -bx;5223      by = -by;5224      bz = -bz;5225      bw = -bw;5226    } // calculate coefficients5227    if (1.0 - cosom > EPSILON) {5228      // standard case (slerp)5229      omega = Math.acos(cosom);5230      sinom = Math.sin(omega);5231      scale0 = Math.sin((1.0 - t) * omega) / sinom;5232      scale1 = Math.sin(t * omega) / sinom;5233    } else {5234      // "from" and "to" quaternions are very close5235      //  ... so we can do a linear interpolation5236      scale0 = 1.0 - t;5237      scale1 = t;5238    } // calculate final values5239    out[0] = scale0 * ax + scale1 * bx;5240    out[1] = scale0 * ay + scale1 * by;5241    out[2] = scale0 * az + scale1 * bz;5242    out[3] = scale0 * aw + scale1 * bw;5243    return out;5244  }5245  /**5246   * Generates a random unit quaternion5247   *5248   * @param {quat} out the receiving quaternion5249   * @returns {quat} out5250   */5251  function random$2(out) {5252    // Implementation of http://planning.cs.uiuc.edu/node198.html5253    // TODO: Calling random 3 times is probably not the fastest solution5254    var u1 = RANDOM();5255    var u2 = RANDOM();5256    var u3 = RANDOM();5257    var sqrt1MinusU1 = Math.sqrt(1 - u1);5258    var sqrtU1 = Math.sqrt(u1);5259    out[0] = sqrt1MinusU1 * Math.sin(2.0 * Math.PI * u2);5260    out[1] = sqrt1MinusU1 * Math.cos(2.0 * Math.PI * u2);5261    out[2] = sqrtU1 * Math.sin(2.0 * Math.PI * u3);5262    out[3] = sqrtU1 * Math.cos(2.0 * Math.PI * u3);5263    return out;5264  }5265  /**5266   * Calculates the inverse of a quat5267   *5268   * @param {quat} out the receiving quaternion5269   * @param {ReadonlyQuat} a quat to calculate inverse of5270   * @returns {quat} out5271   */5272  function invert$4(out, a) {5273    var a0 = a[0],5274        a1 = a[1],5275        a2 = a[2],5276        a3 = a[3];5277    var dot = a0 * a0 + a1 * a1 + a2 * a2 + a3 * a3;5278    var invDot = dot ? 1.0 / dot : 0; // TODO: Would be faster to return [0,0,0,0] immediately if dot == 05279    out[0] = -a0 * invDot;5280    out[1] = -a1 * invDot;5281    out[2] = -a2 * invDot;5282    out[3] = a3 * invDot;5283    return out;5284  }5285  /**5286   * Calculates the conjugate of a quat5287   * If the quaternion is normalized, this function is faster than quat.inverse and produces the same result.5288   *5289   * @param {quat} out the receiving quaternion5290   * @param {ReadonlyQuat} a quat to calculate conjugate of5291   * @returns {quat} out5292   */5293  function conjugate(out, a) {5294    out[0] = -a[0];5295    out[1] = -a[1];5296    out[2] = -a[2];5297    out[3] = a[3];5298    return out;5299  }5300  /**5301   * Creates a quaternion from the given 3x3 rotation matrix.5302   *5303   * NOTE: The resultant quaternion is not normalized, so you should be sure5304   * to renormalize the quaternion yourself where necessary.5305   *5306   * @param {quat} out the receiving quaternion5307   * @param {ReadonlyMat3} m rotation matrix5308   * @returns {quat} out5309   * @function5310   */5311  function fromMat3(out, m) {5312    // Algorithm in Ken Shoemake's article in 1987 SIGGRAPH course notes5313    // article "Quaternion Calculus and Fast Animation".5314    var fTrace = m[0] + m[4] + m[8];5315    var fRoot;5316    if (fTrace > 0.0) {5317      // |w| > 1/2, may as well choose w > 1/25318      fRoot = Math.sqrt(fTrace + 1.0); // 2w5319      out[3] = 0.5 * fRoot;5320      fRoot = 0.5 / fRoot; // 1/(4w)5321      out[0] = (m[5] - m[7]) * fRoot;5322      out[1] = (m[6] - m[2]) * fRoot;5323      out[2] = (m[1] - m[3]) * fRoot;5324    } else {5325      // |w| <= 1/25326      var i = 0;5327      if (m[4] > m[0]) i = 1;5328      if (m[8] > m[i * 3 + i]) i = 2;5329      var j = (i + 1) % 3;5330      var k = (i + 2) % 3;5331      fRoot = Math.sqrt(m[i * 3 + i] - m[j * 3 + j] - m[k * 3 + k] + 1.0);5332      out[i] = 0.5 * fRoot;5333      fRoot = 0.5 / fRoot;5334      out[3] = (m[j * 3 + k] - m[k * 3 + j]) * fRoot;5335      out[j] = (m[j * 3 + i] + m[i * 3 + j]) * fRoot;5336      out[k] = (m[k * 3 + i] + m[i * 3 + k]) * fRoot;5337    }5338    return out;5339  }5340  /**5341   * Creates a quaternion from the given euler angle x, y, z.5342   *5343   * @param {quat} out the receiving quaternion5344   * @param {x} Angle to rotate around X axis in degrees.5345   * @param {y} Angle to rotate around Y axis in degrees.5346   * @param {z} Angle to rotate around Z axis in degrees.5347   * @returns {quat} out5348   * @function5349   */5350  function fromEuler(out, x, y, z) {5351    var halfToRad = 0.5 * Math.PI / 180.0;5352    x *= halfToRad;5353    y *= halfToRad;5354    z *= halfToRad;5355    var sx = Math.sin(x);5356    var cx = Math.cos(x);5357    var sy = Math.sin(y);5358    var cy = Math.cos(y);5359    var sz = Math.sin(z);5360    var cz = Math.cos(z);5361    out[0] = sx * cy * cz - cx * sy * sz;5362    out[1] = cx * sy * cz + sx * cy * sz;5363    out[2] = cx * cy * sz - sx * sy * cz;5364    out[3] = cx * cy * cz + sx * sy * sz;5365    return out;5366  }5367  /**5368   * Returns a string representation of a quatenion5369   *5370   * @param {ReadonlyQuat} a vector to represent as a string5371   * @returns {String} string representation of the vector5372   */5373  function str$6(a) {5374    return "quat(" + a[0] + ", " + a[1] + ", " + a[2] + ", " + a[3] + ")";5375  }5376  /**5377   * Creates a new quat initialized with values from an existing quaternion5378   *5379   * @param {ReadonlyQuat} a quaternion to clone5380   * @returns {quat} a new quaternion5381   * @function5382   */5383  var clone$6 = clone$5;5384  /**5385   * Creates a new quat initialized with the given values5386   *5387   * @param {Number} x X component5388   * @param {Number} y Y component5389   * @param {Number} z Z component5390   * @param {Number} w W component5391   * @returns {quat} a new quaternion5392   * @function5393   */5394  var fromValues$6 = fromValues$5;5395  /**5396   * Copy the values from one quat to another5397   *5398   * @param {quat} out the receiving quaternion5399   * @param {ReadonlyQuat} a the source quaternion5400   * @returns {quat} out5401   * @function5402   */5403  var copy$6 = copy$5;5404  /**5405   * Set the components of a quat to the given values5406   *5407   * @param {quat} out the receiving quaternion5408   * @param {Number} x X component5409   * @param {Number} y Y component5410   * @param {Number} z Z component5411   * @param {Number} w W component5412   * @returns {quat} out5413   * @function5414   */5415  var set$6 = set$5;5416  /**5417   * Adds two quat's5418   *5419   * @param {quat} out the receiving quaternion5420   * @param {ReadonlyQuat} a the first operand5421   * @param {ReadonlyQuat} b the second operand5422   * @returns {quat} out5423   * @function5424   */5425  var add$6 = add$5;5426  /**5427   * Alias for {@link quat.multiply}5428   * @function5429   */5430  var mul$6 = multiply$6;5431  /**5432   * Scales a quat by a scalar number5433   *5434   * @param {quat} out the receiving vector5435   * @param {ReadonlyQuat} a the vector to scale5436   * @param {Number} b amount to scale the vector by5437   * @returns {quat} out5438   * @function5439   */5440  var scale$6 = scale$5;5441  /**5442   * Calculates the dot product of two quat's5443   *5444   * @param {ReadonlyQuat} a the first operand5445   * @param {ReadonlyQuat} b the second operand5446   * @returns {Number} dot product of a and b5447   * @function5448   */5449  var dot$2 = dot$1;5450  /**5451   * Performs a linear interpolation between two quat's5452   *5453   * @param {quat} out the receiving quaternion5454   * @param {ReadonlyQuat} a the first operand5455   * @param {ReadonlyQuat} b the second operand5456   * @param {Number} t interpolation amount, in the range [0-1], between the two inputs5457   * @returns {quat} out5458   * @function5459   */5460  var lerp$2 = lerp$1;5461  /**5462   * Calculates the length of a quat5463   *5464   * @param {ReadonlyQuat} a vector to calculate length of5465   * @returns {Number} length of a5466   */5467  var length$2 = length$1;5468  /**5469   * Alias for {@link quat.length}5470   * @function5471   */5472  var len$2 = length$2;5473  /**5474   * Calculates the squared length of a quat5475   *5476   * @param {ReadonlyQuat} a vector to calculate squared length of5477   * @returns {Number} squared length of a5478   * @function5479   */5480  var squaredLength$2 = squaredLength$1;5481  /**5482   * Alias for {@link quat.squaredLength}5483   * @function5484   */5485  var sqrLen$2 = squaredLength$2;5486  /**5487   * Normalize a quat5488   *5489   * @param {quat} out the receiving quaternion5490   * @param {ReadonlyQuat} a quaternion to normalize5491   * @returns {quat} out5492   * @function5493   */5494  var normalize$2 = normalize$1;5495  /**5496   * Returns whether or not the quaternions have exactly the same elements in the same position (when compared with ===)5497   *5498   * @param {ReadonlyQuat} a The first quaternion.5499   * @param {ReadonlyQuat} b The second quaternion.5500   * @returns {Boolean} True if the vectors are equal, false otherwise.5501   */5502  var exactEquals$6 = exactEquals$5;5503  /**5504   * Returns whether or not the quaternions have approximately the same elements in the same position.5505   *5506   * @param {ReadonlyQuat} a The first vector.5507   * @param {ReadonlyQuat} b The second vector.5508   * @returns {Boolean} True if the vectors are equal, false otherwise.5509   */5510  var equals$7 = equals$6;5511  /**5512   * Sets a quaternion to represent the shortest rotation from one5513   * vector to another.5514   *5515   * Both vectors are assumed to be unit length.5516   *5517   * @param {quat} out the receiving quaternion.5518   * @param {ReadonlyVec3} a the initial vector5519   * @param {ReadonlyVec3} b the destination vector5520   * @returns {quat} out5521   */5522  var rotationTo = function () {5523    var tmpvec3 = create$4();5524    var xUnitVec3 = fromValues$4(1, 0, 0);5525    var yUnitVec3 = fromValues$4(0, 1, 0);5526    return function (out, a, b) {5527      var dot$1 = dot(a, b);5528      if (dot$1 < -0.999999) {5529        cross(tmpvec3, xUnitVec3, a);5530        if (len(tmpvec3) < 0.000001) cross(tmpvec3, yUnitVec3, a);5531        normalize(tmpvec3, tmpvec3);5532        setAxisAngle(out, tmpvec3, Math.PI);5533        return out;5534      } else if (dot$1 > 0.999999) {5535        out[0] = 0;5536        out[1] = 0;5537        out[2] = 0;5538        out[3] = 1;5539        return out;5540      } else {5541        cross(tmpvec3, a, b);5542        out[0] = tmpvec3[0];5543        out[1] = tmpvec3[1];5544        out[2] = tmpvec3[2];5545        out[3] = 1 + dot$1;5546        return normalize$2(out, out);5547      }5548    };5549  }();5550  /**5551   * Performs a spherical linear interpolation with two control points5552   *5553   * @param {quat} out the receiving quaternion5554   * @param {ReadonlyQuat} a the first operand5555   * @param {ReadonlyQuat} b the second operand5556   * @param {ReadonlyQuat} c the third operand5557   * @param {ReadonlyQuat} d the fourth operand5558   * @param {Number} t interpolation amount, in the range [0-1], between the two inputs5559   * @returns {quat} out5560   */5561  var sqlerp = function () {5562    var temp1 = create$6();5563    var temp2 = create$6();5564    return function (out, a, b, c, d, t) {5565      slerp(temp1, a, d, t);5566      slerp(temp2, b, c, t);5567      slerp(out, temp1, temp2, 2 * t * (1 - t));5568      return out;5569    };5570  }();5571  /**5572   * Sets the specified quaternion with values corresponding to the given5573   * axes. Each axis is a vec3 and is expected to be unit length and5574   * perpendicular to all other specified axes.5575   *5576   * @param {ReadonlyVec3} view  the vector representing the viewing direction5577   * @param {ReadonlyVec3} right the vector representing the local "right" direction5578   * @param {ReadonlyVec3} up    the vector representing the local "up" direction5579   * @returns {quat} out5580   */5581  var setAxes = function () {5582    var matr = create$2();5583    return function (out, view, right, up) {5584      matr[0] = right[0];5585      matr[3] = right[1];5586      matr[6] = right[2];5587      matr[1] = up[0];5588      matr[4] = up[1];5589      matr[7] = up[2];5590      matr[2] = -view[0];5591      matr[5] = -view[1];5592      matr[8] = -view[2];5593      return normalize$2(out, fromMat3(out, matr));5594    };5595  }();5596  var quat = /*#__PURE__*/Object.freeze({5597    __proto__: null,5598    create: create$6,5599    identity: identity$4,5600    setAxisAngle: setAxisAngle,5601    getAxisAngle: getAxisAngle,5602    getAngle: getAngle,5603    multiply: multiply$6,5604    rotateX: rotateX$2,5605    rotateY: rotateY$2,5606    rotateZ: rotateZ$2,5607    calculateW: calculateW,5608    exp: exp,5609    ln: ln,5610    pow: pow,5611    slerp: slerp,5612    random: random$2,5613    invert: invert$4,5614    conjugate: conjugate,5615    fromMat3: fromMat3,5616    fromEuler: fromEuler,5617    str: str$6,5618    clone: clone$6,5619    fromValues: fromValues$6,5620    copy: copy$6,5621    set: set$6,5622    add: add$6,5623    mul: mul$6,5624    scale: scale$6,5625    dot: dot$2,5626    lerp: lerp$2,5627    length: length$2,5628    len: len$2,5629    squaredLength: squaredLength$2,5630    sqrLen: sqrLen$2,5631    normalize: normalize$2,5632    exactEquals: exactEquals$6,5633    equals: equals$7,5634    rotationTo: rotationTo,5635    sqlerp: sqlerp,5636    setAxes: setAxes5637  });5638  /**5639   * Dual Quaternion<br>5640   * Format: [real, dual]<br>5641   * Quaternion format: XYZW<br>5642   * Make sure to have normalized dual quaternions, otherwise the functions may not work as intended.<br>5643   * @module quat25644   */5645  /**5646   * Creates a new identity dual quat5647   *5648   * @returns {quat2} a new dual quaternion [real -> rotation, dual -> translation]5649   */5650  function create$7() {5651    var dq = new ARRAY_TYPE(8);5652    if (ARRAY_TYPE != Float32Array) {5653      dq[0] = 0;5654      dq[1] = 0;5655      dq[2] = 0;5656      dq[4] = 0;5657      dq[5] = 0;5658      dq[6] = 0;5659      dq[7] = 0;5660    }5661    dq[3] = 1;5662    return dq;5663  }5664  /**5665   * Creates a new quat initialized with values from an existing quaternion5666   *5667   * @param {ReadonlyQuat2} a dual quaternion to clone5668   * @returns {quat2} new dual quaternion5669   * @function5670   */5671  function clone$7(a) {5672    var dq = new ARRAY_TYPE(8);5673    dq[0] = a[0];5674    dq[1] = a[1];5675    dq[2] = a[2];5676    dq[3] = a[3];5677    dq[4] = a[4];5678    dq[5] = a[5];5679    dq[6] = a[6];5680    dq[7] = a[7];5681    return dq;5682  }5683  /**5684   * Creates a new dual quat initialized with the given values5685   *5686   * @param {Number} x1 X component5687   * @param {Number} y1 Y component5688   * @param {Number} z1 Z component5689   * @param {Number} w1 W component5690   * @param {Number} x2 X component5691   * @param {Number} y2 Y component5692   * @param {Number} z2 Z component5693   * @param {Number} w2 W component5694   * @returns {quat2} new dual quaternion5695   * @function5696   */5697  function fromValues$7(x1, y1, z1, w1, x2, y2, z2, w2) {5698    var dq = new ARRAY_TYPE(8);5699    dq[0] = x1;5700    dq[1] = y1;5701    dq[2] = z1;5702    dq[3] = w1;5703    dq[4] = x2;5704    dq[5] = y2;5705    dq[6] = z2;5706    dq[7] = w2;5707    return dq;5708  }5709  /**5710   * Creates a new dual quat from the given values (quat and translation)5711   *5712   * @param {Number} x1 X component5713   * @param {Number} y1 Y component5714   * @param {Number} z1 Z component5715   * @param {Number} w1 W component5716   * @param {Number} x2 X component (translation)5717   * @param {Number} y2 Y component (translation)5718   * @param {Number} z2 Z component (translation)5719   * @returns {quat2} new dual quaternion5720   * @function5721   */5722  function fromRotationTranslationValues(x1, y1, z1, w1, x2, y2, z2) {5723    var dq = new ARRAY_TYPE(8);5724    dq[0] = x1;5725    dq[1] = y1;5726    dq[2] = z1;5727    dq[3] = w1;5728    var ax = x2 * 0.5,5729        ay = y2 * 0.5,5730        az = z2 * 0.5;5731    dq[4] = ax * w1 + ay * z1 - az * y1;5732    dq[5] = ay * w1 + az * x1 - ax * z1;5733    dq[6] = az * w1 + ax * y1 - ay * x1;5734    dq[7] = -ax * x1 - ay * y1 - az * z1;5735    return dq;5736  }5737  /**5738   * Creates a dual quat from a quaternion and a translation5739   *5740   * @param {ReadonlyQuat2} dual quaternion receiving operation result5741   * @param {ReadonlyQuat} q a normalized quaternion5742   * @param {ReadonlyVec3} t tranlation vector5743   * @returns {quat2} dual quaternion receiving operation result5744   * @function5745   */5746  function fromRotationTranslation$1(out, q, t) {5747    var ax = t[0] * 0.5,5748        ay = t[1] * 0.5,5749        az = t[2] * 0.5,5750        bx = q[0],5751        by = q[1],5752        bz = q[2],5753        bw = q[3];5754    out[0] = bx;5755    out[1] = by;5756    out[2] = bz;5757    out[3] = bw;5758    out[4] = ax * bw + ay * bz - az * by;5759    out[5] = ay * bw + az * bx - ax * bz;5760    out[6] = az * bw + ax * by - ay * bx;5761    out[7] = -ax * bx - ay * by - az * bz;5762    return out;5763  }5764  /**5765   * Creates a dual quat from a translation5766   *5767   * @param {ReadonlyQuat2} dual quaternion receiving operation result5768   * @param {ReadonlyVec3} t translation vector5769   * @returns {quat2} dual quaternion receiving operation result5770   * @function5771   */5772  function fromTranslation$3(out, t) {5773    out[0] = 0;5774    out[1] = 0;5775    out[2] = 0;5776    out[3] = 1;5777    out[4] = t[0] * 0.5;5778    out[5] = t[1] * 0.5;5779    out[6] = t[2] * 0.5;5780    out[7] = 0;5781    return out;5782  }5783  /**5784   * Creates a dual quat from a quaternion5785   *5786   * @param {ReadonlyQuat2} dual quaternion receiving operation result5787   * @param {ReadonlyQuat} q the quaternion5788   * @returns {quat2} dual quaternion receiving operation result5789   * @function5790   */5791  function fromRotation$4(out, q) {5792    out[0] = q[0];5793    out[1] = q[1];5794    out[2] = q[2];5795    out[3] = q[3];5796    out[4] = 0;5797    out[5] = 0;5798    out[6] = 0;5799    out[7] = 0;5800    return out;5801  }5802  /**5803   * Creates a new dual quat from a matrix (4x4)5804   *5805   * @param {quat2} out the dual quaternion5806   * @param {ReadonlyMat4} a the matrix5807   * @returns {quat2} dual quat receiving operation result5808   * @function5809   */5810  function fromMat4$1(out, a) {5811    //TODO Optimize this5812    var outer = create$6();5813    getRotation(outer, a);5814    var t = new ARRAY_TYPE(3);5815    getTranslation(t, a);5816    fromRotationTranslation$1(out, outer, t);5817    return out;5818  }5819  /**5820   * Copy the values from one dual quat to another5821   *5822   * @param {quat2} out the receiving dual quaternion5823   * @param {ReadonlyQuat2} a the source dual quaternion5824   * @returns {quat2} out5825   * @function5826   */5827  function copy$7(out, a) {5828    out[0] = a[0];5829    out[1] = a[1];5830    out[2] = a[2];5831    out[3] = a[3];5832    out[4] = a[4];5833    out[5] = a[5];5834    out[6] = a[6];5835    out[7] = a[7];5836    return out;5837  }5838  /**5839   * Set a dual quat to the identity dual quaternion5840   *5841   * @param {quat2} out the receiving quaternion5842   * @returns {quat2} out5843   */5844  function identity$5(out) {5845    out[0] = 0;5846    out[1] = 0;5847    out[2] = 0;5848    out[3] = 1;5849    out[4] = 0;5850    out[5] = 0;5851    out[6] = 0;5852    out[7] = 0;5853    return out;5854  }5855  /**5856   * Set the components of a dual quat to the given values5857   *5858   * @param {quat2} out the receiving quaternion5859   * @param {Number} x1 X component5860   * @param {Number} y1 Y component5861   * @param {Number} z1 Z component5862   * @param {Number} w1 W component5863   * @param {Number} x2 X component5864   * @param {Number} y2 Y component5865   * @param {Number} z2 Z component5866   * @param {Number} w2 W component5867   * @returns {quat2} out5868   * @function5869   */5870  function set$7(out, x1, y1, z1, w1, x2, y2, z2, w2) {5871    out[0] = x1;5872    out[1] = y1;5873    out[2] = z1;5874    out[3] = w1;5875    out[4] = x2;5876    out[5] = y2;5877    out[6] = z2;5878    out[7] = w2;5879    return out;5880  }5881  /**5882   * Gets the real part of a dual quat5883   * @param  {quat} out real part5884   * @param  {ReadonlyQuat2} a Dual Quaternion5885   * @return {quat} real part5886   */5887  var getReal = copy$6;5888  /**5889   * Gets the dual part of a dual quat5890   * @param  {quat} out dual part5891   * @param  {ReadonlyQuat2} a Dual Quaternion5892   * @return {quat} dual part5893   */5894  function getDual(out, a) {5895    out[0] = a[4];5896    out[1] = a[5];5897    out[2] = a[6];5898    out[3] = a[7];5899    return out;5900  }5901  /**5902   * Set the real component of a dual quat to the given quaternion5903   *5904   * @param {quat2} out the receiving quaternion5905   * @param {ReadonlyQuat} q a quaternion representing the real part5906   * @returns {quat2} out5907   * @function5908   */5909  var setReal = copy$6;5910  /**5911   * Set the dual component of a dual quat to the given quaternion5912   *5913   * @param {quat2} out the receiving quaternion5914   * @param {ReadonlyQuat} q a quaternion representing the dual part5915   * @returns {quat2} out5916   * @function5917   */5918  function setDual(out, q) {5919    out[4] = q[0];5920    out[5] = q[1];5921    out[6] = q[2];5922    out[7] = q[3];5923    return out;5924  }5925  /**5926   * Gets the translation of a normalized dual quat5927   * @param  {vec3} out translation5928   * @param  {ReadonlyQuat2} a Dual Quaternion to be decomposed5929   * @return {vec3} translation5930   */5931  function getTranslation$1(out, a) {5932    var ax = a[4],5933        ay = a[5],5934        az = a[6],5935        aw = a[7],5936        bx = -a[0],5937        by = -a[1],5938        bz = -a[2],5939        bw = a[3];5940    out[0] = (ax * bw + aw * bx + ay * bz - az * by) * 2;5941    out[1] = (ay * bw + aw * by + az * bx - ax * bz) * 2;5942    out[2] = (az * bw + aw * bz + ax * by - ay * bx) * 2;5943    return out;5944  }5945  /**5946   * Translates a dual quat by the given vector5947   *5948   * @param {quat2} out the receiving dual quaternion5949   * @param {ReadonlyQuat2} a the dual quaternion to translate5950   * @param {ReadonlyVec3} v vector to translate by5951   * @returns {quat2} out5952   */5953  function translate$3(out, a, v) {5954    var ax1 = a[0],5955        ay1 = a[1],5956        az1 = a[2],5957        aw1 = a[3],5958        bx1 = v[0] * 0.5,5959        by1 = v[1] * 0.5,5960        bz1 = v[2] * 0.5,5961        ax2 = a[4],5962        ay2 = a[5],5963        az2 = a[6],5964        aw2 = a[7];5965    out[0] = ax1;5966    out[1] = ay1;5967    out[2] = az1;5968    out[3] = aw1;5969    out[4] = aw1 * bx1 + ay1 * bz1 - az1 * by1 + ax2;5970    out[5] = aw1 * by1 + az1 * bx1 - ax1 * bz1 + ay2;5971    out[6] = aw1 * bz1 + ax1 * by1 - ay1 * bx1 + az2;5972    out[7] = -ax1 * bx1 - ay1 * by1 - az1 * bz1 + aw2;5973    return out;5974  }5975  /**5976   * Rotates a dual quat around the X axis5977   *5978   * @param {quat2} out the receiving dual quaternion5979   * @param {ReadonlyQuat2} a the dual quaternion to rotate5980   * @param {number} rad how far should the rotation be5981   * @returns {quat2} out5982   */5983  function rotateX$3(out, a, rad) {5984    var bx = -a[0],5985        by = -a[1],5986        bz = -a[2],5987        bw = a[3],5988        ax = a[4],5989        ay = a[5],5990        az = a[6],5991        aw = a[7],5992        ax1 = ax * bw + aw * bx + ay * bz - az * by,5993        ay1 = ay * bw + aw * by + az * bx - ax * bz,5994        az1 = az * bw + aw * bz + ax * by - ay * bx,5995        aw1 = aw * bw - ax * bx - ay * by - az * bz;5996    rotateX$2(out, a, rad);5997    bx = out[0];5998    by = out[1];5999    bz = out[2];6000    bw = out[3];6001    out[4] = ax1 * bw + aw1 * bx + ay1 * bz - az1 * by;6002    out[5] = ay1 * bw + aw1 * by + az1 * bx - ax1 * bz;6003    out[6] = az1 * bw + aw1 * bz + ax1 * by - ay1 * bx;6004    out[7] = aw1 * bw - ax1 * bx - ay1 * by - az1 * bz;6005    return out;6006  }6007  /**6008   * Rotates a dual quat around the Y axis6009   *6010   * @param {quat2} out the receiving dual quaternion6011   * @param {ReadonlyQuat2} a the dual quaternion to rotate6012   * @param {number} rad how far should the rotation be6013   * @returns {quat2} out6014   */6015  function rotateY$3(out, a, rad) {6016    var bx = -a[0],6017        by = -a[1],6018        bz = -a[2],6019        bw = a[3],6020        ax = a[4],6021        ay = a[5],6022        az = a[6],6023        aw = a[7],6024        ax1 = ax * bw + aw * bx + ay * bz - az * by,6025        ay1 = ay * bw + aw * by + az * bx - ax * bz,6026        az1 = az * bw + aw * bz + ax * by - ay * bx,6027        aw1 = aw * bw - ax * bx - ay * by - az * bz;6028    rotateY$2(out, a, rad);6029    bx = out[0];6030    by = out[1];6031    bz = out[2];6032    bw = out[3];6033    out[4] = ax1 * bw + aw1 * bx + ay1 * bz - az1 * by;6034    out[5] = ay1 * bw + aw1 * by + az1 * bx - ax1 * bz;6035    out[6] = az1 * bw + aw1 * bz + ax1 * by - ay1 * bx;6036    out[7] = aw1 * bw - ax1 * bx - ay1 * by - az1 * bz;6037    return out;6038  }6039  /**6040   * Rotates a dual quat around the Z axis6041   *6042   * @param {quat2} out the receiving dual quaternion6043   * @param {ReadonlyQuat2} a the dual quaternion to rotate6044   * @param {number} rad how far should the rotation be6045   * @returns {quat2} out6046   */6047  function rotateZ$3(out, a, rad) {6048    var bx = -a[0],6049        by = -a[1],6050        bz = -a[2],6051        bw = a[3],6052        ax = a[4],6053        ay = a[5],6054        az = a[6],6055        aw = a[7],6056        ax1 = ax * bw + aw * bx + ay * bz - az * by,6057        ay1 = ay * bw + aw * by + az * bx - ax * bz,6058        az1 = az * bw + aw * bz + ax * by - ay * bx,6059        aw1 = aw * bw - ax * bx - ay * by - az * bz;6060    rotateZ$2(out, a, rad);6061    bx = out[0];6062    by = out[1];6063    bz = out[2];6064    bw = out[3];6065    out[4] = ax1 * bw + aw1 * bx + ay1 * bz - az1 * by;6066    out[5] = ay1 * bw + aw1 * by + az1 * bx - ax1 * bz;6067    out[6] = az1 * bw + aw1 * bz + ax1 * by - ay1 * bx;6068    out[7] = aw1 * bw - ax1 * bx - ay1 * by - az1 * bz;6069    return out;6070  }6071  /**6072   * Rotates a dual quat by a given quaternion (a * q)6073   *6074   * @param {quat2} out the receiving dual quaternion6075   * @param {ReadonlyQuat2} a the dual quaternion to rotate6076   * @param {ReadonlyQuat} q quaternion to rotate by6077   * @returns {quat2} out6078   */6079  function rotateByQuatAppend(out, a, q) {6080    var qx = q[0],6081        qy = q[1],6082        qz = q[2],6083        qw = q[3],6084        ax = a[0],6085        ay = a[1],6086        az = a[2],6087        aw = a[3];6088    out[0] = ax * qw + aw * qx + ay * qz - az * qy;6089    out[1] = ay * qw + aw * qy + az * qx - ax * qz;6090    out[2] = az * qw + aw * qz + ax * qy - ay * qx;6091    out[3] = aw * qw - ax * qx - ay * qy - az * qz;6092    ax = a[4];6093    ay = a[5];6094    az = a[6];6095    aw = a[7];6096    out[4] = ax * qw + aw * qx + ay * qz - az * qy;6097    out[5] = ay * qw + aw * qy + az * qx - ax * qz;6098    out[6] = az * qw + aw * qz + ax * qy - ay * qx;6099    out[7] = aw * qw - ax * qx - ay * qy - az * qz;6100    return out;6101  }6102  /**6103   * Rotates a dual quat by a given quaternion (q * a)6104   *6105   * @param {quat2} out the receiving dual quaternion6106   * @param {ReadonlyQuat} q quaternion to rotate by6107   * @param {ReadonlyQuat2} a the dual quaternion to rotate6108   * @returns {quat2} out6109   */6110  function rotateByQuatPrepend(out, q, a) {6111    var qx = q[0],6112        qy = q[1],6113        qz = q[2],6114        qw = q[3],6115        bx = a[0],6116        by = a[1],6117        bz = a[2],6118        bw = a[3];6119    out[0] = qx * bw + qw * bx + qy * bz - qz * by;6120    out[1] = qy * bw + qw * by + qz * bx - qx * bz;6121    out[2] = qz * bw + qw * bz + qx * by - qy * bx;6122    out[3] = qw * bw - qx * bx - qy * by - qz * bz;6123    bx = a[4];6124    by = a[5];6125    bz = a[6];6126    bw = a[7];6127    out[4] = qx * bw + qw * bx + qy * bz - qz * by;6128    out[5] = qy * bw + qw * by + qz * bx - qx * bz;6129    out[6] = qz * bw + qw * bz + qx * by - qy * bx;6130    out[7] = qw * bw - qx * bx - qy * by - qz * bz;6131    return out;6132  }6133  /**6134   * Rotates a dual quat around a given axis. Does the normalisation automatically6135   *6136   * @param {quat2} out the receiving dual quaternion6137   * @param {ReadonlyQuat2} a the dual quaternion to rotate6138   * @param {ReadonlyVec3} axis the axis to rotate around6139   * @param {Number} rad how far the rotation should be6140   * @returns {quat2} out6141   */6142  function rotateAroundAxis(out, a, axis, rad) {6143    //Special case for rad = 06144    if (Math.abs(rad) < EPSILON) {6145      return copy$7(out, a);6146    }6147    var axisLength = Math.hypot(axis[0], axis[1], axis[2]);6148    rad = rad * 0.5;6149    var s = Math.sin(rad);6150    var bx = s * axis[0] / axisLength;6151    var by = s * axis[1] / axisLength;6152    var bz = s * axis[2] / axisLength;6153    var bw = Math.cos(rad);6154    var ax1 = a[0],6155        ay1 = a[1],6156        az1 = a[2],6157        aw1 = a[3];6158    out[0] = ax1 * bw + aw1 * bx + ay1 * bz - az1 * by;6159    out[1] = ay1 * bw + aw1 * by + az1 * bx - ax1 * bz;6160    out[2] = az1 * bw + aw1 * bz + ax1 * by - ay1 * bx;6161    out[3] = aw1 * bw - ax1 * bx - ay1 * by - az1 * bz;6162    var ax = a[4],6163        ay = a[5],6164        az = a[6],6165        aw = a[7];6166    out[4] = ax * bw + aw * bx + ay * bz - az * by;6167    out[5] = ay * bw + aw * by + az * bx - ax * bz;6168    out[6] = az * bw + aw * bz + ax * by - ay * bx;6169    out[7] = aw * bw - ax * bx - ay * by - az * bz;6170    return out;6171  }6172  /**6173   * Adds two dual quat's6174   *6175   * @param {quat2} out the receiving dual quaternion6176   * @param {ReadonlyQuat2} a the first operand6177   * @param {ReadonlyQuat2} b the second operand6178   * @returns {quat2} out6179   * @function6180   */6181  function add$7(out, a, b) {6182    out[0] = a[0] + b[0];6183    out[1] = a[1] + b[1];6184    out[2] = a[2] + b[2];6185    out[3] = a[3] + b[3];6186    out[4] = a[4] + b[4];6187    out[5] = a[5] + b[5];6188    out[6] = a[6] + b[6];6189    out[7] = a[7] + b[7];6190    return out;6191  }6192  /**6193   * Multiplies two dual quat's6194   *6195   * @param {quat2} out the receiving dual quaternion6196   * @param {ReadonlyQuat2} a the first operand6197   * @param {ReadonlyQuat2} b the second operand6198   * @returns {quat2} out6199   */6200  function multiply$7(out, a, b) {6201    var ax0 = a[0],6202        ay0 = a[1],6203        az0 = a[2],6204        aw0 = a[3],6205        bx1 = b[4],6206        by1 = b[5],6207        bz1 = b[6],6208        bw1 = b[7],6209        ax1 = a[4],6210        ay1 = a[5],6211        az1 = a[6],6212        aw1 = a[7],6213        bx0 = b[0],6214        by0 = b[1],6215        bz0 = b[2],6216        bw0 = b[3];6217    out[0] = ax0 * bw0 + aw0 * bx0 + ay0 * bz0 - az0 * by0;6218    out[1] = ay0 * bw0 + aw0 * by0 + az0 * bx0 - ax0 * bz0;6219    out[2] = az0 * bw0 + aw0 * bz0 + ax0 * by0 - ay0 * bx0;6220    out[3] = aw0 * bw0 - ax0 * bx0 - ay0 * by0 - az0 * bz0;6221    out[4] = ax0 * bw1 + aw0 * bx1 + ay0 * bz1 - az0 * by1 + ax1 * bw0 + aw1 * bx0 + ay1 * bz0 - az1 * by0;6222    out[5] = ay0 * bw1 + aw0 * by1 + az0 * bx1 - ax0 * bz1 + ay1 * bw0 + aw1 * by0 + az1 * bx0 - ax1 * bz0;6223    out[6] = az0 * bw1 + aw0 * bz1 + ax0 * by1 - ay0 * bx1 + az1 * bw0 + aw1 * bz0 + ax1 * by0 - ay1 * bx0;6224    out[7] = aw0 * bw1 - ax0 * bx1 - ay0 * by1 - az0 * bz1 + aw1 * bw0 - ax1 * bx0 - ay1 * by0 - az1 * bz0;6225    return out;6226  }6227  /**6228   * Alias for {@link quat2.multiply}6229   * @function6230   */6231  var mul$7 = multiply$7;6232  /**6233   * Scales a dual quat by a scalar number6234   *6235   * @param {quat2} out the receiving dual quat6236   * @param {ReadonlyQuat2} a the dual quat to scale6237   * @param {Number} b amount to scale the dual quat by6238   * @returns {quat2} out6239   * @function6240   */6241  function scale$7(out, a, b) {6242    out[0] = a[0] * b;6243    out[1] = a[1] * b;6244    out[2] = a[2] * b;6245    out[3] = a[3] * b;6246    out[4] = a[4] * b;6247    out[5] = a[5] * b;6248    out[6] = a[6] * b;6249    out[7] = a[7] * b;6250    return out;6251  }6252  /**6253   * Calculates the dot product of two dual quat's (The dot product of the real parts)6254   *6255   * @param {ReadonlyQuat2} a the first operand6256   * @param {ReadonlyQuat2} b the second operand6257   * @returns {Number} dot product of a and b6258   * @function6259   */6260  var dot$3 = dot$2;6261  /**6262   * Performs a linear interpolation between two dual quats's6263   * NOTE: The resulting dual quaternions won't always be normalized (The error is most noticeable when t = 0.5)6264   *6265   * @param {quat2} out the receiving dual quat6266   * @param {ReadonlyQuat2} a the first operand6267   * @param {ReadonlyQuat2} b the second operand6268   * @param {Number} t interpolation amount, in the range [0-1], between the two inputs6269   * @returns {quat2} out6270   */6271  function lerp$3(out, a, b, t) {6272    var mt = 1 - t;6273    if (dot$3(a, b) < 0) t = -t;6274    out[0] = a[0] * mt + b[0] * t;6275    out[1] = a[1] * mt + b[1] * t;6276    out[2] = a[2] * mt + b[2] * t;6277    out[3] = a[3] * mt + b[3] * t;6278    out[4] = a[4] * mt + b[4] * t;6279    out[5] = a[5] * mt + b[5] * t;6280    out[6] = a[6] * mt + b[6] * t;6281    out[7] = a[7] * mt + b[7] * t;6282    return out;6283  }6284  /**6285   * Calculates the inverse of a dual quat. If they are normalized, conjugate is cheaper6286   *6287   * @param {quat2} out the receiving dual quaternion6288   * @param {ReadonlyQuat2} a dual quat to calculate inverse of6289   * @returns {quat2} out6290   */6291  function invert$5(out, a) {6292    var sqlen = squaredLength$3(a);6293    out[0] = -a[0] / sqlen;6294    out[1] = -a[1] / sqlen;6295    out[2] = -a[2] / sqlen;6296    out[3] = a[3] / sqlen;6297    out[4] = -a[4] / sqlen;6298    out[5] = -a[5] / sqlen;6299    out[6] = -a[6] / sqlen;6300    out[7] = a[7] / sqlen;6301    return out;6302  }6303  /**6304   * Calculates the conjugate of a dual quat6305   * If the dual quaternion is normalized, this function is faster than quat2.inverse and produces the same result.6306   *6307   * @param {quat2} out the receiving quaternion6308   * @param {ReadonlyQuat2} a quat to calculate conjugate of6309   * @returns {quat2} out6310   */6311  function conjugate$1(out, a) {6312    out[0] = -a[0];6313    out[1] = -a[1];6314    out[2] = -a[2];6315    out[3] = a[3];6316    out[4] = -a[4];6317    out[5] = -a[5];6318    out[6] = -a[6];6319    out[7] = a[7];6320    return out;6321  }6322  /**6323   * Calculates the length of a dual quat6324   *6325   * @param {ReadonlyQuat2} a dual quat to calculate length of6326   * @returns {Number} length of a6327   * @function6328   */6329  var length$3 = length$2;6330  /**6331   * Alias for {@link quat2.length}6332   * @function6333   */6334  var len$3 = length$3;6335  /**6336   * Calculates the squared length of a dual quat6337   *6338   * @param {ReadonlyQuat2} a dual quat to calculate squared length of6339   * @returns {Number} squared length of a6340   * @function6341   */6342  var squaredLength$3 = squaredLength$2;6343  /**6344   * Alias for {@link quat2.squaredLength}6345   * @function6346   */6347  var sqrLen$3 = squaredLength$3;6348  /**6349   * Normalize a dual quat6350   *6351   * @param {quat2} out the receiving dual quaternion6352   * @param {ReadonlyQuat2} a dual quaternion to normalize6353   * @returns {quat2} out6354   * @function6355   */6356  function normalize$3(out, a) {6357    var magnitude = squaredLength$3(a);6358    if (magnitude > 0) {6359      magnitude = Math.sqrt(magnitude);6360      var a0 = a[0] / magnitude;6361      var a1 = a[1] / magnitude;6362      var a2 = a[2] / magnitude;6363      var a3 = a[3] / magnitude;6364      var b0 = a[4];6365      var b1 = a[5];6366      var b2 = a[6];6367      var b3 = a[7];6368      var a_dot_b = a0 * b0 + a1 * b1 + a2 * b2 + a3 * b3;6369      out[0] = a0;6370      out[1] = a1;6371      out[2] = a2;6372      out[3] = a3;6373      out[4] = (b0 - a0 * a_dot_b) / magnitude;6374      out[5] = (b1 - a1 * a_dot_b) / magnitude;6375      out[6] = (b2 - a2 * a_dot_b) / magnitude;6376      out[7] = (b3 - a3 * a_dot_b) / magnitude;6377    }6378    return out;6379  }6380  /**6381   * Returns a string representation of a dual quatenion6382   *6383   * @param {ReadonlyQuat2} a dual quaternion to represent as a string6384   * @returns {String} string representation of the dual quat6385   */6386  function str$7(a) {6387    return "quat2(" + a[0] + ", " + a[1] + ", " + a[2] + ", " + a[3] + ", " + a[4] + ", " + a[5] + ", " + a[6] + ", " + a[7] + ")";6388  }6389  /**6390   * Returns whether or not the dual quaternions have exactly the same elements in the same position (when compared with ===)6391   *6392   * @param {ReadonlyQuat2} a the first dual quaternion.6393   * @param {ReadonlyQuat2} b the second dual quaternion.6394   * @returns {Boolean} true if the dual quaternions are equal, false otherwise.6395   */6396  function exactEquals$7(a, b) {6397    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];6398  }6399  /**6400   * Returns whether or not the dual quaternions have approximately the same elements in the same position.6401   *6402   * @param {ReadonlyQuat2} a the first dual quat.6403   * @param {ReadonlyQuat2} b the second dual quat.6404   * @returns {Boolean} true if the dual quats are equal, false otherwise.6405   */6406  function equals$8(a, b) {6407    var a0 = a[0],6408        a1 = a[1],6409        a2 = a[2],6410        a3 = a[3],6411        a4 = a[4],6412        a5 = a[5],6413        a6 = a[6],6414        a7 = a[7];6415    var b0 = b[0],6416        b1 = b[1],6417        b2 = b[2],6418        b3 = b[3],6419        b4 = b[4],6420        b5 = b[5],6421        b6 = b[6],6422        b7 = b[7];6423    return Math.abs(a0 - b0) <= EPSILON * Math.max(1.0, Math.abs(a0), Math.abs(b0)) && Math.abs(a1 - b1) <= EPSILON * Math.max(1.0, Math.abs(a1), Math.abs(b1)) && Math.abs(a2 - b2) <= EPSILON * Math.max(1.0, Math.abs(a2), Math.abs(b2)) && Math.abs(a3 - b3) <= EPSILON * Math.max(1.0, Math.abs(a3), Math.abs(b3)) && Math.abs(a4 - b4) <= EPSILON * Math.max(1.0, Math.abs(a4), Math.abs(b4)) && Math.abs(a5 - b5) <= EPSILON * Math.max(1.0, Math.abs(a5), Math.abs(b5)) && Math.abs(a6 - b6) <= EPSILON * Math.max(1.0, Math.abs(a6), Math.abs(b6)) && Math.abs(a7 - b7) <= EPSILON * Math.max(1.0, Math.abs(a7), Math.abs(b7));6424  }6425  var quat2 = /*#__PURE__*/Object.freeze({6426    __proto__: null,6427    create: create$7,6428    clone: clone$7,6429    fromValues: fromValues$7,6430    fromRotationTranslationValues: fromRotationTranslationValues,6431    fromRotationTranslation: fromRotationTranslation$1,6432    fromTranslation: fromTranslation$3,6433    fromRotation: fromRotation$4,6434    fromMat4: fromMat4$1,6435    copy: copy$7,6436    identity: identity$5,6437    set: set$7,6438    getReal: getReal,6439    getDual: getDual,6440    setReal: setReal,6441    setDual: setDual,6442    getTranslation: getTranslation$1,6443    translate: translate$3,6444    rotateX: rotateX$3,6445    rotateY: rotateY$3,6446    rotateZ: rotateZ$3,6447    rotateByQuatAppend: rotateByQuatAppend,6448    rotateByQuatPrepend: rotateByQuatPrepend,6449    rotateAroundAxis: rotateAroundAxis,6450    add: add$7,6451    multiply: multiply$7,6452    mul: mul$7,6453    scale: scale$7,6454    dot: dot$3,6455    lerp: lerp$3,6456    invert: invert$5,6457    conjugate: conjugate$1,6458    length: length$3,6459    len: len$3,6460    squaredLength: squaredLength$3,6461    sqrLen: sqrLen$3,6462    normalize: normalize$3,6463    str: str$7,6464    exactEquals: exactEquals$7,6465    equals: equals$86466  });6467  /**6468   * 2 Dimensional Vector6469   * @module vec26470   */6471  /**6472   * Creates a new, empty vec26473   *6474   * @returns {vec2} a new 2D vector6475   */6476  function create$8() {6477    var out = new ARRAY_TYPE(2);6478    if (ARRAY_TYPE != Float32Array) {6479      out[0] = 0;6480      out[1] = 0;6481    }6482    return out;6483  }6484  /**6485   * Creates a new vec2 initialized with values from an existing vector6486   *6487   * @param {ReadonlyVec2} a vector to clone6488   * @returns {vec2} a new 2D vector6489   */6490  function clone$8(a) {6491    var out = new ARRAY_TYPE(2);6492    out[0] = a[0];6493    out[1] = a[1];6494    return out;6495  }6496  /**6497   * Creates a new vec2 initialized with the given values6498   *6499   * @param {Number} x X component6500   * @param {Number} y Y component6501   * @returns {vec2} a new 2D vector6502   */6503  function fromValues$8(x, y) {6504    var out = new ARRAY_TYPE(2);6505    out[0] = x;6506    out[1] = y;6507    return out;6508  }6509  /**6510   * Copy the values from one vec2 to another6511   *6512   * @param {vec2} out the receiving vector6513   * @param {ReadonlyVec2} a the source vector6514   * @returns {vec2} out6515   */6516  function copy$8(out, a) {6517    out[0] = a[0];6518    out[1] = a[1];6519    return out;6520  }6521  /**6522   * Set the components of a vec2 to the given values6523   *6524   * @param {vec2} out the receiving vector6525   * @param {Number} x X component6526   * @param {Number} y Y component6527   * @returns {vec2} out6528   */6529  function set$8(out, x, y) {6530    out[0] = x;6531    out[1] = y;6532    return out;6533  }6534  /**6535   * Adds two vec2's6536   *6537   * @param {vec2} out the receiving vector6538   * @param {ReadonlyVec2} a the first operand6539   * @param {ReadonlyVec2} b the second operand6540   * @returns {vec2} out6541   */6542  function add$8(out, a, b) {6543    out[0] = a[0] + b[0];6544    out[1] = a[1] + b[1];6545    return out;6546  }6547  /**6548   * Subtracts vector b from vector a6549   *6550   * @param {vec2} out the receiving vector6551   * @param {ReadonlyVec2} a the first operand6552   * @param {ReadonlyVec2} b the second operand6553   * @returns {vec2} out6554   */6555  function subtract$6(out, a, b) {6556    out[0] = a[0] - b[0];6557    out[1] = a[1] - b[1];6558    return out;6559  }6560  /**6561   * Multiplies two vec2's6562   *6563   * @param {vec2} out the receiving vector6564   * @param {ReadonlyVec2} a the first operand6565   * @param {ReadonlyVec2} b the second operand6566   * @returns {vec2} out6567   */6568  function multiply$8(out, a, b) {6569    out[0] = a[0] * b[0];6570    out[1] = a[1] * b[1];6571    return out;6572  }6573  /**6574   * Divides two vec2's6575   *6576   * @param {vec2} out the receiving vector6577   * @param {ReadonlyVec2} a the first operand6578   * @param {ReadonlyVec2} b the second operand6579   * @returns {vec2} out6580   */6581  function divide$2(out, a, b) {6582    out[0] = a[0] / b[0];6583    out[1] = a[1] / b[1];6584    return out;6585  }6586  /**6587   * Math.ceil the components of a vec26588   *6589   * @param {vec2} out the receiving vector6590   * @param {ReadonlyVec2} a vector to ceil6591   * @returns {vec2} out6592   */6593  function ceil$2(out, a) {6594    out[0] = Math.ceil(a[0]);6595    out[1] = Math.ceil(a[1]);6596    return out;6597  }6598  /**6599   * Math.floor the components of a vec26600   *6601   * @param {vec2} out the receiving vector6602   * @param {ReadonlyVec2} a vector to floor6603   * @returns {vec2} out6604   */6605  function floor$2(out, a) {6606    out[0] = Math.floor(a[0]);6607    out[1] = Math.floor(a[1]);6608    return out;6609  }6610  /**6611   * Returns the minimum of two vec2's6612   *6613   * @param {vec2} out the receiving vector6614   * @param {ReadonlyVec2} a the first operand6615   * @param {ReadonlyVec2} b the second operand6616   * @returns {vec2} out6617   */6618  function min$2(out, a, b) {6619    out[0] = Math.min(a[0], b[0]);6620    out[1] = Math.min(a[1], b[1]);6621    return out;6622  }6623  /**6624   * Returns the maximum of two vec2's6625   *6626   * @param {vec2} out the receiving vector6627   * @param {ReadonlyVec2} a the first operand6628   * @param {ReadonlyVec2} b the second operand6629   * @returns {vec2} out6630   */6631  function max$2(out, a, b) {6632    out[0] = Math.max(a[0], b[0]);6633    out[1] = Math.max(a[1], b[1]);6634    return out;6635  }6636  /**6637   * Math.round the components of a vec26638   *6639   * @param {vec2} out the receiving vector6640   * @param {ReadonlyVec2} a vector to round6641   * @returns {vec2} out6642   */6643  function round$2(out, a) {6644    out[0] = Math.round(a[0]);6645    out[1] = Math.round(a[1]);6646    return out;6647  }6648  /**6649   * Scales a vec2 by a scalar number6650   *6651   * @param {vec2} out the receiving vector6652   * @param {ReadonlyVec2} a the vector to scale6653   * @param {Number} b amount to scale the vector by6654   * @returns {vec2} out6655   */6656  function scale$8(out, a, b) {6657    out[0] = a[0] * b;6658    out[1] = a[1] * b;6659    return out;6660  }6661  /**6662   * Adds two vec2's after scaling the second operand by a scalar value6663   *6664   * @param {vec2} out the receiving vector6665   * @param {ReadonlyVec2} a the first operand6666   * @param {ReadonlyVec2} b the second operand6667   * @param {Number} scale the amount to scale b by before adding6668   * @returns {vec2} out6669   */6670  function scaleAndAdd$2(out, a, b, scale) {6671    out[0] = a[0] + b[0] * scale;6672    out[1] = a[1] + b[1] * scale;6673    return out;6674  }6675  /**6676   * Calculates the euclidian distance between two vec2's6677   *6678   * @param {ReadonlyVec2} a the first operand6679   * @param {ReadonlyVec2} b the second operand6680   * @returns {Number} distance between a and b6681   */6682  function distance$2(a, b) {6683    var x = b[0] - a[0],6684        y = b[1] - a[1];6685    return Math.hypot(x, y);6686  }6687  /**6688   * Calculates the squared euclidian distance between two vec2's6689   *6690   * @param {ReadonlyVec2} a the first operand6691   * @param {ReadonlyVec2} b the second operand6692   * @returns {Number} squared distance between a and b6693   */6694  function squaredDistance$2(a, b) {6695    var x = b[0] - a[0],6696        y = b[1] - a[1];6697    return x * x + y * y;6698  }6699  /**6700   * Calculates the length of a vec26701   *6702   * @param {ReadonlyVec2} a vector to calculate length of6703   * @returns {Number} length of a6704   */6705  function length$4(a) {6706    var x = a[0],6707        y = a[1];6708    return Math.hypot(x, y);6709  }6710  /**6711   * Calculates the squared length of a vec26712   *6713   * @param {ReadonlyVec2} a vector to calculate squared length of6714   * @returns {Number} squared length of a6715   */6716  function squaredLength$4(a) {6717    var x = a[0],6718        y = a[1];6719    return x * x + y * y;6720  }6721  /**6722   * Negates the components of a vec26723   *6724   * @param {vec2} out the receiving vector6725   * @param {ReadonlyVec2} a vector to negate6726   * @returns {vec2} out6727   */6728  function negate$2(out, a) {6729    out[0] = -a[0];6730    out[1] = -a[1];6731    return out;6732  }6733  /**6734   * Returns the inverse of the components of a vec26735   *6736   * @param {vec2} out the receiving vector6737   * @param {ReadonlyVec2} a vector to invert6738   * @returns {vec2} out6739   */6740  function inverse$2(out, a) {6741    out[0] = 1.0 / a[0];6742    out[1] = 1.0 / a[1];6743    return out;6744  }6745  /**6746   * Normalize a vec26747   *6748   * @param {vec2} out the receiving vector6749   * @param {ReadonlyVec2} a vector to normalize6750   * @returns {vec2} out6751   */6752  function normalize$4(out, a) {6753    var x = a[0],6754        y = a[1];6755    var len = x * x + y * y;6756    if (len > 0) {6757      //TODO: evaluate use of glm_invsqrt here?6758      len = 1 / Math.sqrt(len);6759    }6760    out[0] = a[0] * len;6761    out[1] = a[1] * len;6762    return out;6763  }6764  /**6765   * Calculates the dot product of two vec2's6766   *6767   * @param {ReadonlyVec2} a the first operand6768   * @param {ReadonlyVec2} b the second operand6769   * @returns {Number} dot product of a and b6770   */6771  function dot$4(a, b) {6772    return a[0] * b[0] + a[1] * b[1];6773  }6774  /**6775   * Computes the cross product of two vec2's6776   * Note that the cross product must by definition produce a 3D vector6777   *6778   * @param {vec3} out the receiving vector6779   * @param {ReadonlyVec2} a the first operand6780   * @param {ReadonlyVec2} b the second operand6781   * @returns {vec3} out6782   */6783  function cross$2(out, a, b) {6784    var z = a[0] * b[1] - a[1] * b[0];6785    out[0] = out[1] = 0;6786    out[2] = z;6787    return out;6788  }6789  /**6790   * Performs a linear interpolation between two vec2's6791   *6792   * @param {vec2} out the receiving vector6793   * @param {ReadonlyVec2} a the first operand6794   * @param {ReadonlyVec2} b the second operand6795   * @param {Number} t interpolation amount, in the range [0-1], between the two inputs6796   * @returns {vec2} out6797   */6798  function lerp$4(out, a, b, t) {6799    var ax = a[0],6800        ay = a[1];6801    out[0] = ax + t * (b[0] - ax);6802    out[1] = ay + t * (b[1] - ay);6803    return out;6804  }6805  /**6806   * Generates a random vector with the given scale6807   *6808   * @param {vec2} out the receiving vector6809   * @param {Number} [scale] Length of the resulting vector. If ommitted, a unit vector will be returned6810   * @returns {vec2} out6811   */6812  function random$3(out, scale) {6813    scale = scale || 1.0;6814    var r = RANDOM() * 2.0 * Math.PI;6815    out[0] = Math.cos(r) * scale;6816    out[1] = Math.sin(r) * scale;6817    return out;6818  }6819  /**6820   * Transforms the vec2 with a mat26821   *6822   * @param {vec2} out the receiving vector6823   * @param {ReadonlyVec2} a the vector to transform6824   * @param {ReadonlyMat2} m matrix to transform with6825   * @returns {vec2} out6826   */6827  function transformMat2(out, a, m) {6828    var x = a[0],6829        y = a[1];6830    out[0] = m[0] * x + m[2] * y;6831    out[1] = m[1] * x + m[3] * y;6832    return out;6833  }6834  /**6835   * Transforms the vec2 with a mat2d6836   *6837   * @param {vec2} out the receiving vector6838   * @param {ReadonlyVec2} a the vector to transform6839   * @param {ReadonlyMat2d} m matrix to transform with6840   * @returns {vec2} out6841   */6842  function transformMat2d(out, a, m) {6843    var x = a[0],6844        y = a[1];6845    out[0] = m[0] * x + m[2] * y + m[4];6846    out[1] = m[1] * x + m[3] * y + m[5];6847    return out;6848  }6849  /**6850   * Transforms the vec2 with a mat36851   * 3rd vector component is implicitly '1'6852   *6853   * @param {vec2} out the receiving vector6854   * @param {ReadonlyVec2} a the vector to transform6855   * @param {ReadonlyMat3} m matrix to transform with6856   * @returns {vec2} out6857   */6858  function transformMat3$1(out, a, m) {6859    var x = a[0],6860        y = a[1];6861    out[0] = m[0] * x + m[3] * y + m[6];6862    out[1] = m[1] * x + m[4] * y + m[7];6863    return out;6864  }6865  /**6866   * Transforms the vec2 with a mat46867   * 3rd vector component is implicitly '0'6868   * 4th vector component is implicitly '1'6869   *6870   * @param {vec2} out the receiving vector6871   * @param {ReadonlyVec2} a the vector to transform6872   * @param {ReadonlyMat4} m matrix to transform with6873   * @returns {vec2} out6874   */6875  function transformMat4$2(out, a, m) {6876    var x = a[0];6877    var y = a[1];6878    out[0] = m[0] * x + m[4] * y + m[12];6879    out[1] = m[1] * x + m[5] * y + m[13];6880    return out;6881  }6882  /**6883   * Rotate a 2D vector6884   * @param {vec2} out The receiving vec26885   * @param {ReadonlyVec2} a The vec2 point to rotate6886   * @param {ReadonlyVec2} b The origin of the rotation6887   * @param {Number} rad The angle of rotation in radians6888   * @returns {vec2} out6889   */6890  function rotate$4(out, a, b, rad) {6891    //Translate point to the origin6892    var p0 = a[0] - b[0],6893        p1 = a[1] - b[1],6894        sinC = Math.sin(rad),6895        cosC = Math.cos(rad); //perform rotation and translate to correct position6896    out[0] = p0 * cosC - p1 * sinC + b[0];6897    out[1] = p0 * sinC + p1 * cosC + b[1];6898    return out;6899  }6900  /**6901   * Get the angle between two 2D vectors6902   * @param {ReadonlyVec2} a The first operand6903   * @param {ReadonlyVec2} b The second operand6904   * @returns {Number} The angle in radians6905   */6906  function angle$1(a, b) {6907    var x1 = a[0],6908        y1 = a[1],6909        x2 = b[0],6910        y2 = b[1],6911        // mag is the product of the magnitudes of a and b6912    mag = Math.sqrt(x1 * x1 + y1 * y1) * Math.sqrt(x2 * x2 + y2 * y2),6913        // mag &&.. short circuits if mag == 06914    cosine = mag && (x1 * x2 + y1 * y2) / mag; // Math.min(Math.max(cosine, -1), 1) clamps the cosine between -1 and 16915    return Math.acos(Math.min(Math.max(cosine, -1), 1));6916  }6917  /**6918   * Set the components of a vec2 to zero6919   *6920   * @param {vec2} out the receiving vector6921   * @returns {vec2} out6922   */6923  function zero$2(out) {6924    out[0] = 0.0;6925    out[1] = 0.0;6926    return out;6927  }6928  /**6929   * Returns a string representation of a vector6930   *6931   * @param {ReadonlyVec2} a vector to represent as a string6932   * @returns {String} string representation of the vector6933   */6934  function str$8(a) {6935    return "vec2(" + a[0] + ", " + a[1] + ")";6936  }6937  /**6938   * Returns whether or not the vectors exactly have the same elements in the same position (when compared with ===)6939   *6940   * @param {ReadonlyVec2} a The first vector.6941   * @param {ReadonlyVec2} b The second vector.6942   * @returns {Boolean} True if the vectors are equal, false otherwise.6943   */6944  function exactEquals$8(a, b) {6945    return a[0] === b[0] && a[1] === b[1];6946  }6947  /**6948   * Returns whether or not the vectors have approximately the same elements in the same position.6949   *6950   * @param {ReadonlyVec2} a The first vector.6951   * @param {ReadonlyVec2} b The second vector.6952   * @returns {Boolean} True if the vectors are equal, false otherwise.6953   */6954  function equals$9(a, b) {6955    var a0 = a[0],6956        a1 = a[1];6957    var b0 = b[0],6958        b1 = b[1];6959    return Math.abs(a0 - b0) <= EPSILON * Math.max(1.0, Math.abs(a0), Math.abs(b0)) && Math.abs(a1 - b1) <= EPSILON * Math.max(1.0, Math.abs(a1), Math.abs(b1));6960  }6961  /**6962   * Alias for {@link vec2.length}6963   * @function6964   */6965  var len$4 = length$4;6966  /**6967   * Alias for {@link vec2.subtract}6968   * @function6969   */6970  var sub$6 = subtract$6;6971  /**6972   * Alias for {@link vec2.multiply}6973   * @function6974   */6975  var mul$8 = multiply$8;6976  /**6977   * Alias for {@link vec2.divide}6978   * @function6979   */6980  var div$2 = divide$2;6981  /**6982   * Alias for {@link vec2.distance}6983   * @function6984   */6985  var dist$2 = distance$2;6986  /**6987   * Alias for {@link vec2.squaredDistance}6988   * @function6989   */6990  var sqrDist$2 = squaredDistance$2;6991  /**6992   * Alias for {@link vec2.squaredLength}6993   * @function6994   */6995  var sqrLen$4 = squaredLength$4;6996  /**6997   * Perform some operation over an array of vec2s.6998   *6999   * @param {Array} a the array of vectors to iterate over7000   * @param {Number} stride Number of elements between the start of each vec2. If 0 assumes tightly packed7001   * @param {Number} offset Number of elements to skip at the beginning of the array7002   * @param {Number} count Number of vec2s to iterate over. If 0 iterates over entire array7003   * @param {Function} fn Function to call for each vector in the array7004   * @param {Object} [arg] additional argument to pass to fn7005   * @returns {Array} a7006   * @function7007   */7008  var forEach$2 = function () {7009    var vec = create$8();7010    return function (a, stride, offset, count, fn, arg) {7011      var i, l;7012      if (!stride) {7013        stride = 2;7014      }7015      if (!offset) {7016        offset = 0;7017      }7018      if (count) {7019        l = Math.min(count * stride + offset, a.length);7020      } else {7021        l = a.length;7022      }7023      for (i = offset; i < l; i += stride) {7024        vec[0] = a[i];7025        vec[1] = a[i + 1];7026        fn(vec, vec, arg);7027        a[i] = vec[0];7028        a[i + 1] = vec[1];7029      }7030      return a;7031    };7032  }();7033  var vec2 = /*#__PURE__*/Object.freeze({7034    __proto__: null,7035    create: create$8,7036    clone: clone$8,7037    fromValues: fromValues$8,7038    copy: copy$8,7039    set: set$8,7040    add: add$8,7041    subtract: subtract$6,7042    multiply: multiply$8,7043    divide: divide$2,7044    ceil: ceil$2,7045    floor: floor$2,7046    min: min$2,7047    max: max$2,7048    round: round$2,7049    scale: scale$8,7050    scaleAndAdd: scaleAndAdd$2,7051    distance: distance$2,7052    squaredDistance: squaredDistance$2,7053    length: length$4,7054    squaredLength: squaredLength$4,7055    negate: negate$2,7056    inverse: inverse$2,7057    normalize: normalize$4,7058    dot: dot$4,7059    cross: cross$2,7060    lerp: lerp$4,7061    random: random$3,7062    transformMat2: transformMat2,7063    transformMat2d: transformMat2d,7064    transformMat3: transformMat3$1,7065    transformMat4: transformMat4$2,7066    rotate: rotate$4,7067    angle: angle$1,7068    zero: zero$2,7069    str: str$8,7070    exactEquals: exactEquals$8,7071    equals: equals$9,7072    len: len$4,7073    sub: sub$6,7074    mul: mul$8,7075    div: div$2,7076    dist: dist$2,7077    sqrDist: sqrDist$2,7078    sqrLen: sqrLen$4,7079    forEach: forEach$27080  });7081  exports.glMatrix = common;7082  exports.mat2 = mat2;7083  exports.mat2d = mat2d;7084  exports.mat3 = mat3;7085  exports.mat4 = mat4;7086  exports.quat = quat;7087  exports.quat2 = quat2;7088  exports.vec2 = vec2;7089  exports.vec3 = vec3;7090  exports.vec4 = vec4;7091  Object.defineProperty(exports, '__esModule', { value: true });...

gl-matrix.js

Source:gl-matrix.js

1/*!2@fileoverview gl-matrix - High performance matrix and vector operations3@author Brandon Jones4@author Colin MacKenzie IV5@version 3.0.06Copyright (c) 2015-2019, Brandon Jones, Colin MacKenzie IV.7Permission is hereby granted, free of charge, to any person obtaining a copy8of this software and associated documentation files (the "Software"), to deal9in the Software without restriction, including without limitation the rights10to use, copy, modify, merge, publish, distribute, sublicense, and/or sell11copies of the Software, and to permit persons to whom the Software is12furnished to do so, subject to the following conditions:13The above copyright notice and this permission notice shall be included in14all copies or substantial portions of the Software.15THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR16IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,17FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE18AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER19LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,20OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN21THE SOFTWARE.22*/23(function (global, factory) {24  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :25  typeof define === 'function' && define.amd ? define(['exports'], factory) :26  (global = global || self, factory(global.glMatrix = {}));27}(this, function (exports) { 'use strict';28  /**29   * Common utilities30   * @module glMatrix31   */32  // Configuration Constants33  var EPSILON = 0.000001;34  var ARRAY_TYPE = typeof Float32Array !== 'undefined' ? Float32Array : Array;35  var RANDOM = Math.random;36  /**37   * Sets the type of array used when creating new vectors and matrices38   *39   * @param {Type} type Array type, such as Float32Array or Array40   */41  function setMatrixArrayType(type) {42    ARRAY_TYPE = type;43  }44  var degree = Math.PI / 180;45  /**46   * Convert Degree To Radian47   *48   * @param {Number} a Angle in Degrees49   */50  function toRadian(a) {51    return a * degree;52  }53  /**54   * Tests whether or not the arguments have approximately the same value, within an absolute55   * or relative tolerance of glMatrix.EPSILON (an absolute tolerance is used for values less56   * than or equal to 1.0, and a relative tolerance is used for larger values)57   *58   * @param {Number} a The first number to test.59   * @param {Number} b The second number to test.60   * @returns {Boolean} True if the numbers are approximately equal, false otherwise.61   */62  function equals(a, b) {63    return Math.abs(a - b) <= EPSILON * Math.max(1.0, Math.abs(a), Math.abs(b));64  }65  if (!Math.hypot) Math.hypot = function () {66    var y = 0,67        i = arguments.length;68    while (i--) {69      y += arguments[i] * arguments[i];70    }71    return Math.sqrt(y);72  };73  var common = /*#__PURE__*/Object.freeze({74    EPSILON: EPSILON,75    get ARRAY_TYPE () { return ARRAY_TYPE; },76    RANDOM: RANDOM,77    setMatrixArrayType: setMatrixArrayType,78    toRadian: toRadian,79    equals: equals80  });81  /**82   * 2x2 Matrix83   * @module mat284   */85  /**86   * Creates a new identity mat287   *88   * @returns {mat2} a new 2x2 matrix89   */90  function create() {91    var out = new ARRAY_TYPE(4);92    if (ARRAY_TYPE != Float32Array) {93      out[1] = 0;94      out[2] = 0;95    }96    out[0] = 1;97    out[3] = 1;98    return out;99  }100  /**101   * Creates a new mat2 initialized with values from an existing matrix102   *103   * @param {mat2} a matrix to clone104   * @returns {mat2} a new 2x2 matrix105   */106  function clone(a) {107    var out = new ARRAY_TYPE(4);108    out[0] = a[0];109    out[1] = a[1];110    out[2] = a[2];111    out[3] = a[3];112    return out;113  }114  /**115   * Copy the values from one mat2 to another116   *117   * @param {mat2} out the receiving matrix118   * @param {mat2} a the source matrix119   * @returns {mat2} out120   */121  function copy(out, a) {122    out[0] = a[0];123    out[1] = a[1];124    out[2] = a[2];125    out[3] = a[3];126    return out;127  }128  /**129   * Set a mat2 to the identity matrix130   *131   * @param {mat2} out the receiving matrix132   * @returns {mat2} out133   */134  function identity(out) {135    out[0] = 1;136    out[1] = 0;137    out[2] = 0;138    out[3] = 1;139    return out;140  }141  /**142   * Create a new mat2 with the given values143   *144   * @param {Number} m00 Component in column 0, row 0 position (index 0)145   * @param {Number} m01 Component in column 0, row 1 position (index 1)146   * @param {Number} m10 Component in column 1, row 0 position (index 2)147   * @param {Number} m11 Component in column 1, row 1 position (index 3)148   * @returns {mat2} out A new 2x2 matrix149   */150  function fromValues(m00, m01, m10, m11) {151    var out = new ARRAY_TYPE(4);152    out[0] = m00;153    out[1] = m01;154    out[2] = m10;155    out[3] = m11;156    return out;157  }158  /**159   * Set the components of a mat2 to the given values160   *161   * @param {mat2} out the receiving matrix162   * @param {Number} m00 Component in column 0, row 0 position (index 0)163   * @param {Number} m01 Component in column 0, row 1 position (index 1)164   * @param {Number} m10 Component in column 1, row 0 position (index 2)165   * @param {Number} m11 Component in column 1, row 1 position (index 3)166   * @returns {mat2} out167   */168  function set(out, m00, m01, m10, m11) {169    out[0] = m00;170    out[1] = m01;171    out[2] = m10;172    out[3] = m11;173    return out;174  }175  /**176   * Transpose the values of a mat2177   *178   * @param {mat2} out the receiving matrix179   * @param {mat2} a the source matrix180   * @returns {mat2} out181   */182  function transpose(out, a) {183    // If we are transposing ourselves we can skip a few steps but have to cache184    // some values185    if (out === a) {186      var a1 = a[1];187      out[1] = a[2];188      out[2] = a1;189    } else {190      out[0] = a[0];191      out[1] = a[2];192      out[2] = a[1];193      out[3] = a[3];194    }195    return out;196  }197  /**198   * Inverts a mat2199   *200   * @param {mat2} out the receiving matrix201   * @param {mat2} a the source matrix202   * @returns {mat2} out203   */204  function invert(out, a) {205    var a0 = a[0],206        a1 = a[1],207        a2 = a[2],208        a3 = a[3]; // Calculate the determinant209    var det = a0 * a3 - a2 * a1;210    if (!det) {211      return null;212    }213    det = 1.0 / det;214    out[0] = a3 * det;215    out[1] = -a1 * det;216    out[2] = -a2 * det;217    out[3] = a0 * det;218    return out;219  }220  /**221   * Calculates the adjugate of a mat2222   *223   * @param {mat2} out the receiving matrix224   * @param {mat2} a the source matrix225   * @returns {mat2} out226   */227  function adjoint(out, a) {228    // Caching this value is nessecary if out == a229    var a0 = a[0];230    out[0] = a[3];231    out[1] = -a[1];232    out[2] = -a[2];233    out[3] = a0;234    return out;235  }236  /**237   * Calculates the determinant of a mat2238   *239   * @param {mat2} a the source matrix240   * @returns {Number} determinant of a241   */242  function determinant(a) {243    return a[0] * a[3] - a[2] * a[1];244  }245  /**246   * Multiplies two mat2's247   *248   * @param {mat2} out the receiving matrix249   * @param {mat2} a the first operand250   * @param {mat2} b the second operand251   * @returns {mat2} out252   */253  function multiply(out, a, b) {254    var a0 = a[0],255        a1 = a[1],256        a2 = a[2],257        a3 = a[3];258    var b0 = b[0],259        b1 = b[1],260        b2 = b[2],261        b3 = b[3];262    out[0] = a0 * b0 + a2 * b1;263    out[1] = a1 * b0 + a3 * b1;264    out[2] = a0 * b2 + a2 * b3;265    out[3] = a1 * b2 + a3 * b3;266    return out;267  }268  /**269   * Rotates a mat2 by the given angle270   *271   * @param {mat2} out the receiving matrix272   * @param {mat2} a the matrix to rotate273   * @param {Number} rad the angle to rotate the matrix by274   * @returns {mat2} out275   */276  function rotate(out, a, rad) {277    var a0 = a[0],278        a1 = a[1],279        a2 = a[2],280        a3 = a[3];281    var s = Math.sin(rad);282    var c = Math.cos(rad);283    out[0] = a0 * c + a2 * s;284    out[1] = a1 * c + a3 * s;285    out[2] = a0 * -s + a2 * c;286    out[3] = a1 * -s + a3 * c;287    return out;288  }289  /**290   * Scales the mat2 by the dimensions in the given vec2291   *292   * @param {mat2} out the receiving matrix293   * @param {mat2} a the matrix to rotate294   * @param {vec2} v the vec2 to scale the matrix by295   * @returns {mat2} out296   **/297  function scale(out, a, v) {298    var a0 = a[0],299        a1 = a[1],300        a2 = a[2],301        a3 = a[3];302    var v0 = v[0],303        v1 = v[1];304    out[0] = a0 * v0;305    out[1] = a1 * v0;306    out[2] = a2 * v1;307    out[3] = a3 * v1;308    return out;309  }310  /**311   * Creates a matrix from a given angle312   * This is equivalent to (but much faster than):313   *314   *     mat2.identity(dest);315   *     mat2.rotate(dest, dest, rad);316   *317   * @param {mat2} out mat2 receiving operation result318   * @param {Number} rad the angle to rotate the matrix by319   * @returns {mat2} out320   */321  function fromRotation(out, rad) {322    var s = Math.sin(rad);323    var c = Math.cos(rad);324    out[0] = c;325    out[1] = s;326    out[2] = -s;327    out[3] = c;328    return out;329  }330  /**331   * Creates a matrix from a vector scaling332   * This is equivalent to (but much faster than):333   *334   *     mat2.identity(dest);335   *     mat2.scale(dest, dest, vec);336   *337   * @param {mat2} out mat2 receiving operation result338   * @param {vec2} v Scaling vector339   * @returns {mat2} out340   */341  function fromScaling(out, v) {342    out[0] = v[0];343    out[1] = 0;344    out[2] = 0;345    out[3] = v[1];346    return out;347  }348  /**349   * Returns a string representation of a mat2350   *351   * @param {mat2} a matrix to represent as a string352   * @returns {String} string representation of the matrix353   */354  function str(a) {355    return 'mat2(' + a[0] + ', ' + a[1] + ', ' + a[2] + ', ' + a[3] + ')';356  }357  /**358   * Returns Frobenius norm of a mat2359   *360   * @param {mat2} a the matrix to calculate Frobenius norm of361   * @returns {Number} Frobenius norm362   */363  function frob(a) {364    return Math.hypot(a[0], a[1], a[2], a[3]);365  }366  /**367   * Returns L, D and U matrices (Lower triangular, Diagonal and Upper triangular) by factorizing the input matrix368   * @param {mat2} L the lower triangular matrix369   * @param {mat2} D the diagonal matrix370   * @param {mat2} U the upper triangular matrix371   * @param {mat2} a the input matrix to factorize372   */373  function LDU(L, D, U, a) {374    L[2] = a[2] / a[0];375    U[0] = a[0];376    U[1] = a[1];377    U[3] = a[3] - L[2] * U[1];378    return [L, D, U];379  }380  /**381   * Adds two mat2's382   *383   * @param {mat2} out the receiving matrix384   * @param {mat2} a the first operand385   * @param {mat2} b the second operand386   * @returns {mat2} out387   */388  function add(out, a, b) {389    out[0] = a[0] + b[0];390    out[1] = a[1] + b[1];391    out[2] = a[2] + b[2];392    out[3] = a[3] + b[3];393    return out;394  }395  /**396   * Subtracts matrix b from matrix a397   *398   * @param {mat2} out the receiving matrix399   * @param {mat2} a the first operand400   * @param {mat2} b the second operand401   * @returns {mat2} out402   */403  function subtract(out, a, b) {404    out[0] = a[0] - b[0];405    out[1] = a[1] - b[1];406    out[2] = a[2] - b[2];407    out[3] = a[3] - b[3];408    return out;409  }410  /**411   * Returns whether or not the matrices have exactly the same elements in the same position (when compared with ===)412   *413   * @param {mat2} a The first matrix.414   * @param {mat2} b The second matrix.415   * @returns {Boolean} True if the matrices are equal, false otherwise.416   */417  function exactEquals(a, b) {418    return a[0] === b[0] && a[1] === b[1] && a[2] === b[2] && a[3] === b[3];419  }420  /**421   * Returns whether or not the matrices have approximately the same elements in the same position.422   *423   * @param {mat2} a The first matrix.424   * @param {mat2} b The second matrix.425   * @returns {Boolean} True if the matrices are equal, false otherwise.426   */427  function equals$1(a, b) {428    var a0 = a[0],429        a1 = a[1],430        a2 = a[2],431        a3 = a[3];432    var b0 = b[0],433        b1 = b[1],434        b2 = b[2],435        b3 = b[3];436    return Math.abs(a0 - b0) <= EPSILON * Math.max(1.0, Math.abs(a0), Math.abs(b0)) && Math.abs(a1 - b1) <= EPSILON * Math.max(1.0, Math.abs(a1), Math.abs(b1)) && Math.abs(a2 - b2) <= EPSILON * Math.max(1.0, Math.abs(a2), Math.abs(b2)) && Math.abs(a3 - b3) <= EPSILON * Math.max(1.0, Math.abs(a3), Math.abs(b3));437  }438  /**439   * Multiply each element of the matrix by a scalar.440   *441   * @param {mat2} out the receiving matrix442   * @param {mat2} a the matrix to scale443   * @param {Number} b amount to scale the matrix's elements by444   * @returns {mat2} out445   */446  function multiplyScalar(out, a, b) {447    out[0] = a[0] * b;448    out[1] = a[1] * b;449    out[2] = a[2] * b;450    out[3] = a[3] * b;451    return out;452  }453  /**454   * Adds two mat2's after multiplying each element of the second operand by a scalar value.455   *456   * @param {mat2} out the receiving vector457   * @param {mat2} a the first operand458   * @param {mat2} b the second operand459   * @param {Number} scale the amount to scale b's elements by before adding460   * @returns {mat2} out461   */462  function multiplyScalarAndAdd(out, a, b, scale) {463    out[0] = a[0] + b[0] * scale;464    out[1] = a[1] + b[1] * scale;465    out[2] = a[2] + b[2] * scale;466    out[3] = a[3] + b[3] * scale;467    return out;468  }469  /**470   * Alias for {@link mat2.multiply}471   * @function472   */473  var mul = multiply;474  /**475   * Alias for {@link mat2.subtract}476   * @function477   */478  var sub = subtract;479  var mat2 = /*#__PURE__*/Object.freeze({480    create: create,481    clone: clone,482    copy: copy,483    identity: identity,484    fromValues: fromValues,485    set: set,486    transpose: transpose,487    invert: invert,488    adjoint: adjoint,489    determinant: determinant,490    multiply: multiply,491    rotate: rotate,492    scale: scale,493    fromRotation: fromRotation,494    fromScaling: fromScaling,495    str: str,496    frob: frob,497    LDU: LDU,498    add: add,499    subtract: subtract,500    exactEquals: exactEquals,501    equals: equals$1,502    multiplyScalar: multiplyScalar,503    multiplyScalarAndAdd: multiplyScalarAndAdd,504    mul: mul,505    sub: sub506  });507  /**508   * 2x3 Matrix509   * @module mat2d510   *511   * @description512   * A mat2d contains six elements defined as:513   * <pre>514   * [a, c, tx,515   *  b, d, ty]516   * </pre>517   * This is a short form for the 3x3 matrix:518   * <pre>519   * [a, c, tx,520   *  b, d, ty,521   *  0, 0, 1]522   * </pre>523   * The last row is ignored so the array is shorter and operations are faster.524   */525  /**526   * Creates a new identity mat2d527   *528   * @returns {mat2d} a new 2x3 matrix529   */530  function create$1() {531    var out = new ARRAY_TYPE(6);532    if (ARRAY_TYPE != Float32Array) {533      out[1] = 0;534      out[2] = 0;535      out[4] = 0;536      out[5] = 0;537    }538    out[0] = 1;539    out[3] = 1;540    return out;541  }542  /**543   * Creates a new mat2d initialized with values from an existing matrix544   *545   * @param {mat2d} a matrix to clone546   * @returns {mat2d} a new 2x3 matrix547   */548  function clone$1(a) {549    var out = new ARRAY_TYPE(6);550    out[0] = a[0];551    out[1] = a[1];552    out[2] = a[2];553    out[3] = a[3];554    out[4] = a[4];555    out[5] = a[5];556    return out;557  }558  /**559   * Copy the values from one mat2d to another560   *561   * @param {mat2d} out the receiving matrix562   * @param {mat2d} a the source matrix563   * @returns {mat2d} out564   */565  function copy$1(out, a) {566    out[0] = a[0];567    out[1] = a[1];568    out[2] = a[2];569    out[3] = a[3];570    out[4] = a[4];571    out[5] = a[5];572    return out;573  }574  /**575   * Set a mat2d to the identity matrix576   *577   * @param {mat2d} out the receiving matrix578   * @returns {mat2d} out579   */580  function identity$1(out) {581    out[0] = 1;582    out[1] = 0;583    out[2] = 0;584    out[3] = 1;585    out[4] = 0;586    out[5] = 0;587    return out;588  }589  /**590   * Create a new mat2d with the given values591   *592   * @param {Number} a Component A (index 0)593   * @param {Number} b Component B (index 1)594   * @param {Number} c Component C (index 2)595   * @param {Number} d Component D (index 3)596   * @param {Number} tx Component TX (index 4)597   * @param {Number} ty Component TY (index 5)598   * @returns {mat2d} A new mat2d599   */600  function fromValues$1(a, b, c, d, tx, ty) {601    var out = new ARRAY_TYPE(6);602    out[0] = a;603    out[1] = b;604    out[2] = c;605    out[3] = d;606    out[4] = tx;607    out[5] = ty;608    return out;609  }610  /**611   * Set the components of a mat2d to the given values612   *613   * @param {mat2d} out the receiving matrix614   * @param {Number} a Component A (index 0)615   * @param {Number} b Component B (index 1)616   * @param {Number} c Component C (index 2)617   * @param {Number} d Component D (index 3)618   * @param {Number} tx Component TX (index 4)619   * @param {Number} ty Component TY (index 5)620   * @returns {mat2d} out621   */622  function set$1(out, a, b, c, d, tx, ty) {623    out[0] = a;624    out[1] = b;625    out[2] = c;626    out[3] = d;627    out[4] = tx;628    out[5] = ty;629    return out;630  }631  /**632   * Inverts a mat2d633   *634   * @param {mat2d} out the receiving matrix635   * @param {mat2d} a the source matrix636   * @returns {mat2d} out637   */638  function invert$1(out, a) {639    var aa = a[0],640        ab = a[1],641        ac = a[2],642        ad = a[3];643    var atx = a[4],644        aty = a[5];645    var det = aa * ad - ab * ac;646    if (!det) {647      return null;648    }649    det = 1.0 / det;650    out[0] = ad * det;651    out[1] = -ab * det;652    out[2] = -ac * det;653    out[3] = aa * det;654    out[4] = (ac * aty - ad * atx) * det;655    out[5] = (ab * atx - aa * aty) * det;656    return out;657  }658  /**659   * Calculates the determinant of a mat2d660   *661   * @param {mat2d} a the source matrix662   * @returns {Number} determinant of a663   */664  function determinant$1(a) {665    return a[0] * a[3] - a[1] * a[2];666  }667  /**668   * Multiplies two mat2d's669   *670   * @param {mat2d} out the receiving matrix671   * @param {mat2d} a the first operand672   * @param {mat2d} b the second operand673   * @returns {mat2d} out674   */675  function multiply$1(out, a, b) {676    var a0 = a[0],677        a1 = a[1],678        a2 = a[2],679        a3 = a[3],680        a4 = a[4],681        a5 = a[5];682    var b0 = b[0],683        b1 = b[1],684        b2 = b[2],685        b3 = b[3],686        b4 = b[4],687        b5 = b[5];688    out[0] = a0 * b0 + a2 * b1;689    out[1] = a1 * b0 + a3 * b1;690    out[2] = a0 * b2 + a2 * b3;691    out[3] = a1 * b2 + a3 * b3;692    out[4] = a0 * b4 + a2 * b5 + a4;693    out[5] = a1 * b4 + a3 * b5 + a5;694    return out;695  }696  /**697   * Rotates a mat2d by the given angle698   *699   * @param {mat2d} out the receiving matrix700   * @param {mat2d} a the matrix to rotate701   * @param {Number} rad the angle to rotate the matrix by702   * @returns {mat2d} out703   */704  function rotate$1(out, a, rad) {705    var a0 = a[0],706        a1 = a[1],707        a2 = a[2],708        a3 = a[3],709        a4 = a[4],710        a5 = a[5];711    var s = Math.sin(rad);712    var c = Math.cos(rad);713    out[0] = a0 * c + a2 * s;714    out[1] = a1 * c + a3 * s;715    out[2] = a0 * -s + a2 * c;716    out[3] = a1 * -s + a3 * c;717    out[4] = a4;718    out[5] = a5;719    return out;720  }721  /**722   * Scales the mat2d by the dimensions in the given vec2723   *724   * @param {mat2d} out the receiving matrix725   * @param {mat2d} a the matrix to translate726   * @param {vec2} v the vec2 to scale the matrix by727   * @returns {mat2d} out728   **/729  function scale$1(out, a, v) {730    var a0 = a[0],731        a1 = a[1],732        a2 = a[2],733        a3 = a[3],734        a4 = a[4],735        a5 = a[5];736    var v0 = v[0],737        v1 = v[1];738    out[0] = a0 * v0;739    out[1] = a1 * v0;740    out[2] = a2 * v1;741    out[3] = a3 * v1;742    out[4] = a4;743    out[5] = a5;744    return out;745  }746  /**747   * Translates the mat2d by the dimensions in the given vec2748   *749   * @param {mat2d} out the receiving matrix750   * @param {mat2d} a the matrix to translate751   * @param {vec2} v the vec2 to translate the matrix by752   * @returns {mat2d} out753   **/754  function translate(out, a, v) {755    var a0 = a[0],756        a1 = a[1],757        a2 = a[2],758        a3 = a[3],759        a4 = a[4],760        a5 = a[5];761    var v0 = v[0],762        v1 = v[1];763    out[0] = a0;764    out[1] = a1;765    out[2] = a2;766    out[3] = a3;767    out[4] = a0 * v0 + a2 * v1 + a4;768    out[5] = a1 * v0 + a3 * v1 + a5;769    return out;770  }771  /**772   * Creates a matrix from a given angle773   * This is equivalent to (but much faster than):774   *775   *     mat2d.identity(dest);776   *     mat2d.rotate(dest, dest, rad);777   *778   * @param {mat2d} out mat2d receiving operation result779   * @param {Number} rad the angle to rotate the matrix by780   * @returns {mat2d} out781   */782  function fromRotation$1(out, rad) {783    var s = Math.sin(rad),784        c = Math.cos(rad);785    out[0] = c;786    out[1] = s;787    out[2] = -s;788    out[3] = c;789    out[4] = 0;790    out[5] = 0;791    return out;792  }793  /**794   * Creates a matrix from a vector scaling795   * This is equivalent to (but much faster than):796   *797   *     mat2d.identity(dest);798   *     mat2d.scale(dest, dest, vec);799   *800   * @param {mat2d} out mat2d receiving operation result801   * @param {vec2} v Scaling vector802   * @returns {mat2d} out803   */804  function fromScaling$1(out, v) {805    out[0] = v[0];806    out[1] = 0;807    out[2] = 0;808    out[3] = v[1];809    out[4] = 0;810    out[5] = 0;811    return out;812  }813  /**814   * Creates a matrix from a vector translation815   * This is equivalent to (but much faster than):816   *817   *     mat2d.identity(dest);818   *     mat2d.translate(dest, dest, vec);819   *820   * @param {mat2d} out mat2d receiving operation result821   * @param {vec2} v Translation vector822   * @returns {mat2d} out823   */824  function fromTranslation(out, v) {825    out[0] = 1;826    out[1] = 0;827    out[2] = 0;828    out[3] = 1;829    out[4] = v[0];830    out[5] = v[1];831    return out;832  }833  /**834   * Returns a string representation of a mat2d835   *836   * @param {mat2d} a matrix to represent as a string837   * @returns {String} string representation of the matrix838   */839  function str$1(a) {840    return 'mat2d(' + a[0] + ', ' + a[1] + ', ' + a[2] + ', ' + a[3] + ', ' + a[4] + ', ' + a[5] + ')';841  }842  /**843   * Returns Frobenius norm of a mat2d844   *845   * @param {mat2d} a the matrix to calculate Frobenius norm of846   * @returns {Number} Frobenius norm847   */848  function frob$1(a) {849    return Math.hypot(a[0], a[1], a[2], a[3], a[4], a[5], 1);850  }851  /**852   * Adds two mat2d's853   *854   * @param {mat2d} out the receiving matrix855   * @param {mat2d} a the first operand856   * @param {mat2d} b the second operand857   * @returns {mat2d} out858   */859  function add$1(out, a, b) {860    out[0] = a[0] + b[0];861    out[1] = a[1] + b[1];862    out[2] = a[2] + b[2];863    out[3] = a[3] + b[3];864    out[4] = a[4] + b[4];865    out[5] = a[5] + b[5];866    return out;867  }868  /**869   * Subtracts matrix b from matrix a870   *871   * @param {mat2d} out the receiving matrix872   * @param {mat2d} a the first operand873   * @param {mat2d} b the second operand874   * @returns {mat2d} out875   */876  function subtract$1(out, a, b) {877    out[0] = a[0] - b[0];878    out[1] = a[1] - b[1];879    out[2] = a[2] - b[2];880    out[3] = a[3] - b[3];881    out[4] = a[4] - b[4];882    out[5] = a[5] - b[5];883    return out;884  }885  /**886   * Multiply each element of the matrix by a scalar.887   *888   * @param {mat2d} out the receiving matrix889   * @param {mat2d} a the matrix to scale890   * @param {Number} b amount to scale the matrix's elements by891   * @returns {mat2d} out892   */893  function multiplyScalar$1(out, a, b) {894    out[0] = a[0] * b;895    out[1] = a[1] * b;896    out[2] = a[2] * b;897    out[3] = a[3] * b;898    out[4] = a[4] * b;899    out[5] = a[5] * b;900    return out;901  }902  /**903   * Adds two mat2d's after multiplying each element of the second operand by a scalar value.904   *905   * @param {mat2d} out the receiving vector906   * @param {mat2d} a the first operand907   * @param {mat2d} b the second operand908   * @param {Number} scale the amount to scale b's elements by before adding909   * @returns {mat2d} out910   */911  function multiplyScalarAndAdd$1(out, a, b, scale) {912    out[0] = a[0] + b[0] * scale;913    out[1] = a[1] + b[1] * scale;914    out[2] = a[2] + b[2] * scale;915    out[3] = a[3] + b[3] * scale;916    out[4] = a[4] + b[4] * scale;917    out[5] = a[5] + b[5] * scale;918    return out;919  }920  /**921   * Returns whether or not the matrices have exactly the same elements in the same position (when compared with ===)922   *923   * @param {mat2d} a The first matrix.924   * @param {mat2d} b The second matrix.925   * @returns {Boolean} True if the matrices are equal, false otherwise.926   */927  function exactEquals$1(a, b) {928    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];929  }930  /**931   * Returns whether or not the matrices have approximately the same elements in the same position.932   *933   * @param {mat2d} a The first matrix.934   * @param {mat2d} b The second matrix.935   * @returns {Boolean} True if the matrices are equal, false otherwise.936   */937  function equals$2(a, b) {938    var a0 = a[0],939        a1 = a[1],940        a2 = a[2],941        a3 = a[3],942        a4 = a[4],943        a5 = a[5];944    var b0 = b[0],945        b1 = b[1],946        b2 = b[2],947        b3 = b[3],948        b4 = b[4],949        b5 = b[5];950    return Math.abs(a0 - b0) <= EPSILON * Math.max(1.0, Math.abs(a0), Math.abs(b0)) && Math.abs(a1 - b1) <= EPSILON * Math.max(1.0, Math.abs(a1), Math.abs(b1)) && Math.abs(a2 - b2) <= EPSILON * Math.max(1.0, Math.abs(a2), Math.abs(b2)) && Math.abs(a3 - b3) <= EPSILON * Math.max(1.0, Math.abs(a3), Math.abs(b3)) && Math.abs(a4 - b4) <= EPSILON * Math.max(1.0, Math.abs(a4), Math.abs(b4)) && Math.abs(a5 - b5) <= EPSILON * Math.max(1.0, Math.abs(a5), Math.abs(b5));951  }952  /**953   * Alias for {@link mat2d.multiply}954   * @function955   */956  var mul$1 = multiply$1;957  /**958   * Alias for {@link mat2d.subtract}959   * @function960   */961  var sub$1 = subtract$1;962  var mat2d = /*#__PURE__*/Object.freeze({963    create: create$1,964    clone: clone$1,965    copy: copy$1,966    identity: identity$1,967    fromValues: fromValues$1,968    set: set$1,969    invert: invert$1,970    determinant: determinant$1,971    multiply: multiply$1,972    rotate: rotate$1,973    scale: scale$1,974    translate: translate,975    fromRotation: fromRotation$1,976    fromScaling: fromScaling$1,977    fromTranslation: fromTranslation,978    str: str$1,979    frob: frob$1,980    add: add$1,981    subtract: subtract$1,982    multiplyScalar: multiplyScalar$1,983    multiplyScalarAndAdd: multiplyScalarAndAdd$1,984    exactEquals: exactEquals$1,985    equals: equals$2,986    mul: mul$1,987    sub: sub$1988  });989  /**990   * 3x3 Matrix991   * @module mat3992   */993  /**994   * Creates a new identity mat3995   *996   * @returns {mat3} a new 3x3 matrix997   */998  function create$2() {999    var out = new ARRAY_TYPE(9);1000    if (ARRAY_TYPE != Float32Array) {1001      out[1] = 0;1002      out[2] = 0;1003      out[3] = 0;1004      out[5] = 0;1005      out[6] = 0;1006      out[7] = 0;1007    }1008    out[0] = 1;1009    out[4] = 1;1010    out[8] = 1;1011    return out;1012  }1013  /**1014   * Copies the upper-left 3x3 values into the given mat3.1015   *1016   * @param {mat3} out the receiving 3x3 matrix1017   * @param {mat4} a   the source 4x4 matrix1018   * @returns {mat3} out1019   */1020  function fromMat4(out, a) {1021    out[0] = a[0];1022    out[1] = a[1];1023    out[2] = a[2];1024    out[3] = a[4];1025    out[4] = a[5];1026    out[5] = a[6];1027    out[6] = a[8];1028    out[7] = a[9];1029    out[8] = a[10];1030    return out;1031  }1032  /**1033   * Creates a new mat3 initialized with values from an existing matrix1034   *1035   * @param {mat3} a matrix to clone1036   * @returns {mat3} a new 3x3 matrix1037   */1038  function clone$2(a) {1039    var out = new ARRAY_TYPE(9);1040    out[0] = a[0];1041    out[1] = a[1];1042    out[2] = a[2];1043    out[3] = a[3];1044    out[4] = a[4];1045    out[5] = a[5];1046    out[6] = a[6];1047    out[7] = a[7];1048    out[8] = a[8];1049    return out;1050  }1051  /**1052   * Copy the values from one mat3 to another1053   *1054   * @param {mat3} out the receiving matrix1055   * @param {mat3} a the source matrix1056   * @returns {mat3} out1057   */1058  function copy$2(out, a) {1059    out[0] = a[0];1060    out[1] = a[1];1061    out[2] = a[2];1062    out[3] = a[3];1063    out[4] = a[4];1064    out[5] = a[5];1065    out[6] = a[6];1066    out[7] = a[7];1067    out[8] = a[8];1068    return out;1069  }1070  /**1071   * Create a new mat3 with the given values1072   *1073   * @param {Number} m00 Component in column 0, row 0 position (index 0)1074   * @param {Number} m01 Component in column 0, row 1 position (index 1)1075   * @param {Number} m02 Component in column 0, row 2 position (index 2)1076   * @param {Number} m10 Component in column 1, row 0 position (index 3)1077   * @param {Number} m11 Component in column 1, row 1 position (index 4)1078   * @param {Number} m12 Component in column 1, row 2 position (index 5)1079   * @param {Number} m20 Component in column 2, row 0 position (index 6)1080   * @param {Number} m21 Component in column 2, row 1 position (index 7)1081   * @param {Number} m22 Component in column 2, row 2 position (index 8)1082   * @returns {mat3} A new mat31083   */1084  function fromValues$2(m00, m01, m02, m10, m11, m12, m20, m21, m22) {1085    var out = new ARRAY_TYPE(9);1086    out[0] = m00;1087    out[1] = m01;1088    out[2] = m02;1089    out[3] = m10;1090    out[4] = m11;1091    out[5] = m12;1092    out[6] = m20;1093    out[7] = m21;1094    out[8] = m22;1095    return out;1096  }1097  /**1098   * Set the components of a mat3 to the given values1099   *1100   * @param {mat3} out the receiving matrix1101   * @param {Number} m00 Component in column 0, row 0 position (index 0)1102   * @param {Number} m01 Component in column 0, row 1 position (index 1)1103   * @param {Number} m02 Component in column 0, row 2 position (index 2)1104   * @param {Number} m10 Component in column 1, row 0 position (index 3)1105   * @param {Number} m11 Component in column 1, row 1 position (index 4)1106   * @param {Number} m12 Component in column 1, row 2 position (index 5)1107   * @param {Number} m20 Component in column 2, row 0 position (index 6)1108   * @param {Number} m21 Component in column 2, row 1 position (index 7)1109   * @param {Number} m22 Component in column 2, row 2 position (index 8)1110   * @returns {mat3} out1111   */1112  function set$2(out, m00, m01, m02, m10, m11, m12, m20, m21, m22) {1113    out[0] = m00;1114    out[1] = m01;1115    out[2] = m02;1116    out[3] = m10;1117    out[4] = m11;1118    out[5] = m12;1119    out[6] = m20;1120    out[7] = m21;1121    out[8] = m22;1122    return out;1123  }1124  /**1125   * Set a mat3 to the identity matrix1126   *1127   * @param {mat3} out the receiving matrix1128   * @returns {mat3} out1129   */1130  function identity$2(out) {1131    out[0] = 1;1132    out[1] = 0;1133    out[2] = 0;1134    out[3] = 0;1135    out[4] = 1;1136    out[5] = 0;1137    out[6] = 0;1138    out[7] = 0;1139    out[8] = 1;1140    return out;1141  }1142  /**1143   * Transpose the values of a mat31144   *1145   * @param {mat3} out the receiving matrix1146   * @param {mat3} a the source matrix1147   * @returns {mat3} out1148   */1149  function transpose$1(out, a) {1150    // If we are transposing ourselves we can skip a few steps but have to cache some values1151    if (out === a) {1152      var a01 = a[1],1153          a02 = a[2],1154          a12 = a[5];1155      out[1] = a[3];1156      out[2] = a[6];1157      out[3] = a01;1158      out[5] = a[7];1159      out[6] = a02;1160      out[7] = a12;1161    } else {1162      out[0] = a[0];1163      out[1] = a[3];1164      out[2] = a[6];1165      out[3] = a[1];1166      out[4] = a[4];1167      out[5] = a[7];1168      out[6] = a[2];1169      out[7] = a[5];1170      out[8] = a[8];1171    }1172    return out;1173  }1174  /**1175   * Inverts a mat31176   *1177   * @param {mat3} out the receiving matrix1178   * @param {mat3} a the source matrix1179   * @returns {mat3} out1180   */1181  function invert$2(out, a) {1182    var a00 = a[0],1183        a01 = a[1],1184        a02 = a[2];1185    var a10 = a[3],1186        a11 = a[4],1187        a12 = a[5];1188    var a20 = a[6],1189        a21 = a[7],1190        a22 = a[8];1191    var b01 = a22 * a11 - a12 * a21;1192    var b11 = -a22 * a10 + a12 * a20;1193    var b21 = a21 * a10 - a11 * a20; // Calculate the determinant1194    var det = a00 * b01 + a01 * b11 + a02 * b21;1195    if (!det) {1196      return null;1197    }1198    det = 1.0 / det;1199    out[0] = b01 * det;1200    out[1] = (-a22 * a01 + a02 * a21) * det;1201    out[2] = (a12 * a01 - a02 * a11) * det;1202    out[3] = b11 * det;1203    out[4] = (a22 * a00 - a02 * a20) * det;1204    out[5] = (-a12 * a00 + a02 * a10) * det;1205    out[6] = b21 * det;1206    out[7] = (-a21 * a00 + a01 * a20) * det;1207    out[8] = (a11 * a00 - a01 * a10) * det;1208    return out;1209  }1210  /**1211   * Calculates the adjugate of a mat31212   *1213   * @param {mat3} out the receiving matrix1214   * @param {mat3} a the source matrix1215   * @returns {mat3} out1216   */1217  function adjoint$1(out, a) {1218    var a00 = a[0],1219        a01 = a[1],1220        a02 = a[2];1221    var a10 = a[3],1222        a11 = a[4],1223        a12 = a[5];1224    var a20 = a[6],1225        a21 = a[7],1226        a22 = a[8];1227    out[0] = a11 * a22 - a12 * a21;1228    out[1] = a02 * a21 - a01 * a22;1229    out[2] = a01 * a12 - a02 * a11;1230    out[3] = a12 * a20 - a10 * a22;1231    out[4] = a00 * a22 - a02 * a20;1232    out[5] = a02 * a10 - a00 * a12;1233    out[6] = a10 * a21 - a11 * a20;1234    out[7] = a01 * a20 - a00 * a21;1235    out[8] = a00 * a11 - a01 * a10;1236    return out;1237  }1238  /**1239   * Calculates the determinant of a mat31240   *1241   * @param {mat3} a the source matrix1242   * @returns {Number} determinant of a1243   */1244  function determinant$2(a) {1245    var a00 = a[0],1246        a01 = a[1],1247        a02 = a[2];1248    var a10 = a[3],1249        a11 = a[4],1250        a12 = a[5];1251    var a20 = a[6],1252        a21 = a[7],1253        a22 = a[8];1254    return a00 * (a22 * a11 - a12 * a21) + a01 * (-a22 * a10 + a12 * a20) + a02 * (a21 * a10 - a11 * a20);1255  }1256  /**1257   * Multiplies two mat3's1258   *1259   * @param {mat3} out the receiving matrix1260   * @param {mat3} a the first operand1261   * @param {mat3} b the second operand1262   * @returns {mat3} out1263   */1264  function multiply$2(out, a, b) {1265    var a00 = a[0],1266        a01 = a[1],1267        a02 = a[2];1268    var a10 = a[3],1269        a11 = a[4],1270        a12 = a[5];1271    var a20 = a[6],1272        a21 = a[7],1273        a22 = a[8];1274    var b00 = b[0],1275        b01 = b[1],1276        b02 = b[2];1277    var b10 = b[3],1278        b11 = b[4],1279        b12 = b[5];1280    var b20 = b[6],1281        b21 = b[7],1282        b22 = b[8];1283    out[0] = b00 * a00 + b01 * a10 + b02 * a20;1284    out[1] = b00 * a01 + b01 * a11 + b02 * a21;1285    out[2] = b00 * a02 + b01 * a12 + b02 * a22;1286    out[3] = b10 * a00 + b11 * a10 + b12 * a20;1287    out[4] = b10 * a01 + b11 * a11 + b12 * a21;1288    out[5] = b10 * a02 + b11 * a12 + b12 * a22;1289    out[6] = b20 * a00 + b21 * a10 + b22 * a20;1290    out[7] = b20 * a01 + b21 * a11 + b22 * a21;1291    out[8] = b20 * a02 + b21 * a12 + b22 * a22;1292    return out;1293  }1294  /**1295   * Translate a mat3 by the given vector1296   *1297   * @param {mat3} out the receiving matrix1298   * @param {mat3} a the matrix to translate1299   * @param {vec2} v vector to translate by1300   * @returns {mat3} out1301   */1302  function translate$1(out, a, v) {1303    var a00 = a[0],1304        a01 = a[1],1305        a02 = a[2],1306        a10 = a[3],1307        a11 = a[4],1308        a12 = a[5],1309        a20 = a[6],1310        a21 = a[7],1311        a22 = a[8],1312        x = v[0],1313        y = v[1];1314    out[0] = a00;1315    out[1] = a01;1316    out[2] = a02;1317    out[3] = a10;1318    out[4] = a11;1319    out[5] = a12;1320    out[6] = x * a00 + y * a10 + a20;1321    out[7] = x * a01 + y * a11 + a21;1322    out[8] = x * a02 + y * a12 + a22;1323    return out;1324  }1325  /**1326   * Rotates a mat3 by the given angle1327   *1328   * @param {mat3} out the receiving matrix1329   * @param {mat3} a the matrix to rotate1330   * @param {Number} rad the angle to rotate the matrix by1331   * @returns {mat3} out1332   */1333  function rotate$2(out, a, rad) {1334    var a00 = a[0],1335        a01 = a[1],1336        a02 = a[2],1337        a10 = a[3],1338        a11 = a[4],1339        a12 = a[5],1340        a20 = a[6],1341        a21 = a[7],1342        a22 = a[8],1343        s = Math.sin(rad),1344        c = Math.cos(rad);1345    out[0] = c * a00 + s * a10;1346    out[1] = c * a01 + s * a11;1347    out[2] = c * a02 + s * a12;1348    out[3] = c * a10 - s * a00;1349    out[4] = c * a11 - s * a01;1350    out[5] = c * a12 - s * a02;1351    out[6] = a20;1352    out[7] = a21;1353    out[8] = a22;1354    return out;1355  }1356  /**1357   * Scales the mat3 by the dimensions in the given vec21358   *1359   * @param {mat3} out the receiving matrix1360   * @param {mat3} a the matrix to rotate1361   * @param {vec2} v the vec2 to scale the matrix by1362   * @returns {mat3} out1363   **/1364  function scale$2(out, a, v) {1365    var x = v[0],1366        y = v[1];1367    out[0] = x * a[0];1368    out[1] = x * a[1];1369    out[2] = x * a[2];1370    out[3] = y * a[3];1371    out[4] = y * a[4];1372    out[5] = y * a[5];1373    out[6] = a[6];1374    out[7] = a[7];1375    out[8] = a[8];1376    return out;1377  }1378  /**1379   * Creates a matrix from a vector translation1380   * This is equivalent to (but much faster than):1381   *1382   *     mat3.identity(dest);1383   *     mat3.translate(dest, dest, vec);1384   *1385   * @param {mat3} out mat3 receiving operation result1386   * @param {vec2} v Translation vector1387   * @returns {mat3} out1388   */1389  function fromTranslation$1(out, v) {1390    out[0] = 1;1391    out[1] = 0;1392    out[2] = 0;1393    out[3] = 0;1394    out[4] = 1;1395    out[5] = 0;1396    out[6] = v[0];1397    out[7] = v[1];1398    out[8] = 1;1399    return out;1400  }1401  /**1402   * Creates a matrix from a given angle1403   * This is equivalent to (but much faster than):1404   *1405   *     mat3.identity(dest);1406   *     mat3.rotate(dest, dest, rad);1407   *1408   * @param {mat3} out mat3 receiving operation result1409   * @param {Number} rad the angle to rotate the matrix by1410   * @returns {mat3} out1411   */1412  function fromRotation$2(out, rad) {1413    var s = Math.sin(rad),1414        c = Math.cos(rad);1415    out[0] = c;1416    out[1] = s;1417    out[2] = 0;1418    out[3] = -s;1419    out[4] = c;1420    out[5] = 0;1421    out[6] = 0;1422    out[7] = 0;1423    out[8] = 1;1424    return out;1425  }1426  /**1427   * Creates a matrix from a vector scaling1428   * This is equivalent to (but much faster than):1429   *1430   *     mat3.identity(dest);1431   *     mat3.scale(dest, dest, vec);1432   *1433   * @param {mat3} out mat3 receiving operation result1434   * @param {vec2} v Scaling vector1435   * @returns {mat3} out1436   */1437  function fromScaling$2(out, v) {1438    out[0] = v[0];1439    out[1] = 0;1440    out[2] = 0;1441    out[3] = 0;1442    out[4] = v[1];1443    out[5] = 0;1444    out[6] = 0;1445    out[7] = 0;1446    out[8] = 1;1447    return out;1448  }1449  /**1450   * Copies the values from a mat2d into a mat31451   *1452   * @param {mat3} out the receiving matrix1453   * @param {mat2d} a the matrix to copy1454   * @returns {mat3} out1455   **/1456  function fromMat2d(out, a) {1457    out[0] = a[0];1458    out[1] = a[1];1459    out[2] = 0;1460    out[3] = a[2];1461    out[4] = a[3];1462    out[5] = 0;1463    out[6] = a[4];1464    out[7] = a[5];1465    out[8] = 1;1466    return out;1467  }1468  /**1469  * Calculates a 3x3 matrix from the given quaternion1470  *1471  * @param {mat3} out mat3 receiving operation result1472  * @param {quat} q Quaternion to create matrix from1473  *1474  * @returns {mat3} out1475  */1476  function fromQuat(out, q) {1477    var x = q[0],1478        y = q[1],1479        z = q[2],1480        w = q[3];1481    var x2 = x + x;1482    var y2 = y + y;1483    var z2 = z + z;1484    var xx = x * x2;1485    var yx = y * x2;1486    var yy = y * y2;1487    var zx = z * x2;1488    var zy = z * y2;1489    var zz = z * z2;1490    var wx = w * x2;1491    var wy = w * y2;1492    var wz = w * z2;1493    out[0] = 1 - yy - zz;1494    out[3] = yx - wz;1495    out[6] = zx + wy;1496    out[1] = yx + wz;1497    out[4] = 1 - xx - zz;1498    out[7] = zy - wx;1499    out[2] = zx - wy;1500    out[5] = zy + wx;1501    out[8] = 1 - xx - yy;1502    return out;1503  }1504  /**1505  * Calculates a 3x3 normal matrix (transpose inverse) from the 4x4 matrix1506  *1507  * @param {mat3} out mat3 receiving operation result1508  * @param {mat4} a Mat4 to derive the normal matrix from1509  *1510  * @returns {mat3} out1511  */1512  function normalFromMat4(out, a) {1513    var a00 = a[0],1514        a01 = a[1],1515        a02 = a[2],1516        a03 = a[3];1517    var a10 = a[4],1518        a11 = a[5],1519        a12 = a[6],1520        a13 = a[7];1521    var a20 = a[8],1522        a21 = a[9],1523        a22 = a[10],1524        a23 = a[11];1525    var a30 = a[12],1526        a31 = a[13],1527        a32 = a[14],1528        a33 = a[15];1529    var b00 = a00 * a11 - a01 * a10;1530    var b01 = a00 * a12 - a02 * a10;1531    var b02 = a00 * a13 - a03 * a10;1532    var b03 = a01 * a12 - a02 * a11;1533    var b04 = a01 * a13 - a03 * a11;1534    var b05 = a02 * a13 - a03 * a12;1535    var b06 = a20 * a31 - a21 * a30;1536    var b07 = a20 * a32 - a22 * a30;1537    var b08 = a20 * a33 - a23 * a30;1538    var b09 = a21 * a32 - a22 * a31;1539    var b10 = a21 * a33 - a23 * a31;1540    var b11 = a22 * a33 - a23 * a32; // Calculate the determinant1541    var det = b00 * b11 - b01 * b10 + b02 * b09 + b03 * b08 - b04 * b07 + b05 * b06;1542    if (!det) {1543      return null;1544    }1545    det = 1.0 / det;1546    out[0] = (a11 * b11 - a12 * b10 + a13 * b09) * det;1547    out[1] = (a12 * b08 - a10 * b11 - a13 * b07) * det;1548    out[2] = (a10 * b10 - a11 * b08 + a13 * b06) * det;1549    out[3] = (a02 * b10 - a01 * b11 - a03 * b09) * det;1550    out[4] = (a00 * b11 - a02 * b08 + a03 * b07) * det;1551    out[5] = (a01 * b08 - a00 * b10 - a03 * b06) * det;1552    out[6] = (a31 * b05 - a32 * b04 + a33 * b03) * det;1553    out[7] = (a32 * b02 - a30 * b05 - a33 * b01) * det;1554    out[8] = (a30 * b04 - a31 * b02 + a33 * b00) * det;1555    return out;1556  }1557  /**1558   * Generates a 2D projection matrix with the given bounds1559   *1560   * @param {mat3} out mat3 frustum matrix will be written into1561   * @param {number} width Width of your gl context1562   * @param {number} height Height of gl context1563   * @returns {mat3} out1564   */1565  function projection(out, width, height) {1566    out[0] = 2 / width;1567    out[1] = 0;1568    out[2] = 0;1569    out[3] = 0;1570    out[4] = -2 / height;1571    out[5] = 0;1572    out[6] = -1;1573    out[7] = 1;1574    out[8] = 1;1575    return out;1576  }1577  /**1578   * Returns a string representation of a mat31579   *1580   * @param {mat3} a matrix to represent as a string1581   * @returns {String} string representation of the matrix1582   */1583  function str$2(a) {1584    return 'mat3(' + a[0] + ', ' + a[1] + ', ' + a[2] + ', ' + a[3] + ', ' + a[4] + ', ' + a[5] + ', ' + a[6] + ', ' + a[7] + ', ' + a[8] + ')';1585  }1586  /**1587   * Returns Frobenius norm of a mat31588   *1589   * @param {mat3} a the matrix to calculate Frobenius norm of1590   * @returns {Number} Frobenius norm1591   */1592  function frob$2(a) {1593    return Math.hypot(a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7], a[8]);1594  }1595  /**1596   * Adds two mat3's1597   *1598   * @param {mat3} out the receiving matrix1599   * @param {mat3} a the first operand1600   * @param {mat3} b the second operand1601   * @returns {mat3} out1602   */1603  function add$2(out, a, b) {1604    out[0] = a[0] + b[0];1605    out[1] = a[1] + b[1];1606    out[2] = a[2] + b[2];1607    out[3] = a[3] + b[3];1608    out[4] = a[4] + b[4];1609    out[5] = a[5] + b[5];1610    out[6] = a[6] + b[6];1611    out[7] = a[7] + b[7];1612    out[8] = a[8] + b[8];1613    return out;1614  }1615  /**1616   * Subtracts matrix b from matrix a1617   *1618   * @param {mat3} out the receiving matrix1619   * @param {mat3} a the first operand1620   * @param {mat3} b the second operand1621   * @returns {mat3} out1622   */1623  function subtract$2(out, a, b) {1624    out[0] = a[0] - b[0];1625    out[1] = a[1] - b[1];1626    out[2] = a[2] - b[2];1627    out[3] = a[3] - b[3];1628    out[4] = a[4] - b[4];1629    out[5] = a[5] - b[5];1630    out[6] = a[6] - b[6];1631    out[7] = a[7] - b[7];1632    out[8] = a[8] - b[8];1633    return out;1634  }1635  /**1636   * Multiply each element of the matrix by a scalar.1637   *1638   * @param {mat3} out the receiving matrix1639   * @param {mat3} a the matrix to scale1640   * @param {Number} b amount to scale the matrix's elements by1641   * @returns {mat3} out1642   */1643  function multiplyScalar$2(out, a, b) {1644    out[0] = a[0] * b;1645    out[1] = a[1] * b;1646    out[2] = a[2] * b;1647    out[3] = a[3] * b;1648    out[4] = a[4] * b;1649    out[5] = a[5] * b;1650    out[6] = a[6] * b;1651    out[7] = a[7] * b;1652    out[8] = a[8] * b;1653    return out;1654  }1655  /**1656   * Adds two mat3's after multiplying each element of the second operand by a scalar value.1657   *1658   * @param {mat3} out the receiving vector1659   * @param {mat3} a the first operand1660   * @param {mat3} b the second operand1661   * @param {Number} scale the amount to scale b's elements by before adding1662   * @returns {mat3} out1663   */1664  function multiplyScalarAndAdd$2(out, a, b, scale) {1665    out[0] = a[0] + b[0] * scale;1666    out[1] = a[1] + b[1] * scale;1667    out[2] = a[2] + b[2] * scale;1668    out[3] = a[3] + b[3] * scale;1669    out[4] = a[4] + b[4] * scale;1670    out[5] = a[5] + b[5] * scale;1671    out[6] = a[6] + b[6] * scale;1672    out[7] = a[7] + b[7] * scale;1673    out[8] = a[8] + b[8] * scale;1674    return out;1675  }1676  /**1677   * Returns whether or not the matrices have exactly the same elements in the same position (when compared with ===)1678   *1679   * @param {mat3} a The first matrix.1680   * @param {mat3} b The second matrix.1681   * @returns {Boolean} True if the matrices are equal, false otherwise.1682   */1683  function exactEquals$2(a, b) {1684    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];1685  }1686  /**1687   * Returns whether or not the matrices have approximately the same elements in the same position.1688   *1689   * @param {mat3} a The first matrix.1690   * @param {mat3} b The second matrix.1691   * @returns {Boolean} True if the matrices are equal, false otherwise.1692   */1693  function equals$3(a, b) {1694    var a0 = a[0],1695        a1 = a[1],1696        a2 = a[2],1697        a3 = a[3],1698        a4 = a[4],1699        a5 = a[5],1700        a6 = a[6],1701        a7 = a[7],1702        a8 = a[8];1703    var b0 = b[0],1704        b1 = b[1],1705        b2 = b[2],1706        b3 = b[3],1707        b4 = b[4],1708        b5 = b[5],1709        b6 = b[6],1710        b7 = b[7],1711        b8 = b[8];1712    return Math.abs(a0 - b0) <= EPSILON * Math.max(1.0, Math.abs(a0), Math.abs(b0)) && Math.abs(a1 - b1) <= EPSILON * Math.max(1.0, Math.abs(a1), Math.abs(b1)) && Math.abs(a2 - b2) <= EPSILON * Math.max(1.0, Math.abs(a2), Math.abs(b2)) && Math.abs(a3 - b3) <= EPSILON * Math.max(1.0, Math.abs(a3), Math.abs(b3)) && Math.abs(a4 - b4) <= EPSILON * Math.max(1.0, Math.abs(a4), Math.abs(b4)) && Math.abs(a5 - b5) <= EPSILON * Math.max(1.0, Math.abs(a5), Math.abs(b5)) && Math.abs(a6 - b6) <= EPSILON * Math.max(1.0, Math.abs(a6), Math.abs(b6)) && Math.abs(a7 - b7) <= EPSILON * Math.max(1.0, Math.abs(a7), Math.abs(b7)) && Math.abs(a8 - b8) <= EPSILON * Math.max(1.0, Math.abs(a8), Math.abs(b8));1713  }1714  /**1715   * Alias for {@link mat3.multiply}1716   * @function1717   */1718  var mul$2 = multiply$2;1719  /**1720   * Alias for {@link mat3.subtract}1721   * @function1722   */1723  var sub$2 = subtract$2;1724  var mat3 = /*#__PURE__*/Object.freeze({1725    create: create$2,1726    fromMat4: fromMat4,1727    clone: clone$2,1728    copy: copy$2,1729    fromValues: fromValues$2,1730    set: set$2,1731    identity: identity$2,1732    transpose: transpose$1,1733    invert: invert$2,1734    adjoint: adjoint$1,1735    determinant: determinant$2,1736    multiply: multiply$2,1737    translate: translate$1,1738    rotate: rotate$2,1739    scale: scale$2,1740    fromTranslation: fromTranslation$1,1741    fromRotation: fromRotation$2,1742    fromScaling: fromScaling$2,1743    fromMat2d: fromMat2d,1744    fromQuat: fromQuat,1745    normalFromMat4: normalFromMat4,1746    projection: projection,1747    str: str$2,1748    frob: frob$2,1749    add: add$2,1750    subtract: subtract$2,1751    multiplyScalar: multiplyScalar$2,1752    multiplyScalarAndAdd: multiplyScalarAndAdd$2,1753    exactEquals: exactEquals$2,1754    equals: equals$3,1755    mul: mul$2,1756    sub: sub$21757  });1758  /**1759   * 4x4 Matrix<br>Format: column-major, when typed out it looks like row-major<br>The matrices are being post multiplied.1760   * @module mat41761   */1762  /**1763   * Creates a new identity mat41764   *1765   * @returns {mat4} a new 4x4 matrix1766   */1767  function create$3() {1768    var out = new ARRAY_TYPE(16);1769    if (ARRAY_TYPE != Float32Array) {1770      out[1] = 0;1771      out[2] = 0;1772      out[3] = 0;1773      out[4] = 0;1774      out[6] = 0;1775      out[7] = 0;1776      out[8] = 0;1777      out[9] = 0;1778      out[11] = 0;1779      out[12] = 0;1780      out[13] = 0;1781      out[14] = 0;1782    }1783    out[0] = 1;1784    out[5] = 1;1785    out[10] = 1;1786    out[15] = 1;1787    return out;1788  }1789  /**1790   * Creates a new mat4 initialized with values from an existing matrix1791   *1792   * @param {mat4} a matrix to clone1793   * @returns {mat4} a new 4x4 matrix1794   */1795  function clone$3(a) {1796    var out = new ARRAY_TYPE(16);1797    out[0] = a[0];1798    out[1] = a[1];1799    out[2] = a[2];1800    out[3] = a[3];1801    out[4] = a[4];1802    out[5] = a[5];1803    out[6] = a[6];1804    out[7] = a[7];1805    out[8] = a[8];1806    out[9] = a[9];1807    out[10] = a[10];1808    out[11] = a[11];1809    out[12] = a[12];1810    out[13] = a[13];1811    out[14] = a[14];1812    out[15] = a[15];1813    return out;1814  }1815  /**1816   * Copy the values from one mat4 to another1817   *1818   * @param {mat4} out the receiving matrix1819   * @param {mat4} a the source matrix1820   * @returns {mat4} out1821   */1822  function copy$3(out, a) {1823    out[0] = a[0];1824    out[1] = a[1];1825    out[2] = a[2];1826    out[3] = a[3];1827    out[4] = a[4];1828    out[5] = a[5];1829    out[6] = a[6];1830    out[7] = a[7];1831    out[8] = a[8];1832    out[9] = a[9];1833    out[10] = a[10];1834    out[11] = a[11];1835    out[12] = a[12];1836    out[13] = a[13];1837    out[14] = a[14];1838    out[15] = a[15];1839    return out;1840  }1841  /**1842   * Create a new mat4 with the given values1843   *1844   * @param {Number} m00 Component in column 0, row 0 position (index 0)1845   * @param {Number} m01 Component in column 0, row 1 position (index 1)1846   * @param {Number} m02 Component in column 0, row 2 position (index 2)1847   * @param {Number} m03 Component in column 0, row 3 position (index 3)1848   * @param {Number} m10 Component in column 1, row 0 position (index 4)1849   * @param {Number} m11 Component in column 1, row 1 position (index 5)1850   * @param {Number} m12 Component in column 1, row 2 position (index 6)1851   * @param {Number} m13 Component in column 1, row 3 position (index 7)1852   * @param {Number} m20 Component in column 2, row 0 position (index 8)1853   * @param {Number} m21 Component in column 2, row 1 position (index 9)1854   * @param {Number} m22 Component in column 2, row 2 position (index 10)1855   * @param {Number} m23 Component in column 2, row 3 position (index 11)1856   * @param {Number} m30 Component in column 3, row 0 position (index 12)1857   * @param {Number} m31 Component in column 3, row 1 position (index 13)1858   * @param {Number} m32 Component in column 3, row 2 position (index 14)1859   * @param {Number} m33 Component in column 3, row 3 position (index 15)1860   * @returns {mat4} A new mat41861   */1862  function fromValues$3(m00, m01, m02, m03, m10, m11, m12, m13, m20, m21, m22, m23, m30, m31, m32, m33) {1863    var out = new ARRAY_TYPE(16);1864    out[0] = m00;1865    out[1] = m01;1866    out[2] = m02;1867    out[3] = m03;1868    out[4] = m10;1869    out[5] = m11;1870    out[6] = m12;1871    out[7] = m13;1872    out[8] = m20;1873    out[9] = m21;1874    out[10] = m22;1875    out[11] = m23;1876    out[12] = m30;1877    out[13] = m31;1878    out[14] = m32;1879    out[15] = m33;1880    return out;1881  }1882  /**1883   * Set the components of a mat4 to the given values1884   *1885   * @param {mat4} out the receiving matrix1886   * @param {Number} m00 Component in column 0, row 0 position (index 0)1887   * @param {Number} m01 Component in column 0, row 1 position (index 1)1888   * @param {Number} m02 Component in column 0, row 2 position (index 2)1889   * @param {Number} m03 Component in column 0, row 3 position (index 3)1890   * @param {Number} m10 Component in column 1, row 0 position (index 4)1891   * @param {Number} m11 Component in column 1, row 1 position (index 5)1892   * @param {Number} m12 Component in column 1, row 2 position (index 6)1893   * @param {Number} m13 Component in column 1, row 3 position (index 7)1894   * @param {Number} m20 Component in column 2, row 0 position (index 8)1895   * @param {Number} m21 Component in column 2, row 1 position (index 9)1896   * @param {Number} m22 Component in column 2, row 2 position (index 10)1897   * @param {Number} m23 Component in column 2, row 3 position (index 11)1898   * @param {Number} m30 Component in column 3, row 0 position (index 12)1899   * @param {Number} m31 Component in column 3, row 1 position (index 13)1900   * @param {Number} m32 Component in column 3, row 2 position (index 14)1901   * @param {Number} m33 Component in column 3, row 3 position (index 15)1902   * @returns {mat4} out1903   */1904  function set$3(out, m00, m01, m02, m03, m10, m11, m12, m13, m20, m21, m22, m23, m30, m31, m32, m33) {1905    out[0] = m00;1906    out[1] = m01;1907    out[2] = m02;1908    out[3] = m03;1909    out[4] = m10;1910    out[5] = m11;1911    out[6] = m12;1912    out[7] = m13;1913    out[8] = m20;1914    out[9] = m21;1915    out[10] = m22;1916    out[11] = m23;1917    out[12] = m30;1918    out[13] = m31;1919    out[14] = m32;1920    out[15] = m33;1921    return out;1922  }1923  /**1924   * Set a mat4 to the identity matrix1925   *1926   * @param {mat4} out the receiving matrix1927   * @returns {mat4} out1928   */1929  function identity$3(out) {1930    out[0] = 1;1931    out[1] = 0;1932    out[2] = 0;1933    out[3] = 0;1934    out[4] = 0;1935    out[5] = 1;1936    out[6] = 0;1937    out[7] = 0;1938    out[8] = 0;1939    out[9] = 0;1940    out[10] = 1;1941    out[11] = 0;1942    out[12] = 0;1943    out[13] = 0;1944    out[14] = 0;1945    out[15] = 1;1946    return out;1947  }1948  /**1949   * Transpose the values of a mat41950   *1951   * @param {mat4} out the receiving matrix1952   * @param {mat4} a the source matrix1953   * @returns {mat4} out1954   */1955  function transpose$2(out, a) {1956    // If we are transposing ourselves we can skip a few steps but have to cache some values1957    if (out === a) {1958      var a01 = a[1],1959          a02 = a[2],1960          a03 = a[3];1961      var a12 = a[6],1962          a13 = a[7];1963      var a23 = a[11];1964      out[1] = a[4];1965      out[2] = a[8];1966      out[3] = a[12];1967      out[4] = a01;1968      out[6] = a[9];1969      out[7] = a[13];1970      out[8] = a02;1971      out[9] = a12;1972      out[11] = a[14];1973      out[12] = a03;1974      out[13] = a13;1975      out[14] = a23;1976    } else {1977      out[0] = a[0];1978      out[1] = a[4];1979      out[2] = a[8];1980      out[3] = a[12];1981      out[4] = a[1];1982      out[5] = a[5];1983      out[6] = a[9];1984      out[7] = a[13];1985      out[8] = a[2];1986      out[9] = a[6];1987      out[10] = a[10];1988      out[11] = a[14];1989      out[12] = a[3];1990      out[13] = a[7];1991      out[14] = a[11];1992      out[15] = a[15];1993    }1994    return out;1995  }1996  /**1997   * Inverts a mat41998   *1999   * @param {mat4} out the receiving matrix2000   * @param {mat4} a the source matrix2001   * @returns {mat4} out2002   */2003  function invert$3(out, a) {2004    var a00 = a[0],2005        a01 = a[1],2006        a02 = a[2],2007        a03 = a[3];2008    var a10 = a[4],2009        a11 = a[5],2010        a12 = a[6],2011        a13 = a[7];2012    var a20 = a[8],2013        a21 = a[9],2014        a22 = a[10],2015        a23 = a[11];2016    var a30 = a[12],2017        a31 = a[13],2018        a32 = a[14],2019        a33 = a[15];2020    var b00 = a00 * a11 - a01 * a10;2021    var b01 = a00 * a12 - a02 * a10;2022    var b02 = a00 * a13 - a03 * a10;2023    var b03 = a01 * a12 - a02 * a11;2024    var b04 = a01 * a13 - a03 * a11;2025    var b05 = a02 * a13 - a03 * a12;2026    var b06 = a20 * a31 - a21 * a30;2027    var b07 = a20 * a32 - a22 * a30;2028    var b08 = a20 * a33 - a23 * a30;2029    var b09 = a21 * a32 - a22 * a31;2030    var b10 = a21 * a33 - a23 * a31;2031    var b11 = a22 * a33 - a23 * a32; // Calculate the determinant2032    var det = b00 * b11 - b01 * b10 + b02 * b09 + b03 * b08 - b04 * b07 + b05 * b06;2033    if (!det) {2034      return null;2035    }2036    det = 1.0 / det;2037    out[0] = (a11 * b11 - a12 * b10 + a13 * b09) * det;2038    out[1] = (a02 * b10 - a01 * b11 - a03 * b09) * det;2039    out[2] = (a31 * b05 - a32 * b04 + a33 * b03) * det;2040    out[3] = (a22 * b04 - a21 * b05 - a23 * b03) * det;2041    out[4] = (a12 * b08 - a10 * b11 - a13 * b07) * det;2042    out[5] = (a00 * b11 - a02 * b08 + a03 * b07) * det;2043    out[6] = (a32 * b02 - a30 * b05 - a33 * b01) * det;2044    out[7] = (a20 * b05 - a22 * b02 + a23 * b01) * det;2045    out[8] = (a10 * b10 - a11 * b08 + a13 * b06) * det;2046    out[9] = (a01 * b08 - a00 * b10 - a03 * b06) * det;2047    out[10] = (a30 * b04 - a31 * b02 + a33 * b00) * det;2048    out[11] = (a21 * b02 - a20 * b04 - a23 * b00) * det;2049    out[12] = (a11 * b07 - a10 * b09 - a12 * b06) * det;2050    out[13] = (a00 * b09 - a01 * b07 + a02 * b06) * det;2051    out[14] = (a31 * b01 - a30 * b03 - a32 * b00) * det;2052    out[15] = (a20 * b03 - a21 * b01 + a22 * b00) * det;2053    return out;2054  }2055  /**2056   * Calculates the adjugate of a mat42057   *2058   * @param {mat4} out the receiving matrix2059   * @param {mat4} a the source matrix2060   * @returns {mat4} out2061   */2062  function adjoint$2(out, a) {2063    var a00 = a[0],2064        a01 = a[1],2065        a02 = a[2],2066        a03 = a[3];2067    var a10 = a[4],2068        a11 = a[5],2069        a12 = a[6],2070        a13 = a[7];2071    var a20 = a[8],2072        a21 = a[9],2073        a22 = a[10],2074        a23 = a[11];2075    var a30 = a[12],2076        a31 = a[13],2077        a32 = a[14],2078        a33 = a[15];2079    out[0] = a11 * (a22 * a33 - a23 * a32) - a21 * (a12 * a33 - a13 * a32) + a31 * (a12 * a23 - a13 * a22);2080    out[1] = -(a01 * (a22 * a33 - a23 * a32) - a21 * (a02 * a33 - a03 * a32) + a31 * (a02 * a23 - a03 * a22));2081    out[2] = a01 * (a12 * a33 - a13 * a32) - a11 * (a02 * a33 - a03 * a32) + a31 * (a02 * a13 - a03 * a12);2082    out[3] = -(a01 * (a12 * a23 - a13 * a22) - a11 * (a02 * a23 - a03 * a22) + a21 * (a02 * a13 - a03 * a12));2083    out[4] = -(a10 * (a22 * a33 - a23 * a32) - a20 * (a12 * a33 - a13 * a32) + a30 * (a12 * a23 - a13 * a22));2084    out[5] = a00 * (a22 * a33 - a23 * a32) - a20 * (a02 * a33 - a03 * a32) + a30 * (a02 * a23 - a03 * a22);2085    out[6] = -(a00 * (a12 * a33 - a13 * a32) - a10 * (a02 * a33 - a03 * a32) + a30 * (a02 * a13 - a03 * a12));2086    out[7] = a00 * (a12 * a23 - a13 * a22) - a10 * (a02 * a23 - a03 * a22) + a20 * (a02 * a13 - a03 * a12);2087    out[8] = a10 * (a21 * a33 - a23 * a31) - a20 * (a11 * a33 - a13 * a31) + a30 * (a11 * a23 - a13 * a21);2088    out[9] = -(a00 * (a21 * a33 - a23 * a31) - a20 * (a01 * a33 - a03 * a31) + a30 * (a01 * a23 - a03 * a21));2089    out[10] = a00 * (a11 * a33 - a13 * a31) - a10 * (a01 * a33 - a03 * a31) + a30 * (a01 * a13 - a03 * a11);2090    out[11] = -(a00 * (a11 * a23 - a13 * a21) - a10 * (a01 * a23 - a03 * a21) + a20 * (a01 * a13 - a03 * a11));2091    out[12] = -(a10 * (a21 * a32 - a22 * a31) - a20 * (a11 * a32 - a12 * a31) + a30 * (a11 * a22 - a12 * a21));2092    out[13] = a00 * (a21 * a32 - a22 * a31) - a20 * (a01 * a32 - a02 * a31) + a30 * (a01 * a22 - a02 * a21);2093    out[14] = -(a00 * (a11 * a32 - a12 * a31) - a10 * (a01 * a32 - a02 * a31) + a30 * (a01 * a12 - a02 * a11));2094    out[15] = a00 * (a11 * a22 - a12 * a21) - a10 * (a01 * a22 - a02 * a21) + a20 * (a01 * a12 - a02 * a11);2095    return out;2096  }2097  /**2098   * Calculates the determinant of a mat42099   *2100   * @param {mat4} a the source matrix2101   * @returns {Number} determinant of a2102   */2103  function determinant$3(a) {2104    var a00 = a[0],2105        a01 = a[1],2106        a02 = a[2],2107        a03 = a[3];2108    var a10 = a[4],2109        a11 = a[5],2110        a12 = a[6],2111        a13 = a[7];2112    var a20 = a[8],2113        a21 = a[9],2114        a22 = a[10],2115        a23 = a[11];2116    var a30 = a[12],2117        a31 = a[13],2118        a32 = a[14],2119        a33 = a[15];2120    var b00 = a00 * a11 - a01 * a10;2121    var b01 = a00 * a12 - a02 * a10;2122    var b02 = a00 * a13 - a03 * a10;2123    var b03 = a01 * a12 - a02 * a11;2124    var b04 = a01 * a13 - a03 * a11;2125    var b05 = a02 * a13 - a03 * a12;2126    var b06 = a20 * a31 - a21 * a30;2127    var b07 = a20 * a32 - a22 * a30;2128    var b08 = a20 * a33 - a23 * a30;2129    var b09 = a21 * a32 - a22 * a31;2130    var b10 = a21 * a33 - a23 * a31;2131    var b11 = a22 * a33 - a23 * a32; // Calculate the determinant2132    return b00 * b11 - b01 * b10 + b02 * b09 + b03 * b08 - b04 * b07 + b05 * b06;2133  }2134  /**2135   * Multiplies two mat4s2136   *2137   * @param {mat4} out the receiving matrix2138   * @param {mat4} a the first operand2139   * @param {mat4} b the second operand2140   * @returns {mat4} out2141   */2142  function multiply$3(out, a, b) {2143    var a00 = a[0],2144        a01 = a[1],2145        a02 = a[2],2146        a03 = a[3];2147    var a10 = a[4],2148        a11 = a[5],2149        a12 = a[6],2150        a13 = a[7];2151    var a20 = a[8],2152        a21 = a[9],2153        a22 = a[10],2154        a23 = a[11];2155    var a30 = a[12],2156        a31 = a[13],2157        a32 = a[14],2158        a33 = a[15]; // Cache only the current line of the second matrix2159    var b0 = b[0],2160        b1 = b[1],2161        b2 = b[2],2162        b3 = b[3];2163    out[0] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30;2164    out[1] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31;2165    out[2] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32;2166    out[3] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33;2167    b0 = b[4];2168    b1 = b[5];2169    b2 = b[6];2170    b3 = b[7];2171    out[4] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30;2172    out[5] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31;2173    out[6] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32;2174    out[7] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33;2175    b0 = b[8];2176    b1 = b[9];2177    b2 = b[10];2178    b3 = b[11];2179    out[8] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30;2180    out[9] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31;2181    out[10] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32;2182    out[11] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33;2183    b0 = b[12];2184    b1 = b[13];2185    b2 = b[14];2186    b3 = b[15];2187    out[12] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30;2188    out[13] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31;2189    out[14] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32;2190    out[15] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33;2191    return out;2192  }2193  /**2194   * Translate a mat4 by the given vector2195   *2196   * @param {mat4} out the receiving matrix2197   * @param {mat4} a the matrix to translate2198   * @param {vec3} v vector to translate by2199   * @returns {mat4} out2200   */2201  function translate$2(out, a, v) {2202    var x = v[0],2203        y = v[1],2204        z = v[2];2205    var a00, a01, a02, a03;2206    var a10, a11, a12, a13;2207    var a20, a21, a22, a23;2208    if (a === out) {2209      out[12] = a[0] * x + a[4] * y + a[8] * z + a[12];2210      out[13] = a[1] * x + a[5] * y + a[9] * z + a[13];2211      out[14] = a[2] * x + a[6] * y + a[10] * z + a[14];2212      out[15] = a[3] * x + a[7] * y + a[11] * z + a[15];2213    } else {2214      a00 = a[0];2215      a01 = a[1];2216      a02 = a[2];2217      a03 = a[3];2218      a10 = a[4];2219      a11 = a[5];2220      a12 = a[6];2221      a13 = a[7];2222      a20 = a[8];2223      a21 = a[9];2224      a22 = a[10];2225      a23 = a[11];2226      out[0] = a00;2227      out[1] = a01;2228      out[2] = a02;2229      out[3] = a03;2230      out[4] = a10;2231      out[5] = a11;2232      out[6] = a12;2233      out[7] = a13;2234      out[8] = a20;2235      out[9] = a21;2236      out[10] = a22;2237      out[11] = a23;2238      out[12] = a00 * x + a10 * y + a20 * z + a[12];2239      out[13] = a01 * x + a11 * y + a21 * z + a[13];2240      out[14] = a02 * x + a12 * y + a22 * z + a[14];2241      out[15] = a03 * x + a13 * y + a23 * z + a[15];2242    }2243    return out;2244  }2245  /**2246   * Scales the mat4 by the dimensions in the given vec3 not using vectorization2247   *2248   * @param {mat4} out the receiving matrix2249   * @param {mat4} a the matrix to scale2250   * @param {vec3} v the vec3 to scale the matrix by2251   * @returns {mat4} out2252   **/2253  function scale$3(out, a, v) {2254    var x = v[0],2255        y = v[1],2256        z = v[2];2257    out[0] = a[0] * x;2258    out[1] = a[1] * x;2259    out[2] = a[2] * x;2260    out[3] = a[3] * x;2261    out[4] = a[4] * y;2262    out[5] = a[5] * y;2263    out[6] = a[6] * y;2264    out[7] = a[7] * y;2265    out[8] = a[8] * z;2266    out[9] = a[9] * z;2267    out[10] = a[10] * z;2268    out[11] = a[11] * z;2269    out[12] = a[12];2270    out[13] = a[13];2271    out[14] = a[14];2272    out[15] = a[15];2273    return out;2274  }2275  /**2276   * Rotates a mat4 by the given angle around the given axis2277   *2278   * @param {mat4} out the receiving matrix2279   * @param {mat4} a the matrix to rotate2280   * @param {Number} rad the angle to rotate the matrix by2281   * @param {vec3} axis the axis to rotate around2282   * @returns {mat4} out2283   */2284  function rotate$3(out, a, rad, axis) {2285    var x = axis[0],2286        y = axis[1],2287        z = axis[2];2288    var len = Math.hypot(x, y, z);2289    var s, c, t;2290    var a00, a01, a02, a03;2291    var a10, a11, a12, a13;2292    var a20, a21, a22, a23;2293    var b00, b01, b02;2294    var b10, b11, b12;2295    var b20, b21, b22;2296    if (len < EPSILON) {2297      return null;2298    }2299    len = 1 / len;2300    x *= len;2301    y *= len;2302    z *= len;2303    s = Math.sin(rad);2304    c = Math.cos(rad);2305    t = 1 - c;2306    a00 = a[0];2307    a01 = a[1];2308    a02 = a[2];2309    a03 = a[3];2310    a10 = a[4];2311    a11 = a[5];2312    a12 = a[6];2313    a13 = a[7];2314    a20 = a[8];2315    a21 = a[9];2316    a22 = a[10];2317    a23 = a[11]; // Construct the elements of the rotation matrix2318    b00 = x * x * t + c;2319    b01 = y * x * t + z * s;2320    b02 = z * x * t - y * s;2321    b10 = x * y * t - z * s;2322    b11 = y * y * t + c;2323    b12 = z * y * t + x * s;2324    b20 = x * z * t + y * s;2325    b21 = y * z * t - x * s;2326    b22 = z * z * t + c; // Perform rotation-specific matrix multiplication2327    out[0] = a00 * b00 + a10 * b01 + a20 * b02;2328    out[1] = a01 * b00 + a11 * b01 + a21 * b02;2329    out[2] = a02 * b00 + a12 * b01 + a22 * b02;2330    out[3] = a03 * b00 + a13 * b01 + a23 * b02;2331    out[4] = a00 * b10 + a10 * b11 + a20 * b12;2332    out[5] = a01 * b10 + a11 * b11 + a21 * b12;2333    out[6] = a02 * b10 + a12 * b11 + a22 * b12;2334    out[7] = a03 * b10 + a13 * b11 + a23 * b12;2335    out[8] = a00 * b20 + a10 * b21 + a20 * b22;2336    out[9] = a01 * b20 + a11 * b21 + a21 * b22;2337    out[10] = a02 * b20 + a12 * b21 + a22 * b22;2338    out[11] = a03 * b20 + a13 * b21 + a23 * b22;2339    if (a !== out) {2340      // If the source and destination differ, copy the unchanged last row2341      out[12] = a[12];2342      out[13] = a[13];2343      out[14] = a[14];2344      out[15] = a[15];2345    }2346    return out;2347  }2348  /**2349   * Rotates a matrix by the given angle around the X axis2350   *2351   * @param {mat4} out the receiving matrix2352   * @param {mat4} a the matrix to rotate2353   * @param {Number} rad the angle to rotate the matrix by2354   * @returns {mat4} out2355   */2356  function rotateX(out, a, rad) {2357    var s = Math.sin(rad);2358    var c = Math.cos(rad);2359    var a10 = a[4];2360    var a11 = a[5];2361    var a12 = a[6];2362    var a13 = a[7];2363    var a20 = a[8];2364    var a21 = a[9];2365    var a22 = a[10];2366    var a23 = a[11];2367    if (a !== out) {2368      // If the source and destination differ, copy the unchanged rows2369      out[0] = a[0];2370      out[1] = a[1];2371      out[2] = a[2];2372      out[3] = a[3];2373      out[12] = a[12];2374      out[13] = a[13];2375      out[14] = a[14];2376      out[15] = a[15];2377    } // Perform axis-specific matrix multiplication2378    out[4] = a10 * c + a20 * s;2379    out[5] = a11 * c + a21 * s;2380    out[6] = a12 * c + a22 * s;2381    out[7] = a13 * c + a23 * s;2382    out[8] = a20 * c - a10 * s;2383    out[9] = a21 * c - a11 * s;2384    out[10] = a22 * c - a12 * s;2385    out[11] = a23 * c - a13 * s;2386    return out;2387  }2388  /**2389   * Rotates a matrix by the given angle around the Y axis2390   *2391   * @param {mat4} out the receiving matrix2392   * @param {mat4} a the matrix to rotate2393   * @param {Number} rad the angle to rotate the matrix by2394   * @returns {mat4} out2395   */2396  function rotateY(out, a, rad) {2397    var s = Math.sin(rad);2398    var c = Math.cos(rad);2399    var a00 = a[0];2400    var a01 = a[1];2401    var a02 = a[2];2402    var a03 = a[3];2403    var a20 = a[8];2404    var a21 = a[9];2405    var a22 = a[10];2406    var a23 = a[11];2407    if (a !== out) {2408      // If the source and destination differ, copy the unchanged rows2409      out[4] = a[4];2410      out[5] = a[5];2411      out[6] = a[6];2412      out[7] = a[7];2413      out[12] = a[12];2414      out[13] = a[13];2415      out[14] = a[14];2416      out[15] = a[15];2417    } // Perform axis-specific matrix multiplication2418    out[0] = a00 * c - a20 * s;2419    out[1] = a01 * c - a21 * s;2420    out[2] = a02 * c - a22 * s;2421    out[3] = a03 * c - a23 * s;2422    out[8] = a00 * s + a20 * c;2423    out[9] = a01 * s + a21 * c;2424    out[10] = a02 * s + a22 * c;2425    out[11] = a03 * s + a23 * c;2426    return out;2427  }2428  /**2429   * Rotates a matrix by the given angle around the Z axis2430   *2431   * @param {mat4} out the receiving matrix2432   * @param {mat4} a the matrix to rotate2433   * @param {Number} rad the angle to rotate the matrix by2434   * @returns {mat4} out2435   */2436  function rotateZ(out, a, rad) {2437    var s = Math.sin(rad);2438    var c = Math.cos(rad);2439    var a00 = a[0];2440    var a01 = a[1];2441    var a02 = a[2];2442    var a03 = a[3];2443    var a10 = a[4];2444    var a11 = a[5];2445    var a12 = a[6];2446    var a13 = a[7];2447    if (a !== out) {2448      // If the source and destination differ, copy the unchanged last row2449      out[8] = a[8];2450      out[9] = a[9];2451      out[10] = a[10];2452      out[11] = a[11];2453      out[12] = a[12];2454      out[13] = a[13];2455      out[14] = a[14];2456      out[15] = a[15];2457    } // Perform axis-specific matrix multiplication2458    out[0] = a00 * c + a10 * s;2459    out[1] = a01 * c + a11 * s;2460    out[2] = a02 * c + a12 * s;2461    out[3] = a03 * c + a13 * s;2462    out[4] = a10 * c - a00 * s;2463    out[5] = a11 * c - a01 * s;2464    out[6] = a12 * c - a02 * s;2465    out[7] = a13 * c - a03 * s;2466    return out;2467  }2468  /**2469   * Creates a matrix from a vector translation2470   * This is equivalent to (but much faster than):2471   *2472   *     mat4.identity(dest);2473   *     mat4.translate(dest, dest, vec);2474   *2475   * @param {mat4} out mat4 receiving operation result2476   * @param {vec3} v Translation vector2477   * @returns {mat4} out2478   */2479  function fromTranslation$2(out, v) {2480    out[0] = 1;2481    out[1] = 0;2482    out[2] = 0;2483    out[3] = 0;2484    out[4] = 0;2485    out[5] = 1;2486    out[6] = 0;2487    out[7] = 0;2488    out[8] = 0;2489    out[9] = 0;2490    out[10] = 1;2491    out[11] = 0;2492    out[12] = v[0];2493    out[13] = v[1];2494    out[14] = v[2];2495    out[15] = 1;2496    return out;2497  }2498  /**2499   * Creates a matrix from a vector scaling2500   * This is equivalent to (but much faster than):2501   *2502   *     mat4.identity(dest);2503   *     mat4.scale(dest, dest, vec);2504   *2505   * @param {mat4} out mat4 receiving operation result2506   * @param {vec3} v Scaling vector2507   * @returns {mat4} out2508   */2509  function fromScaling$3(out, v) {2510    out[0] = v[0];2511    out[1] = 0;2512    out[2] = 0;2513    out[3] = 0;2514    out[4] = 0;2515    out[5] = v[1];2516    out[6] = 0;2517    out[7] = 0;2518    out[8] = 0;2519    out[9] = 0;2520    out[10] = v[2];2521    out[11] = 0;2522    out[12] = 0;2523    out[13] = 0;2524    out[14] = 0;2525    out[15] = 1;2526    return out;2527  }2528  /**2529   * Creates a matrix from a given angle around a given axis2530   * This is equivalent to (but much faster than):2531   *2532   *     mat4.identity(dest);2533   *     mat4.rotate(dest, dest, rad, axis);2534   *2535   * @param {mat4} out mat4 receiving operation result2536   * @param {Number} rad the angle to rotate the matrix by2537   * @param {vec3} axis the axis to rotate around2538   * @returns {mat4} out2539   */2540  function fromRotation$3(out, rad, axis) {2541    var x = axis[0],2542        y = axis[1],2543        z = axis[2];2544    var len = Math.hypot(x, y, z);2545    var s, c, t;2546    if (len < EPSILON) {2547      return null;2548    }2549    len = 1 / len;2550    x *= len;2551    y *= len;2552    z *= len;2553    s = Math.sin(rad);2554    c = Math.cos(rad);2555    t = 1 - c; // Perform rotation-specific matrix multiplication2556    out[0] = x * x * t + c;2557    out[1] = y * x * t + z * s;2558    out[2] = z * x * t - y * s;2559    out[3] = 0;2560    out[4] = x * y * t - z * s;2561    out[5] = y * y * t + c;2562    out[6] = z * y * t + x * s;2563    out[7] = 0;2564    out[8] = x * z * t + y * s;2565    out[9] = y * z * t - x * s;2566    out[10] = z * z * t + c;2567    out[11] = 0;2568    out[12] = 0;2569    out[13] = 0;2570    out[14] = 0;2571    out[15] = 1;2572    return out;2573  }2574  /**2575   * Creates a matrix from the given angle around the X axis2576   * This is equivalent to (but much faster than):2577   *2578   *     mat4.identity(dest);2579   *     mat4.rotateX(dest, dest, rad);2580   *2581   * @param {mat4} out mat4 receiving operation result2582   * @param {Number} rad the angle to rotate the matrix by2583   * @returns {mat4} out2584   */2585  function fromXRotation(out, rad) {2586    var s = Math.sin(rad);2587    var c = Math.cos(rad); // Perform axis-specific matrix multiplication2588    out[0] = 1;2589    out[1] = 0;2590    out[2] = 0;2591    out[3] = 0;2592    out[4] = 0;2593    out[5] = c;2594    out[6] = s;2595    out[7] = 0;2596    out[8] = 0;2597    out[9] = -s;2598    out[10] = c;2599    out[11] = 0;2600    out[12] = 0;2601    out[13] = 0;2602    out[14] = 0;2603    out[15] = 1;2604    return out;2605  }2606  /**2607   * Creates a matrix from the given angle around the Y axis2608   * This is equivalent to (but much faster than):2609   *2610   *     mat4.identity(dest);2611   *     mat4.rotateY(dest, dest, rad);2612   *2613   * @param {mat4} out mat4 receiving operation result2614   * @param {Number} rad the angle to rotate the matrix by2615   * @returns {mat4} out2616   */2617  function fromYRotation(out, rad) {2618    var s = Math.sin(rad);2619    var c = Math.cos(rad); // Perform axis-specific matrix multiplication2620    out[0] = c;2621    out[1] = 0;2622    out[2] = -s;2623    out[3] = 0;2624    out[4] = 0;2625    out[5] = 1;2626    out[6] = 0;2627    out[7] = 0;2628    out[8] = s;2629    out[9] = 0;2630    out[10] = c;2631    out[11] = 0;2632    out[12] = 0;2633    out[13] = 0;2634    out[14] = 0;2635    out[15] = 1;2636    return out;2637  }2638  /**2639   * Creates a matrix from the given angle around the Z axis2640   * This is equivalent to (but much faster than):2641   *2642   *     mat4.identity(dest);2643   *     mat4.rotateZ(dest, dest, rad);2644   *2645   * @param {mat4} out mat4 receiving operation result2646   * @param {Number} rad the angle to rotate the matrix by2647   * @returns {mat4} out2648   */2649  function fromZRotation(out, rad) {2650    var s = Math.sin(rad);2651    var c = Math.cos(rad); // Perform axis-specific matrix multiplication2652    out[0] = c;2653    out[1] = s;2654    out[2] = 0;2655    out[3] = 0;2656    out[4] = -s;2657    out[5] = c;2658    out[6] = 0;2659    out[7] = 0;2660    out[8] = 0;2661    out[9] = 0;2662    out[10] = 1;2663    out[11] = 0;2664    out[12] = 0;2665    out[13] = 0;2666    out[14] = 0;2667    out[15] = 1;2668    return out;2669  }2670  /**2671   * Creates a matrix from a quaternion rotation and vector translation2672   * This is equivalent to (but much faster than):2673   *2674   *     mat4.identity(dest);2675   *     mat4.translate(dest, vec);2676   *     let quatMat = mat4.create();2677   *     quat4.toMat4(quat, quatMat);2678   *     mat4.multiply(dest, quatMat);2679   *2680   * @param {mat4} out mat4 receiving operation result2681   * @param {quat4} q Rotation quaternion2682   * @param {vec3} v Translation vector2683   * @returns {mat4} out2684   */2685  function fromRotationTranslation(out, q, v) {2686    // Quaternion math2687    var x = q[0],2688        y = q[1],2689        z = q[2],2690        w = q[3];2691    var x2 = x + x;2692    var y2 = y + y;2693    var z2 = z + z;2694    var xx = x * x2;2695    var xy = x * y2;2696    var xz = x * z2;2697    var yy = y * y2;2698    var yz = y * z2;2699    var zz = z * z2;2700    var wx = w * x2;2701    var wy = w * y2;2702    var wz = w * z2;2703    out[0] = 1 - (yy + zz);2704    out[1] = xy + wz;2705    out[2] = xz - wy;2706    out[3] = 0;2707    out[4] = xy - wz;2708    out[5] = 1 - (xx + zz);2709    out[6] = yz + wx;2710    out[7] = 0;2711    out[8] = xz + wy;2712    out[9] = yz - wx;2713    out[10] = 1 - (xx + yy);2714    out[11] = 0;2715    out[12] = v[0];2716    out[13] = v[1];2717    out[14] = v[2];2718    out[15] = 1;2719    return out;2720  }2721  /**2722   * Creates a new mat4 from a dual quat.2723   *2724   * @param {mat4} out Matrix2725   * @param {quat2} a Dual Quaternion2726   * @returns {mat4} mat4 receiving operation result2727   */2728  function fromQuat2(out, a) {2729    var translation = new ARRAY_TYPE(3);2730    var bx = -a[0],2731        by = -a[1],2732        bz = -a[2],2733        bw = a[3],2734        ax = a[4],2735        ay = a[5],2736        az = a[6],2737        aw = a[7];2738    var magnitude = bx * bx + by * by + bz * bz + bw * bw; //Only scale if it makes sense2739    if (magnitude > 0) {2740      translation[0] = (ax * bw + aw * bx + ay * bz - az * by) * 2 / magnitude;2741      translation[1] = (ay * bw + aw * by + az * bx - ax * bz) * 2 / magnitude;2742      translation[2] = (az * bw + aw * bz + ax * by - ay * bx) * 2 / magnitude;2743    } else {2744      translation[0] = (ax * bw + aw * bx + ay * bz - az * by) * 2;2745      translation[1] = (ay * bw + aw * by + az * bx - ax * bz) * 2;2746      translation[2] = (az * bw + aw * bz + ax * by - ay * bx) * 2;2747    }2748    fromRotationTranslation(out, a, translation);2749    return out;2750  }2751  /**2752   * Returns the translation vector component of a transformation2753   *  matrix. If a matrix is built with fromRotationTranslation,2754   *  the returned vector will be the same as the translation vector2755   *  originally supplied.2756   * @param  {vec3} out Vector to receive translation component2757   * @param  {mat4} mat Matrix to be decomposed (input)2758   * @return {vec3} out2759   */2760  function getTranslation(out, mat) {2761    out[0] = mat[12];2762    out[1] = mat[13];2763    out[2] = mat[14];2764    return out;2765  }2766  /**2767   * Returns the scaling factor component of a transformation2768   *  matrix. If a matrix is built with fromRotationTranslationScale2769   *  with a normalized Quaternion paramter, the returned vector will be2770   *  the same as the scaling vector2771   *  originally supplied.2772   * @param  {vec3} out Vector to receive scaling factor component2773   * @param  {mat4} mat Matrix to be decomposed (input)2774   * @return {vec3} out2775   */2776  function getScaling(out, mat) {2777    var m11 = mat[0];2778    var m12 = mat[1];2779    var m13 = mat[2];2780    var m21 = mat[4];2781    var m22 = mat[5];2782    var m23 = mat[6];2783    var m31 = mat[8];2784    var m32 = mat[9];2785    var m33 = mat[10];2786    out[0] = Math.hypot(m11, m12, m13);2787    out[1] = Math.hypot(m21, m22, m23);2788    out[2] = Math.hypot(m31, m32, m33);2789    return out;2790  }2791  /**2792   * Returns a quaternion representing the rotational component2793   *  of a transformation matrix. If a matrix is built with2794   *  fromRotationTranslation, the returned quaternion will be the2795   *  same as the quaternion originally supplied.2796   * @param {quat} out Quaternion to receive the rotation component2797   * @param {mat4} mat Matrix to be decomposed (input)2798   * @return {quat} out2799   */2800  function getRotation(out, mat) {2801    var scaling = new ARRAY_TYPE(3);2802    getScaling(scaling, mat);2803    var is1 = 1 / scaling[0];2804    var is2 = 1 / scaling[1];2805    var is3 = 1 / scaling[2];2806    var sm11 = mat[0] * is1;2807    var sm12 = mat[1] * is2;2808    var sm13 = mat[2] * is3;2809    var sm21 = mat[4] * is1;2810    var sm22 = mat[5] * is2;2811    var sm23 = mat[6] * is3;2812    var sm31 = mat[8] * is1;2813    var sm32 = mat[9] * is2;2814    var sm33 = mat[10] * is3;2815    var trace = sm11 + sm22 + sm33;2816    var S = 0;2817    if (trace > 0) {2818      S = Math.sqrt(trace + 1.0) * 2;2819      out[3] = 0.25 * S;2820      out[0] = (sm23 - sm32) / S;2821      out[1] = (sm31 - sm13) / S;2822      out[2] = (sm12 - sm21) / S;2823    } else if (sm11 > sm22 && sm11 > sm33) {2824      S = Math.sqrt(1.0 + sm11 - sm22 - sm33) * 2;2825      out[3] = (sm23 - sm32) / S;2826      out[0] = 0.25 * S;2827      out[1] = (sm12 + sm21) / S;2828      out[2] = (sm31 + sm13) / S;2829    } else if (sm22 > sm33) {2830      S = Math.sqrt(1.0 + sm22 - sm11 - sm33) * 2;2831      out[3] = (sm31 - sm13) / S;2832      out[0] = (sm12 + sm21) / S;2833      out[1] = 0.25 * S;2834      out[2] = (sm23 + sm32) / S;2835    } else {2836      S = Math.sqrt(1.0 + sm33 - sm11 - sm22) * 2;2837      out[3] = (sm12 - sm21) / S;2838      out[0] = (sm31 + sm13) / S;2839      out[1] = (sm23 + sm32) / S;2840      out[2] = 0.25 * S;2841    }2842    return out;2843  }2844  /**2845   * Creates a matrix from a quaternion rotation, vector translation and vector scale2846   * This is equivalent to (but much faster than):2847   *2848   *     mat4.identity(dest);2849   *     mat4.translate(dest, vec);2850   *     let quatMat = mat4.create();2851   *     quat4.toMat4(quat, quatMat);2852   *     mat4.multiply(dest, quatMat);2853   *     mat4.scale(dest, scale)2854   *2855   * @param {mat4} out mat4 receiving operation result2856   * @param {quat4} q Rotation quaternion2857   * @param {vec3} v Translation vector2858   * @param {vec3} s Scaling vector2859   * @returns {mat4} out2860   */2861  function fromRotationTranslationScale(out, q, v, s) {2862    // Quaternion math2863    var x = q[0],2864        y = q[1],2865        z = q[2],2866        w = q[3];2867    var x2 = x + x;2868    var y2 = y + y;2869    var z2 = z + z;2870    var xx = x * x2;2871    var xy = x * y2;2872    var xz = x * z2;2873    var yy = y * y2;2874    var yz = y * z2;2875    var zz = z * z2;2876    var wx = w * x2;2877    var wy = w * y2;2878    var wz = w * z2;2879    var sx = s[0];2880    var sy = s[1];2881    var sz = s[2];2882    out[0] = (1 - (yy + zz)) * sx;2883    out[1] = (xy + wz) * sx;2884    out[2] = (xz - wy) * sx;2885    out[3] = 0;2886    out[4] = (xy - wz) * sy;2887    out[5] = (1 - (xx + zz)) * sy;2888    out[6] = (yz + wx) * sy;2889    out[7] = 0;2890    out[8] = (xz + wy) * sz;2891    out[9] = (yz - wx) * sz;2892    out[10] = (1 - (xx + yy)) * sz;2893    out[11] = 0;2894    out[12] = v[0];2895    out[13] = v[1];2896    out[14] = v[2];2897    out[15] = 1;2898    return out;2899  }2900  /**2901   * Creates a matrix from a quaternion rotation, vector translation and vector scale, rotating and scaling around the given origin2902   * This is equivalent to (but much faster than):2903   *2904   *     mat4.identity(dest);2905   *     mat4.translate(dest, vec);2906   *     mat4.translate(dest, origin);2907   *     let quatMat = mat4.create();2908   *     quat4.toMat4(quat, quatMat);2909   *     mat4.multiply(dest, quatMat);2910   *     mat4.scale(dest, scale)2911   *     mat4.translate(dest, negativeOrigin);2912   *2913   * @param {mat4} out mat4 receiving operation result2914   * @param {quat4} q Rotation quaternion2915   * @param {vec3} v Translation vector2916   * @param {vec3} s Scaling vector2917   * @param {vec3} o The origin vector around which to scale and rotate2918   * @returns {mat4} out2919   */2920  function fromRotationTranslationScaleOrigin(out, q, v, s, o) {2921    // Quaternion math2922    var x = q[0],2923        y = q[1],2924        z = q[2],2925        w = q[3];2926    var x2 = x + x;2927    var y2 = y + y;2928    var z2 = z + z;2929    var xx = x * x2;2930    var xy = x * y2;2931    var xz = x * z2;2932    var yy = y * y2;2933    var yz = y * z2;2934    var zz = z * z2;2935    var wx = w * x2;2936    var wy = w * y2;2937    var wz = w * z2;2938    var sx = s[0];2939    var sy = s[1];2940    var sz = s[2];2941    var ox = o[0];2942    var oy = o[1];2943    var oz = o[2];2944    var out0 = (1 - (yy + zz)) * sx;2945    var out1 = (xy + wz) * sx;2946    var out2 = (xz - wy) * sx;2947    var out4 = (xy - wz) * sy;2948    var out5 = (1 - (xx + zz)) * sy;2949    var out6 = (yz + wx) * sy;2950    var out8 = (xz + wy) * sz;2951    var out9 = (yz - wx) * sz;2952    var out10 = (1 - (xx + yy)) * sz;2953    out[0] = out0;2954    out[1] = out1;2955    out[2] = out2;2956    out[3] = 0;2957    out[4] = out4;2958    out[5] = out5;2959    out[6] = out6;2960    out[7] = 0;2961    out[8] = out8;2962    out[9] = out9;2963    out[10] = out10;2964    out[11] = 0;2965    out[12] = v[0] + ox - (out0 * ox + out4 * oy + out8 * oz);2966    out[13] = v[1] + oy - (out1 * ox + out5 * oy + out9 * oz);2967    out[14] = v[2] + oz - (out2 * ox + out6 * oy + out10 * oz);2968    out[15] = 1;2969    return out;2970  }2971  /**2972   * Calculates a 4x4 matrix from the given quaternion2973   *2974   * @param {mat4} out mat4 receiving operation result2975   * @param {quat} q Quaternion to create matrix from2976   *2977   * @returns {mat4} out2978   */2979  function fromQuat$1(out, q) {2980    var x = q[0],2981        y = q[1],2982        z = q[2],2983        w = q[3];2984    var x2 = x + x;2985    var y2 = y + y;2986    var z2 = z + z;2987    var xx = x * x2;2988    var yx = y * x2;2989    var yy = y * y2;2990    var zx = z * x2;2991    var zy = z * y2;2992    var zz = z * z2;2993    var wx = w * x2;2994    var wy = w * y2;2995    var wz = w * z2;2996    out[0] = 1 - yy - zz;2997    out[1] = yx + wz;2998    out[2] = zx - wy;2999    out[3] = 0;3000    out[4] = yx - wz;3001    out[5] = 1 - xx - zz;3002    out[6] = zy + wx;3003    out[7] = 0;3004    out[8] = zx + wy;3005    out[9] = zy - wx;3006    out[10] = 1 - xx - yy;3007    out[11] = 0;3008    out[12] = 0;3009    out[13] = 0;3010    out[14] = 0;3011    out[15] = 1;3012    return out;3013  }3014  /**3015   * Generates a frustum matrix with the given bounds3016   *3017   * @param {mat4} out mat4 frustum matrix will be written into3018   * @param {Number} left Left bound of the frustum3019   * @param {Number} right Right bound of the frustum3020   * @param {Number} bottom Bottom bound of the frustum3021   * @param {Number} top Top bound of the frustum3022   * @param {Number} near Near bound of the frustum3023   * @param {Number} far Far bound of the frustum3024   * @returns {mat4} out3025   */3026  function frustum(out, left, right, bottom, top, near, far) {3027    var rl = 1 / (right - left);3028    var tb = 1 / (top - bottom);3029    var nf = 1 / (near - far);3030    out[0] = near * 2 * rl;3031    out[1] = 0;3032    out[2] = 0;3033    out[3] = 0;3034    out[4] = 0;3035    out[5] = near * 2 * tb;3036    out[6] = 0;3037    out[7] = 0;3038    out[8] = (right + left) * rl;3039    out[9] = (top + bottom) * tb;3040    out[10] = (far + near) * nf;3041    out[11] = -1;3042    out[12] = 0;3043    out[13] = 0;3044    out[14] = far * near * 2 * nf;3045    out[15] = 0;3046    return out;3047  }3048  /**3049   * Generates a perspective projection matrix with the given bounds.3050   * Passing null/undefined/no value for far will generate infinite projection matrix.3051   *3052   * @param {mat4} out mat4 frustum matrix will be written into3053   * @param {number} fovy Vertical field of view in radians3054   * @param {number} aspect Aspect ratio. typically viewport width/height3055   * @param {number} near Near bound of the frustum3056   * @param {number} far Far bound of the frustum, can be null or Infinity3057   * @returns {mat4} out3058   */3059  function perspective(out, fovy, aspect, near, far) {3060    var f = 1.0 / Math.tan(fovy / 2),3061        nf;3062    out[0] = f / aspect;3063    out[1] = 0;3064    out[2] = 0;3065    out[3] = 0;3066    out[4] = 0;3067    out[5] = f;3068    out[6] = 0;3069    out[7] = 0;3070    out[8] = 0;3071    out[9] = 0;3072    out[11] = -1;3073    out[12] = 0;3074    out[13] = 0;3075    out[15] = 0;3076    if (far != null && far !== Infinity) {3077      nf = 1 / (near - far);3078      out[10] = (far + near) * nf;3079      out[14] = 2 * far * near * nf;3080    } else {3081      out[10] = -1;3082      out[14] = -2 * near;3083    }3084    return out;3085  }3086  /**3087   * Generates a perspective projection matrix with the given field of view.3088   * This is primarily useful for generating projection matrices to be used3089   * with the still experiemental WebVR API.3090   *3091   * @param {mat4} out mat4 frustum matrix will be written into3092   * @param {Object} fov Object containing the following values: upDegrees, downDegrees, leftDegrees, rightDegrees3093   * @param {number} near Near bound of the frustum3094   * @param {number} far Far bound of the frustum3095   * @returns {mat4} out3096   */3097  function perspectiveFromFieldOfView(out, fov, near, far) {3098    var upTan = Math.tan(fov.upDegrees * Math.PI / 180.0);3099    var downTan = Math.tan(fov.downDegrees * Math.PI / 180.0);3100    var leftTan = Math.tan(fov.leftDegrees * Math.PI / 180.0);3101    var rightTan = Math.tan(fov.rightDegrees * Math.PI / 180.0);3102    var xScale = 2.0 / (leftTan + rightTan);3103    var yScale = 2.0 / (upTan + downTan);3104    out[0] = xScale;3105    out[1] = 0.0;3106    out[2] = 0.0;3107    out[3] = 0.0;3108    out[4] = 0.0;3109    out[5] = yScale;3110    out[6] = 0.0;3111    out[7] = 0.0;3112    out[8] = -((leftTan - rightTan) * xScale * 0.5);3113    out[9] = (upTan - downTan) * yScale * 0.5;3114    out[10] = far / (near - far);3115    out[11] = -1.0;3116    out[12] = 0.0;3117    out[13] = 0.0;3118    out[14] = far * near / (near - far);3119    out[15] = 0.0;3120    return out;3121  }3122  /**3123   * Generates a orthogonal projection matrix with the given bounds3124   *3125   * @param {mat4} out mat4 frustum matrix will be written into3126   * @param {number} left Left bound of the frustum3127   * @param {number} right Right bound of the frustum3128   * @param {number} bottom Bottom bound of the frustum3129   * @param {number} top Top bound of the frustum3130   * @param {number} near Near bound of the frustum3131   * @param {number} far Far bound of the frustum3132   * @returns {mat4} out3133   */3134  function ortho(out, left, right, bottom, top, near, far) {3135    var lr = 1 / (left - right);3136    var bt = 1 / (bottom - top);3137    var nf = 1 / (near - far);3138    out[0] = -2 * lr;3139    out[1] = 0;3140    out[2] = 0;3141    out[3] = 0;3142    out[4] = 0;3143    out[5] = -2 * bt;3144    out[6] = 0;3145    out[7] = 0;3146    out[8] = 0;3147    out[9] = 0;3148    out[10] = 2 * nf;3149    out[11] = 0;3150    out[12] = (left + right) * lr;3151    out[13] = (top + bottom) * bt;3152    out[14] = (far + near) * nf;3153    out[15] = 1;3154    return out;3155  }3156  /**3157   * Generates a look-at matrix with the given eye position, focal point, and up axis.3158   * If you want a matrix that actually makes an object look at another object, you should use targetTo instead.3159   *3160   * @param {mat4} out mat4 frustum matrix will be written into3161   * @param {vec3} eye Position of the viewer3162   * @param {vec3} center Point the viewer is looking at3163   * @param {vec3} up vec3 pointing up3164   * @returns {mat4} out3165   */3166  function lookAt(out, eye, center, up) {3167    var x0, x1, x2, y0, y1, y2, z0, z1, z2, len;3168    var eyex = eye[0];3169    var eyey = eye[1];3170    var eyez = eye[2];3171    var upx = up[0];3172    var upy = up[1];3173    var upz = up[2];3174    var centerx = center[0];3175    var centery = center[1];3176    var centerz = center[2];3177    if (Math.abs(eyex - centerx) < EPSILON && Math.abs(eyey - centery) < EPSILON && Math.abs(eyez - centerz) < EPSILON) {3178      return identity$3(out);3179    }3180    z0 = eyex - centerx;3181    z1 = eyey - centery;3182    z2 = eyez - centerz;3183    len = 1 / Math.hypot(z0, z1, z2);3184    z0 *= len;3185    z1 *= len;3186    z2 *= len;3187    x0 = upy * z2 - upz * z1;3188    x1 = upz * z0 - upx * z2;3189    x2 = upx * z1 - upy * z0;3190    len = Math.hypot(x0, x1, x2);3191    if (!len) {3192      x0 = 0;3193      x1 = 0;3194      x2 = 0;3195    } else {3196      len = 1 / len;3197      x0 *= len;3198      x1 *= len;3199      x2 *= len;3200    }3201    y0 = z1 * x2 - z2 * x1;3202    y1 = z2 * x0 - z0 * x2;3203    y2 = z0 * x1 - z1 * x0;3204    len = Math.hypot(y0, y1, y2);3205    if (!len) {3206      y0 = 0;3207      y1 = 0;3208      y2 = 0;3209    } else {3210      len = 1 / len;3211      y0 *= len;3212      y1 *= len;3213      y2 *= len;3214    }3215    out[0] = x0;3216    out[1] = y0;3217    out[2] = z0;3218    out[3] = 0;3219    out[4] = x1;3220    out[5] = y1;3221    out[6] = z1;3222    out[7] = 0;3223    out[8] = x2;3224    out[9] = y2;3225    out[10] = z2;3226    out[11] = 0;3227    out[12] = -(x0 * eyex + x1 * eyey + x2 * eyez);3228    out[13] = -(y0 * eyex + y1 * eyey + y2 * eyez);3229    out[14] = -(z0 * eyex + z1 * eyey + z2 * eyez);3230    out[15] = 1;3231    return out;3232  }3233  /**3234   * Generates a matrix that makes something look at something else.3235   *3236   * @param {mat4} out mat4 frustum matrix will be written into3237   * @param {vec3} eye Position of the viewer3238   * @param {vec3} center Point the viewer is looking at3239   * @param {vec3} up vec3 pointing up3240   * @returns {mat4} out3241   */3242  function targetTo(out, eye, target, up) {3243    var eyex = eye[0],3244        eyey = eye[1],3245        eyez = eye[2],3246        upx = up[0],3247        upy = up[1],3248        upz = up[2];3249    var z0 = eyex - target[0],3250        z1 = eyey - target[1],3251        z2 = eyez - target[2];3252    var len = z0 * z0 + z1 * z1 + z2 * z2;3253    if (len > 0) {3254      len = 1 / Math.sqrt(len);3255      z0 *= len;3256      z1 *= len;3257      z2 *= len;3258    }3259    var x0 = upy * z2 - upz * z1,3260        x1 = upz * z0 - upx * z2,3261        x2 = upx * z1 - upy * z0;3262    len = x0 * x0 + x1 * x1 + x2 * x2;3263    if (len > 0) {3264      len = 1 / Math.sqrt(len);3265      x0 *= len;3266      x1 *= len;3267      x2 *= len;3268    }3269    out[0] = x0;3270    out[1] = x1;3271    out[2] = x2;3272    out[3] = 0;3273    out[4] = z1 * x2 - z2 * x1;3274    out[5] = z2 * x0 - z0 * x2;3275    out[6] = z0 * x1 - z1 * x0;3276    out[7] = 0;3277    out[8] = z0;3278    out[9] = z1;3279    out[10] = z2;3280    out[11] = 0;3281    out[12] = eyex;3282    out[13] = eyey;3283    out[14] = eyez;3284    out[15] = 1;3285    return out;3286  }3287  /**3288   * Returns a string representation of a mat43289   *3290   * @param {mat4} a matrix to represent as a string3291   * @returns {String} string representation of the matrix3292   */3293  function str$3(a) {3294    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] + ')';3295  }3296  /**3297   * Returns Frobenius norm of a mat43298   *3299   * @param {mat4} a the matrix to calculate Frobenius norm of3300   * @returns {Number} Frobenius norm3301   */3302  function frob$3(a) {3303    return Math.hypot(a[0], a[1], 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]);3304  }3305  /**3306   * Adds two mat4's3307   *3308   * @param {mat4} out the receiving matrix3309   * @param {mat4} a the first operand3310   * @param {mat4} b the second operand3311   * @returns {mat4} out3312   */3313  function add$3(out, a, b) {3314    out[0] = a[0] + b[0];3315    out[1] = a[1] + b[1];3316    out[2] = a[2] + b[2];3317    out[3] = a[3] + b[3];3318    out[4] = a[4] + b[4];3319    out[5] = a[5] + b[5];3320    out[6] = a[6] + b[6];3321    out[7] = a[7] + b[7];3322    out[8] = a[8] + b[8];3323    out[9] = a[9] + b[9];3324    out[10] = a[10] + b[10];3325    out[11] = a[11] + b[11];3326    out[12] = a[12] + b[12];3327    out[13] = a[13] + b[13];3328    out[14] = a[14] + b[14];3329    out[15] = a[15] + b[15];3330    return out;3331  }3332  /**3333   * Subtracts matrix b from matrix a3334   *3335   * @param {mat4} out the receiving matrix3336   * @param {mat4} a the first operand3337   * @param {mat4} b the second operand3338   * @returns {mat4} out3339   */3340  function subtract$3(out, a, b) {3341    out[0] = a[0] - b[0];3342    out[1] = a[1] - b[1];3343    out[2] = a[2] - b[2];3344    out[3] = a[3] - b[3];3345    out[4] = a[4] - b[4];3346    out[5] = a[5] - b[5];3347    out[6] = a[6] - b[6];3348    out[7] = a[7] - b[7];3349    out[8] = a[8] - b[8];3350    out[9] = a[9] - b[9];3351    out[10] = a[10] - b[10];3352    out[11] = a[11] - b[11];3353    out[12] = a[12] - b[12];3354    out[13] = a[13] - b[13];3355    out[14] = a[14] - b[14];3356    out[15] = a[15] - b[15];3357    return out;3358  }3359  /**3360   * Multiply each element of the matrix by a scalar.3361   *3362   * @param {mat4} out the receiving matrix3363   * @param {mat4} a the matrix to scale3364   * @param {Number} b amount to scale the matrix's elements by3365   * @returns {mat4} out3366   */3367  function multiplyScalar$3(out, a, b) {3368    out[0] = a[0] * b;3369    out[1] = a[1] * b;3370    out[2] = a[2] * b;3371    out[3] = a[3] * b;3372    out[4] = a[4] * b;3373    out[5] = a[5] * b;3374    out[6] = a[6] * b;3375    out[7] = a[7] * b;3376    out[8] = a[8] * b;3377    out[9] = a[9] * b;3378    out[10] = a[10] * b;3379    out[11] = a[11] * b;3380    out[12] = a[12] * b;3381    out[13] = a[13] * b;3382    out[14] = a[14] * b;3383    out[15] = a[15] * b;3384    return out;3385  }3386  /**3387   * Adds two mat4's after multiplying each element of the second operand by a scalar value.3388   *3389   * @param {mat4} out the receiving vector3390   * @param {mat4} a the first operand3391   * @param {mat4} b the second operand3392   * @param {Number} scale the amount to scale b's elements by before adding3393   * @returns {mat4} out3394   */3395  function multiplyScalarAndAdd$3(out, a, b, scale) {3396    out[0] = a[0] + b[0] * scale;3397    out[1] = a[1] + b[1] * scale;3398    out[2] = a[2] + b[2] * scale;3399    out[3] = a[3] + b[3] * scale;3400    out[4] = a[4] + b[4] * scale;3401    out[5] = a[5] + b[5] * scale;3402    out[6] = a[6] + b[6] * scale;3403    out[7] = a[7] + b[7] * scale;3404    out[8] = a[8] + b[8] * scale;3405    out[9] = a[9] + b[9] * scale;3406    out[10] = a[10] + b[10] * scale;3407    out[11] = a[11] + b[11] * scale;3408    out[12] = a[12] + b[12] * scale;3409    out[13] = a[13] + b[13] * scale;3410    out[14] = a[14] + b[14] * scale;3411    out[15] = a[15] + b[15] * scale;3412    return out;3413  }3414  /**3415   * Returns whether or not the matrices have exactly the same elements in the same position (when compared with ===)3416   *3417   * @param {mat4} a The first matrix.3418   * @param {mat4} b The second matrix.3419   * @returns {Boolean} True if the matrices are equal, false otherwise.3420   */3421  function exactEquals$3(a, b) {3422    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];3423  }3424  /**3425   * Returns whether or not the matrices have approximately the same elements in the same position.3426   *3427   * @param {mat4} a The first matrix.3428   * @param {mat4} b The second matrix.3429   * @returns {Boolean} True if the matrices are equal, false otherwise.3430   */3431  function equals$4(a, b) {3432    var a0 = a[0],3433        a1 = a[1],3434        a2 = a[2],3435        a3 = a[3];3436    var a4 = a[4],3437        a5 = a[5],3438        a6 = a[6],3439        a7 = a[7];3440    var a8 = a[8],3441        a9 = a[9],3442        a10 = a[10],3443        a11 = a[11];3444    var a12 = a[12],3445        a13 = a[13],3446        a14 = a[14],3447        a15 = a[15];3448    var b0 = b[0],3449        b1 = b[1],3450        b2 = b[2],3451        b3 = b[3];3452    var b4 = b[4],3453        b5 = b[5],3454        b6 = b[6],3455        b7 = b[7];3456    var b8 = b[8],3457        b9 = b[9],3458        b10 = b[10],3459        b11 = b[11];3460    var b12 = b[12],3461        b13 = b[13],3462        b14 = b[14],3463        b15 = b[15];3464    return Math.abs(a0 - b0) <= EPSILON * Math.max(1.0, Math.abs(a0), Math.abs(b0)) && Math.abs(a1 - b1) <= EPSILON * Math.max(1.0, Math.abs(a1), Math.abs(b1)) && Math.abs(a2 - b2) <= EPSILON * Math.max(1.0, Math.abs(a2), Math.abs(b2)) && Math.abs(a3 - b3) <= EPSILON * Math.max(1.0, Math.abs(a3), Math.abs(b3)) && Math.abs(a4 - b4) <= EPSILON * Math.max(1.0, Math.abs(a4), Math.abs(b4)) && Math.abs(a5 - b5) <= EPSILON * Math.max(1.0, Math.abs(a5), Math.abs(b5)) && Math.abs(a6 - b6) <= EPSILON * Math.max(1.0, Math.abs(a6), Math.abs(b6)) && Math.abs(a7 - b7) <= EPSILON * Math.max(1.0, Math.abs(a7), Math.abs(b7)) && Math.abs(a8 - b8) <= EPSILON * Math.max(1.0, Math.abs(a8), Math.abs(b8)) && Math.abs(a9 - b9) <= EPSILON * Math.max(1.0, Math.abs(a9), Math.abs(b9)) && Math.abs(a10 - b10) <= EPSILON * Math.max(1.0, Math.abs(a10), Math.abs(b10)) && Math.abs(a11 - b11) <= EPSILON * Math.max(1.0, Math.abs(a11), Math.abs(b11)) && Math.abs(a12 - b12) <= EPSILON * Math.max(1.0, Math.abs(a12), Math.abs(b12)) && Math.abs(a13 - b13) <= EPSILON * Math.max(1.0, Math.abs(a13), Math.abs(b13)) && Math.abs(a14 - b14) <= EPSILON * Math.max(1.0, Math.abs(a14), Math.abs(b14)) && Math.abs(a15 - b15) <= EPSILON * Math.max(1.0, Math.abs(a15), Math.abs(b15));3465  }3466  /**3467   * Alias for {@link mat4.multiply}3468   * @function3469   */3470  var mul$3 = multiply$3;3471  /**3472   * Alias for {@link mat4.subtract}3473   * @function3474   */3475  var sub$3 = subtract$3;3476  var mat4 = /*#__PURE__*/Object.freeze({3477    create: create$3,3478    clone: clone$3,3479    copy: copy$3,3480    fromValues: fromValues$3,3481    set: set$3,3482    identity: identity$3,3483    transpose: transpose$2,3484    invert: invert$3,3485    adjoint: adjoint$2,3486    determinant: determinant$3,3487    multiply: multiply$3,3488    translate: translate$2,3489    scale: scale$3,3490    rotate: rotate$3,3491    rotateX: rotateX,3492    rotateY: rotateY,3493    rotateZ: rotateZ,3494    fromTranslation: fromTranslation$2,3495    fromScaling: fromScaling$3,3496    fromRotation: fromRotation$3,3497    fromXRotation: fromXRotation,3498    fromYRotation: fromYRotation,3499    fromZRotation: fromZRotation,3500    fromRotationTranslation: fromRotationTranslation,3501    fromQuat2: fromQuat2,3502    getTranslation: getTranslation,3503    getScaling: getScaling,3504    getRotation: getRotation,3505    fromRotationTranslationScale: fromRotationTranslationScale,3506    fromRotationTranslationScaleOrigin: fromRotationTranslationScaleOrigin,3507    fromQuat: fromQuat$1,3508    frustum: frustum,3509    perspective: perspective,3510    perspectiveFromFieldOfView: perspectiveFromFieldOfView,3511    ortho: ortho,3512    lookAt: lookAt,3513    targetTo: targetTo,3514    str: str$3,3515    frob: frob$3,3516    add: add$3,3517    subtract: subtract$3,3518    multiplyScalar: multiplyScalar$3,3519    multiplyScalarAndAdd: multiplyScalarAndAdd$3,3520    exactEquals: exactEquals$3,3521    equals: equals$4,3522    mul: mul$3,3523    sub: sub$33524  });3525  /**3526   * 3 Dimensional Vector3527   * @module vec33528   */3529  /**3530   * Creates a new, empty vec33531   *3532   * @returns {vec3} a new 3D vector3533   */3534  function create$4() {3535    var out = new ARRAY_TYPE(3);3536    if (ARRAY_TYPE != Float32Array) {3537      out[0] = 0;3538      out[1] = 0;3539      out[2] = 0;3540    }3541    return out;3542  }3543  /**3544   * Creates a new vec3 initialized with values from an existing vector3545   *3546   * @param {vec3} a vector to clone3547   * @returns {vec3} a new 3D vector3548   */3549  function clone$4(a) {3550    var out = new ARRAY_TYPE(3);3551    out[0] = a[0];3552    out[1] = a[1];3553    out[2] = a[2];3554    return out;3555  }3556  /**3557   * Calculates the length of a vec33558   *3559   * @param {vec3} a vector to calculate length of3560   * @returns {Number} length of a3561   */3562  function length(a) {3563    var x = a[0];3564    var y = a[1];3565    var z = a[2];3566    return Math.hypot(x, y, z);3567  }3568  /**3569   * Creates a new vec3 initialized with the given values3570   *3571   * @param {Number} x X component3572   * @param {Number} y Y component3573   * @param {Number} z Z component3574   * @returns {vec3} a new 3D vector3575   */3576  function fromValues$4(x, y, z) {3577    var out = new ARRAY_TYPE(3);3578    out[0] = x;3579    out[1] = y;3580    out[2] = z;3581    return out;3582  }3583  /**3584   * Copy the values from one vec3 to another3585   *3586   * @param {vec3} out the receiving vector3587   * @param {vec3} a the source vector3588   * @returns {vec3} out3589   */3590  function copy$4(out, a) {3591    out[0] = a[0];3592    out[1] = a[1];3593    out[2] = a[2];3594    return out;3595  }3596  /**3597   * Set the components of a vec3 to the given values3598   *3599   * @param {vec3} out the receiving vector3600   * @param {Number} x X component3601   * @param {Number} y Y component3602   * @param {Number} z Z component3603   * @returns {vec3} out3604   */3605  function set$4(out, x, y, z) {3606    out[0] = x;3607    out[1] = y;3608    out[2] = z;3609    return out;3610  }3611  /**3612   * Adds two vec3's3613   *3614   * @param {vec3} out the receiving vector3615   * @param {vec3} a the first operand3616   * @param {vec3} b the second operand3617   * @returns {vec3} out3618   */3619  function add$4(out, a, b) {3620    out[0] = a[0] + b[0];3621    out[1] = a[1] + b[1];3622    out[2] = a[2] + b[2];3623    return out;3624  }3625  /**3626   * Subtracts vector b from vector a3627   *3628   * @param {vec3} out the receiving vector3629   * @param {vec3} a the first operand3630   * @param {vec3} b the second operand3631   * @returns {vec3} out3632   */3633  function subtract$4(out, a, b) {3634    out[0] = a[0] - b[0];3635    out[1] = a[1] - b[1];3636    out[2] = a[2] - b[2];3637    return out;3638  }3639  /**3640   * Multiplies two vec3's3641   *3642   * @param {vec3} out the receiving vector3643   * @param {vec3} a the first operand3644   * @param {vec3} b the second operand3645   * @returns {vec3} out3646   */3647  function multiply$4(out, a, b) {3648    out[0] = a[0] * b[0];3649    out[1] = a[1] * b[1];3650    out[2] = a[2] * b[2];3651    return out;3652  }3653  /**3654   * Divides two vec3's3655   *3656   * @param {vec3} out the receiving vector3657   * @param {vec3} a the first operand3658   * @param {vec3} b the second operand3659   * @returns {vec3} out3660   */3661  function divide(out, a, b) {3662    out[0] = a[0] / b[0];3663    out[1] = a[1] / b[1];3664    out[2] = a[2] / b[2];3665    return out;3666  }3667  /**3668   * Math.ceil the components of a vec33669   *3670   * @param {vec3} out the receiving vector3671   * @param {vec3} a vector to ceil3672   * @returns {vec3} out3673   */3674  function ceil(out, a) {3675    out[0] = Math.ceil(a[0]);3676    out[1] = Math.ceil(a[1]);3677    out[2] = Math.ceil(a[2]);3678    return out;3679  }3680  /**3681   * Math.floor the components of a vec33682   *3683   * @param {vec3} out the receiving vector3684   * @param {vec3} a vector to floor3685   * @returns {vec3} out3686   */3687  function floor(out, a) {3688    out[0] = Math.floor(a[0]);3689    out[1] = Math.floor(a[1]);3690    out[2] = Math.floor(a[2]);3691    return out;3692  }3693  /**3694   * Returns the minimum of two vec3's3695   *3696   * @param {vec3} out the receiving vector3697   * @param {vec3} a the first operand3698   * @param {vec3} b the second operand3699   * @returns {vec3} out3700   */3701  function min(out, a, b) {3702    out[0] = Math.min(a[0], b[0]);3703    out[1] = Math.min(a[1], b[1]);3704    out[2] = Math.min(a[2], b[2]);3705    return out;3706  }3707  /**3708   * Returns the maximum of two vec3's3709   *3710   * @param {vec3} out the receiving vector3711   * @param {vec3} a the first operand3712   * @param {vec3} b the second operand3713   * @returns {vec3} out3714   */3715  function max(out, a, b) {3716    out[0] = Math.max(a[0], b[0]);3717    out[1] = Math.max(a[1], b[1]);3718    out[2] = Math.max(a[2], b[2]);3719    return out;3720  }3721  /**3722   * Math.round the components of a vec33723   *3724   * @param {vec3} out the receiving vector3725   * @param {vec3} a vector to round3726   * @returns {vec3} out3727   */3728  function round(out, a) {3729    out[0] = Math.round(a[0]);3730    out[1] = Math.round(a[1]);3731    out[2] = Math.round(a[2]);3732    return out;3733  }3734  /**3735   * Scales a vec3 by a scalar number3736   *3737   * @param {vec3} out the receiving vector3738   * @param {vec3} a the vector to scale3739   * @param {Number} b amount to scale the vector by3740   * @returns {vec3} out3741   */3742  function scale$4(out, a, b) {3743    out[0] = a[0] * b;3744    out[1] = a[1] * b;3745    out[2] = a[2] * b;3746    return out;3747  }3748  /**3749   * Adds two vec3's after scaling the second operand by a scalar value3750   *3751   * @param {vec3} out the receiving vector3752   * @param {vec3} a the first operand3753   * @param {vec3} b the second operand3754   * @param {Number} scale the amount to scale b by before adding3755   * @returns {vec3} out3756   */3757  function scaleAndAdd(out, a, b, scale) {3758    out[0] = a[0] + b[0] * scale;3759    out[1] = a[1] + b[1] * scale;3760    out[2] = a[2] + b[2] * scale;3761    return out;3762  }3763  /**3764   * Calculates the euclidian distance between two vec3's3765   *3766   * @param {vec3} a the first operand3767   * @param {vec3} b the second operand3768   * @returns {Number} distance between a and b3769   */3770  function distance(a, b) {3771    var x = b[0] - a[0];3772    var y = b[1] - a[1];3773    var z = b[2] - a[2];3774    return Math.hypot(x, y, z);3775  }3776  /**3777   * Calculates the squared euclidian distance between two vec3's3778   *3779   * @param {vec3} a the first operand3780   * @param {vec3} b the second operand3781   * @returns {Number} squared distance between a and b3782   */3783  function squaredDistance(a, b) {3784    var x = b[0] - a[0];3785    var y = b[1] - a[1];3786    var z = b[2] - a[2];3787    return x * x + y * y + z * z;3788  }3789  /**3790   * Calculates the squared length of a vec33791   *3792   * @param {vec3} a vector to calculate squared length of3793   * @returns {Number} squared length of a3794   */3795  function squaredLength(a) {3796    var x = a[0];3797    var y = a[1];3798    var z = a[2];3799    return x * x + y * y + z * z;3800  }3801  /**3802   * Negates the components of a vec33803   *3804   * @param {vec3} out the receiving vector3805   * @param {vec3} a vector to negate3806   * @returns {vec3} out3807   */3808  function negate(out, a) {3809    out[0] = -a[0];3810    out[1] = -a[1];3811    out[2] = -a[2];3812    return out;3813  }3814  /**3815   * Returns the inverse of the components of a vec33816   *3817   * @param {vec3} out the receiving vector3818   * @param {vec3} a vector to invert3819   * @returns {vec3} out3820   */3821  function inverse(out, a) {3822    out[0] = 1.0 / a[0];3823    out[1] = 1.0 / a[1];3824    out[2] = 1.0 / a[2];3825    return out;3826  }3827  /**3828   * Normalize a vec33829   *3830   * @param {vec3} out the receiving vector3831   * @param {vec3} a vector to normalize3832   * @returns {vec3} out3833   */3834  function normalize(out, a) {3835    var x = a[0];3836    var y = a[1];3837    var z = a[2];3838    var len = x * x + y * y + z * z;3839    if (len > 0) {3840      //TODO: evaluate use of glm_invsqrt here?3841      len = 1 / Math.sqrt(len);3842    }3843    out[0] = a[0] * len;3844    out[1] = a[1] * len;3845    out[2] = a[2] * len;3846    return out;3847  }3848  /**3849   * Calculates the dot product of two vec3's3850   *3851   * @param {vec3} a the first operand3852   * @param {vec3} b the second operand3853   * @returns {Number} dot product of a and b3854   */3855  function dot(a, b) {3856    return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];3857  }3858  /**3859   * Computes the cross product of two vec3's3860   *3861   * @param {vec3} out the receiving vector3862   * @param {vec3} a the first operand3863   * @param {vec3} b the second operand3864   * @returns {vec3} out3865   */3866  function cross(out, a, b) {3867    var ax = a[0],3868        ay = a[1],3869        az = a[2];3870    var bx = b[0],3871        by = b[1],3872        bz = b[2];3873    out[0] = ay * bz - az * by;3874    out[1] = az * bx - ax * bz;3875    out[2] = ax * by - ay * bx;3876    return out;3877  }3878  /**3879   * Performs a linear interpolation between two vec3's3880   *3881   * @param {vec3} out the receiving vector3882   * @param {vec3} a the first operand3883   * @param {vec3} b the second operand3884   * @param {Number} t interpolation amount, in the range [0-1], between the two inputs3885   * @returns {vec3} out3886   */3887  function lerp(out, a, b, t) {3888    var ax = a[0];3889    var ay = a[1];3890    var az = a[2];3891    out[0] = ax + t * (b[0] - ax);3892    out[1] = ay + t * (b[1] - ay);3893    out[2] = az + t * (b[2] - az);3894    return out;3895  }3896  /**3897   * Performs a hermite interpolation with two control points3898   *3899   * @param {vec3} out the receiving vector3900   * @param {vec3} a the first operand3901   * @param {vec3} b the second operand3902   * @param {vec3} c the third operand3903   * @param {vec3} d the fourth operand3904   * @param {Number} t interpolation amount, in the range [0-1], between the two inputs3905   * @returns {vec3} out3906   */3907  function hermite(out, a, b, c, d, t) {3908    var factorTimes2 = t * t;3909    var factor1 = factorTimes2 * (2 * t - 3) + 1;3910    var factor2 = factorTimes2 * (t - 2) + t;3911    var factor3 = factorTimes2 * (t - 1);3912    var factor4 = factorTimes2 * (3 - 2 * t);3913    out[0] = a[0] * factor1 + b[0] * factor2 + c[0] * factor3 + d[0] * factor4;3914    out[1] = a[1] * factor1 + b[1] * factor2 + c[1] * factor3 + d[1] * factor4;3915    out[2] = a[2] * factor1 + b[2] * factor2 + c[2] * factor3 + d[2] * factor4;3916    return out;3917  }3918  /**3919   * Performs a bezier interpolation with two control points3920   *3921   * @param {vec3} out the receiving vector3922   * @param {vec3} a the first operand3923   * @param {vec3} b the second operand3924   * @param {vec3} c the third operand3925   * @param {vec3} d the fourth operand3926   * @param {Number} t interpolation amount, in the range [0-1], between the two inputs3927   * @returns {vec3} out3928   */3929  function bezier(out, a, b, c, d, t) {3930    var inverseFactor = 1 - t;3931    var inverseFactorTimesTwo = inverseFactor * inverseFactor;3932    var factorTimes2 = t * t;3933    var factor1 = inverseFactorTimesTwo * inverseFactor;3934    var factor2 = 3 * t * inverseFactorTimesTwo;3935    var factor3 = 3 * factorTimes2 * inverseFactor;3936    var factor4 = factorTimes2 * t;3937    out[0] = a[0] * factor1 + b[0] * factor2 + c[0] * factor3 + d[0] * factor4;3938    out[1] = a[1] * factor1 + b[1] * factor2 + c[1] * factor3 + d[1] * factor4;3939    out[2] = a[2] * factor1 + b[2] * factor2 + c[2] * factor3 + d[2] * factor4;3940    return out;3941  }3942  /**3943   * Generates a random vector with the given scale3944   *3945   * @param {vec3} out the receiving vector3946   * @param {Number} [scale] Length of the resulting vector. If ommitted, a unit vector will be returned3947   * @returns {vec3} out3948   */3949  function random(out, scale) {3950    scale = scale || 1.0;3951    var r = RANDOM() * 2.0 * Math.PI;3952    var z = RANDOM() * 2.0 - 1.0;3953    var zScale = Math.sqrt(1.0 - z * z) * scale;3954    out[0] = Math.cos(r) * zScale;3955    out[1] = Math.sin(r) * zScale;3956    out[2] = z * scale;3957    return out;3958  }3959  /**3960   * Transforms the vec3 with a mat4.3961   * 4th vector component is implicitly '1'3962   *3963   * @param {vec3} out the receiving vector3964   * @param {vec3} a the vector to transform3965   * @param {mat4} m matrix to transform with3966   * @returns {vec3} out3967   */3968  function transformMat4(out, a, m) {3969    var x = a[0],3970        y = a[1],3971        z = a[2];3972    var w = m[3] * x + m[7] * y + m[11] * z + m[15];3973    w = w || 1.0;3974    out[0] = (m[0] * x + m[4] * y + m[8] * z + m[12]) / w;3975    out[1] = (m[1] * x + m[5] * y + m[9] * z + m[13]) / w;3976    out[2] = (m[2] * x + m[6] * y + m[10] * z + m[14]) / w;3977    return out;3978  }3979  /**3980   * Transforms the vec3 with a mat3.3981   *3982   * @param {vec3} out the receiving vector3983   * @param {vec3} a the vector to transform3984   * @param {mat3} m the 3x3 matrix to transform with3985   * @returns {vec3} out3986   */3987  function transformMat3(out, a, m) {3988    var x = a[0],3989        y = a[1],3990        z = a[2];3991    out[0] = x * m[0] + y * m[3] + z * m[6];3992    out[1] = x * m[1] + y * m[4] + z * m[7];3993    out[2] = x * m[2] + y * m[5] + z * m[8];3994    return out;3995  }3996  /**3997   * Transforms the vec3 with a quat3998   * Can also be used for dual quaternions. (Multiply it with the real part)3999   *4000   * @param {vec3} out the receiving vector4001   * @param {vec3} a the vector to transform4002   * @param {quat} q quaternion to transform with4003   * @returns {vec3} out4004   */4005  function transformQuat(out, a, q) {4006    // benchmarks: https://jsperf.com/quaternion-transform-vec3-implementations-fixed4007    var qx = q[0],4008        qy = q[1],4009        qz = q[2],4010        qw = q[3];4011    var x = a[0],4012        y = a[1],4013        z = a[2]; // var qvec = [qx, qy, qz];4014    // var uv = vec3.cross([], qvec, a);4015    var uvx = qy * z - qz * y,4016        uvy = qz * x - qx * z,4017        uvz = qx * y - qy * x; // var uuv = vec3.cross([], qvec, uv);4018    var uuvx = qy * uvz - qz * uvy,4019        uuvy = qz * uvx - qx * uvz,4020        uuvz = qx * uvy - qy * uvx; // vec3.scale(uv, uv, 2 * w);4021    var w2 = qw * 2;4022    uvx *= w2;4023    uvy *= w2;4024    uvz *= w2; // vec3.scale(uuv, uuv, 2);4025    uuvx *= 2;4026    uuvy *= 2;4027    uuvz *= 2; // return vec3.add(out, a, vec3.add(out, uv, uuv));4028    out[0] = x + uvx + uuvx;4029    out[1] = y + uvy + uuvy;4030    out[2] = z + uvz + uuvz;4031    return out;4032  }4033  /**4034   * Rotate a 3D vector around the x-axis4035   * @param {vec3} out The receiving vec34036   * @param {vec3} a The vec3 point to rotate4037   * @param {vec3} b The origin of the rotation4038   * @param {Number} c The angle of rotation4039   * @returns {vec3} out4040   */4041  function rotateX$1(out, a, b, c) {4042    var p = [],4043        r = []; //Translate point to the origin4044    p[0] = a[0] - b[0];4045    p[1] = a[1] - b[1];4046    p[2] = a[2] - b[2]; //perform rotation4047    r[0] = p[0];4048    r[1] = p[1] * Math.cos(c) - p[2] * Math.sin(c);4049    r[2] = p[1] * Math.sin(c) + p[2] * Math.cos(c); //translate to correct position4050    out[0] = r[0] + b[0];4051    out[1] = r[1] + b[1];4052    out[2] = r[2] + b[2];4053    return out;4054  }4055  /**4056   * Rotate a 3D vector around the y-axis4057   * @param {vec3} out The receiving vec34058   * @param {vec3} a The vec3 point to rotate4059   * @param {vec3} b The origin of the rotation4060   * @param {Number} c The angle of rotation4061   * @returns {vec3} out4062   */4063  function rotateY$1(out, a, b, c) {4064    var p = [],4065        r = []; //Translate point to the origin4066    p[0] = a[0] - b[0];4067    p[1] = a[1] - b[1];4068    p[2] = a[2] - b[2]; //perform rotation4069    r[0] = p[2] * Math.sin(c) + p[0] * Math.cos(c);4070    r[1] = p[1];4071    r[2] = p[2] * Math.cos(c) - p[0] * Math.sin(c); //translate to correct position4072    out[0] = r[0] + b[0];4073    out[1] = r[1] + b[1];4074    out[2] = r[2] + b[2];4075    return out;4076  }4077  /**4078   * Rotate a 3D vector around the z-axis4079   * @param {vec3} out The receiving vec34080   * @param {vec3} a The vec3 point to rotate4081   * @param {vec3} b The origin of the rotation4082   * @param {Number} c The angle of rotation4083   * @returns {vec3} out4084   */4085  function rotateZ$1(out, a, b, c) {4086    var p = [],4087        r = []; //Translate point to the origin4088    p[0] = a[0] - b[0];4089    p[1] = a[1] - b[1];4090    p[2] = a[2] - b[2]; //perform rotation4091    r[0] = p[0] * Math.cos(c) - p[1] * Math.sin(c);4092    r[1] = p[0] * Math.sin(c) + p[1] * Math.cos(c);4093    r[2] = p[2]; //translate to correct position4094    out[0] = r[0] + b[0];4095    out[1] = r[1] + b[1];4096    out[2] = r[2] + b[2];4097    return out;4098  }4099  /**4100   * Get the angle between two 3D vectors4101   * @param {vec3} a The first operand4102   * @param {vec3} b The second operand4103   * @returns {Number} The angle in radians4104   */4105  function angle(a, b) {4106    var tempA = fromValues$4(a[0], a[1], a[2]);4107    var tempB = fromValues$4(b[0], b[1], b[2]);4108    normalize(tempA, tempA);4109    normalize(tempB, tempB);4110    var cosine = dot(tempA, tempB);4111    if (cosine > 1.0) {4112      return 0;4113    } else if (cosine < -1.0) {4114      return Math.PI;4115    } else {4116      return Math.acos(cosine);4117    }4118  }4119  /**4120   * Set the components of a vec3 to zero4121   *4122   * @param {vec3} out the receiving vector4123   * @returns {vec3} out4124   */4125  function zero(out) {4126    out[0] = 0.0;4127    out[1] = 0.0;4128    out[2] = 0.0;4129    return out;4130  }4131  /**4132   * Returns a string representation of a vector4133   *4134   * @param {vec3} a vector to represent as a string4135   * @returns {String} string representation of the vector4136   */4137  function str$4(a) {4138    return 'vec3(' + a[0] + ', ' + a[1] + ', ' + a[2] + ')';4139  }4140  /**4141   * Returns whether or not the vectors have exactly the same elements in the same position (when compared with ===)4142   *4143   * @param {vec3} a The first vector.4144   * @param {vec3} b The second vector.4145   * @returns {Boolean} True if the vectors are equal, false otherwise.4146   */4147  function exactEquals$4(a, b) {4148    return a[0] === b[0] && a[1] === b[1] && a[2] === b[2];4149  }4150  /**4151   * Returns whether or not the vectors have approximately the same elements in the same position.4152   *4153   * @param {vec3} a The first vector.4154   * @param {vec3} b The second vector.4155   * @returns {Boolean} True if the vectors are equal, false otherwise.4156   */4157  function equals$5(a, b) {4158    var a0 = a[0],4159        a1 = a[1],4160        a2 = a[2];4161    var b0 = b[0],4162        b1 = b[1],4163        b2 = b[2];4164    return Math.abs(a0 - b0) <= EPSILON * Math.max(1.0, Math.abs(a0), Math.abs(b0)) && Math.abs(a1 - b1) <= EPSILON * Math.max(1.0, Math.abs(a1), Math.abs(b1)) && Math.abs(a2 - b2) <= EPSILON * Math.max(1.0, Math.abs(a2), Math.abs(b2));4165  }4166  /**4167   * Alias for {@link vec3.subtract}4168   * @function4169   */4170  var sub$4 = subtract$4;4171  /**4172   * Alias for {@link vec3.multiply}4173   * @function4174   */4175  var mul$4 = multiply$4;4176  /**4177   * Alias for {@link vec3.divide}4178   * @function4179   */4180  var div = divide;4181  /**4182   * Alias for {@link vec3.distance}4183   * @function4184   */4185  var dist = distance;4186  /**4187   * Alias for {@link vec3.squaredDistance}4188   * @function4189   */4190  var sqrDist = squaredDistance;4191  /**4192   * Alias for {@link vec3.length}4193   * @function4194   */4195  var len = length;4196  /**4197   * Alias for {@link vec3.squaredLength}4198   * @function4199   */4200  var sqrLen = squaredLength;4201  /**4202   * Perform some operation over an array of vec3s.4203   *4204   * @param {Array} a the array of vectors to iterate over4205   * @param {Number} stride Number of elements between the start of each vec3. If 0 assumes tightly packed4206   * @param {Number} offset Number of elements to skip at the beginning of the array4207   * @param {Number} count Number of vec3s to iterate over. If 0 iterates over entire array4208   * @param {Function} fn Function to call for each vector in the array4209   * @param {Object} [arg] additional argument to pass to fn4210   * @returns {Array} a4211   * @function4212   */4213  var forEach = function () {4214    var vec = create$4();4215    return function (a, stride, offset, count, fn, arg) {4216      var i, l;4217      if (!stride) {4218        stride = 3;4219      }4220      if (!offset) {4221        offset = 0;4222      }4223      if (count) {4224        l = Math.min(count * stride + offset, a.length);4225      } else {4226        l = a.length;4227      }4228      for (i = offset; i < l; i += stride) {4229        vec[0] = a[i];4230        vec[1] = a[i + 1];4231        vec[2] = a[i + 2];4232        fn(vec, vec, arg);4233        a[i] = vec[0];4234        a[i + 1] = vec[1];4235        a[i + 2] = vec[2];4236      }4237      return a;4238    };4239  }();4240  var vec3 = /*#__PURE__*/Object.freeze({4241    create: create$4,4242    clone: clone$4,4243    length: length,4244    fromValues: fromValues$4,4245    copy: copy$4,4246    set: set$4,4247    add: add$4,4248    subtract: subtract$4,4249    multiply: multiply$4,4250    divide: divide,4251    ceil: ceil,4252    floor: floor,4253    min: min,4254    max: max,4255    round: round,4256    scale: scale$4,4257    scaleAndAdd: scaleAndAdd,4258    distance: distance,4259    squaredDistance: squaredDistance,4260    squaredLength: squaredLength,4261    negate: negate,4262    inverse: inverse,4263    normalize: normalize,4264    dot: dot,4265    cross: cross,4266    lerp: lerp,4267    hermite: hermite,4268    bezier: bezier,4269    random: random,4270    transformMat4: transformMat4,4271    transformMat3: transformMat3,4272    transformQuat: transformQuat,4273    rotateX: rotateX$1,4274    rotateY: rotateY$1,4275    rotateZ: rotateZ$1,4276    angle: angle,4277    zero: zero,4278    str: str$4,4279    exactEquals: exactEquals$4,4280    equals: equals$5,4281    sub: sub$4,4282    mul: mul$4,4283    div: div,4284    dist: dist,4285    sqrDist: sqrDist,4286    len: len,4287    sqrLen: sqrLen,4288    forEach: forEach4289  });4290  /**4291   * 4 Dimensional Vector4292   * @module vec44293   */4294  /**4295   * Creates a new, empty vec44296   *4297   * @returns {vec4} a new 4D vector4298   */4299  function create$5() {4300    var out = new ARRAY_TYPE(4);4301    if (ARRAY_TYPE != Float32Array) {4302      out[0] = 0;4303      out[1] = 0;4304      out[2] = 0;4305      out[3] = 0;4306    }4307    return out;4308  }4309  /**4310   * Creates a new vec4 initialized with values from an existing vector4311   *4312   * @param {vec4} a vector to clone4313   * @returns {vec4} a new 4D vector4314   */4315  function clone$5(a) {4316    var out = new ARRAY_TYPE(4);4317    out[0] = a[0];4318    out[1] = a[1];4319    out[2] = a[2];4320    out[3] = a[3];4321    return out;4322  }4323  /**4324   * Creates a new vec4 initialized with the given values4325   *4326   * @param {Number} x X component4327   * @param {Number} y Y component4328   * @param {Number} z Z component4329   * @param {Number} w W component4330   * @returns {vec4} a new 4D vector4331   */4332  function fromValues$5(x, y, z, w) {4333    var out = new ARRAY_TYPE(4);4334    out[0] = x;4335    out[1] = y;4336    out[2] = z;4337    out[3] = w;4338    return out;4339  }4340  /**4341   * Copy the values from one vec4 to another4342   *4343   * @param {vec4} out the receiving vector4344   * @param {vec4} a the source vector4345   * @returns {vec4} out4346   */4347  function copy$5(out, a) {4348    out[0] = a[0];4349    out[1] = a[1];4350    out[2] = a[2];4351    out[3] = a[3];4352    return out;4353  }4354  /**4355   * Set the components of a vec4 to the given values4356   *4357   * @param {vec4} out the receiving vector4358   * @param {Number} x X component4359   * @param {Number} y Y component4360   * @param {Number} z Z component4361   * @param {Number} w W component4362   * @returns {vec4} out4363   */4364  function set$5(out, x, y, z, w) {4365    out[0] = x;4366    out[1] = y;4367    out[2] = z;4368    out[3] = w;4369    return out;4370  }4371  /**4372   * Adds two vec4's4373   *4374   * @param {vec4} out the receiving vector4375   * @param {vec4} a the first operand4376   * @param {vec4} b the second operand4377   * @returns {vec4} out4378   */4379  function add$5(out, a, b) {4380    out[0] = a[0] + b[0];4381    out[1] = a[1] + b[1];4382    out[2] = a[2] + b[2];4383    out[3] = a[3] + b[3];4384    return out;4385  }4386  /**4387   * Subtracts vector b from vector a4388   *4389   * @param {vec4} out the receiving vector4390   * @param {vec4} a the first operand4391   * @param {vec4} b the second operand4392   * @returns {vec4} out4393   */4394  function subtract$5(out, a, b) {4395    out[0] = a[0] - b[0];4396    out[1] = a[1] - b[1];4397    out[2] = a[2] - b[2];4398    out[3] = a[3] - b[3];4399    return out;4400  }4401  /**4402   * Multiplies two vec4's4403   *4404   * @param {vec4} out the receiving vector4405   * @param {vec4} a the first operand4406   * @param {vec4} b the second operand4407   * @returns {vec4} out4408   */4409  function multiply$5(out, a, b) {4410    out[0] = a[0] * b[0];4411    out[1] = a[1] * b[1];4412    out[2] = a[2] * b[2];4413    out[3] = a[3] * b[3];4414    return out;4415  }4416  /**4417   * Divides two vec4's4418   *4419   * @param {vec4} out the receiving vector4420   * @param {vec4} a the first operand4421   * @param {vec4} b the second operand4422   * @returns {vec4} out4423   */4424  function divide$1(out, a, b) {4425    out[0] = a[0] / b[0];4426    out[1] = a[1] / b[1];4427    out[2] = a[2] / b[2];4428    out[3] = a[3] / b[3];4429    return out;4430  }4431  /**4432   * Math.ceil the components of a vec44433   *4434   * @param {vec4} out the receiving vector4435   * @param {vec4} a vector to ceil4436   * @returns {vec4} out4437   */4438  function ceil$1(out, a) {4439    out[0] = Math.ceil(a[0]);4440    out[1] = Math.ceil(a[1]);4441    out[2] = Math.ceil(a[2]);4442    out[3] = Math.ceil(a[3]);4443    return out;4444  }4445  /**4446   * Math.floor the components of a vec44447   *4448   * @param {vec4} out the receiving vector4449   * @param {vec4} a vector to floor4450   * @returns {vec4} out4451   */4452  function floor$1(out, a) {4453    out[0] = Math.floor(a[0]);4454    out[1] = Math.floor(a[1]);4455    out[2] = Math.floor(a[2]);4456    out[3] = Math.floor(a[3]);4457    return out;4458  }4459  /**4460   * Returns the minimum of two vec4's4461   *4462   * @param {vec4} out the receiving vector4463   * @param {vec4} a the first operand4464   * @param {vec4} b the second operand4465   * @returns {vec4} out4466   */4467  function min$1(out, a, b) {4468    out[0] = Math.min(a[0], b[0]);4469    out[1] = Math.min(a[1], b[1]);4470    out[2] = Math.min(a[2], b[2]);4471    out[3] = Math.min(a[3], b[3]);4472    return out;4473  }4474  /**4475   * Returns the maximum of two vec4's4476   *4477   * @param {vec4} out the receiving vector4478   * @param {vec4} a the first operand4479   * @param {vec4} b the second operand4480   * @returns {vec4} out4481   */4482  function max$1(out, a, b) {4483    out[0] = Math.max(a[0], b[0]);4484    out[1] = Math.max(a[1], b[1]);4485    out[2] = Math.max(a[2], b[2]);4486    out[3] = Math.max(a[3], b[3]);4487    return out;4488  }4489  /**4490   * Math.round the components of a vec44491   *4492   * @param {vec4} out the receiving vector4493   * @param {vec4} a vector to round4494   * @returns {vec4} out4495   */4496  function round$1(out, a) {4497    out[0] = Math.round(a[0]);4498    out[1] = Math.round(a[1]);4499    out[2] = Math.round(a[2]);4500    out[3] = Math.round(a[3]);4501    return out;4502  }4503  /**4504   * Scales a vec4 by a scalar number4505   *4506   * @param {vec4} out the receiving vector4507   * @param {vec4} a the vector to scale4508   * @param {Number} b amount to scale the vector by4509   * @returns {vec4} out4510   */4511  function scale$5(out, a, b) {4512    out[0] = a[0] * b;4513    out[1] = a[1] * b;4514    out[2] = a[2] * b;4515    out[3] = a[3] * b;4516    return out;4517  }4518  /**4519   * Adds two vec4's after scaling the second operand by a scalar value4520   *4521   * @param {vec4} out the receiving vector4522   * @param {vec4} a the first operand4523   * @param {vec4} b the second operand4524   * @param {Number} scale the amount to scale b by before adding4525   * @returns {vec4} out4526   */4527  function scaleAndAdd$1(out, a, b, scale) {4528    out[0] = a[0] + b[0] * scale;4529    out[1] = a[1] + b[1] * scale;4530    out[2] = a[2] + b[2] * scale;4531    out[3] = a[3] + b[3] * scale;4532    return out;4533  }4534  /**4535   * Calculates the euclidian distance between two vec4's4536   *4537   * @param {vec4} a the first operand4538   * @param {vec4} b the second operand4539   * @returns {Number} distance between a and b4540   */4541  function distance$1(a, b) {4542    var x = b[0] - a[0];4543    var y = b[1] - a[1];4544    var z = b[2] - a[2];4545    var w = b[3] - a[3];4546    return Math.hypot(x, y, z, w);4547  }4548  /**4549   * Calculates the squared euclidian distance between two vec4's4550   *4551   * @param {vec4} a the first operand4552   * @param {vec4} b the second operand4553   * @returns {Number} squared distance between a and b4554   */4555  function squaredDistance$1(a, b) {4556    var x = b[0] - a[0];4557    var y = b[1] - a[1];4558    var z = b[2] - a[2];4559    var w = b[3] - a[3];4560    return x * x + y * y + z * z + w * w;4561  }4562  /**4563   * Calculates the length of a vec44564   *4565   * @param {vec4} a vector to calculate length of4566   * @returns {Number} length of a4567   */4568  function length$1(a) {4569    var x = a[0];4570    var y = a[1];4571    var z = a[2];4572    var w = a[3];4573    return Math.hypot(x, y, z, w);4574  }4575  /**4576   * Calculates the squared length of a vec44577   *4578   * @param {vec4} a vector to calculate squared length of4579   * @returns {Number} squared length of a4580   */4581  function squaredLength$1(a) {4582    var x = a[0];4583    var y = a[1];4584    var z = a[2];4585    var w = a[3];4586    return x * x + y * y + z * z + w * w;4587  }4588  /**4589   * Negates the components of a vec44590   *4591   * @param {vec4} out the receiving vector4592   * @param {vec4} a vector to negate4593   * @returns {vec4} out4594   */4595  function negate$1(out, a) {4596    out[0] = -a[0];4597    out[1] = -a[1];4598    out[2] = -a[2];4599    out[3] = -a[3];4600    return out;4601  }4602  /**4603   * Returns the inverse of the components of a vec44604   *4605   * @param {vec4} out the receiving vector4606   * @param {vec4} a vector to invert4607   * @returns {vec4} out4608   */4609  function inverse$1(out, a) {4610    out[0] = 1.0 / a[0];4611    out[1] = 1.0 / a[1];4612    out[2] = 1.0 / a[2];4613    out[3] = 1.0 / a[3];4614    return out;4615  }4616  /**4617   * Normalize a vec44618   *4619   * @param {vec4} out the receiving vector4620   * @param {vec4} a vector to normalize4621   * @returns {vec4} out4622   */4623  function normalize$1(out, a) {4624    var x = a[0];4625    var y = a[1];4626    var z = a[2];4627    var w = a[3];4628    var len = x * x + y * y + z * z + w * w;4629    if (len > 0) {4630      len = 1 / Math.sqrt(len);4631    }4632    out[0] = x * len;4633    out[1] = y * len;4634    out[2] = z * len;4635    out[3] = w * len;4636    return out;4637  }4638  /**4639   * Calculates the dot product of two vec4's4640   *4641   * @param {vec4} a the first operand4642   * @param {vec4} b the second operand4643   * @returns {Number} dot product of a and b4644   */4645  function dot$1(a, b) {4646    return a[0] * b[0] + a[1] * b[1] + a[2] * b[2] + a[3] * b[3];4647  }4648  /**4649   * Returns the cross-product of three vectors in a 4-dimensional space4650   *4651   * @param {vec4} result the receiving vector4652   * @param {vec4} U the first vector4653   * @param {vec4} V the second vector4654   * @param {vec4} W the third vector4655   * @returns {vec4} result4656   */4657  function cross$1(out, u, v, w) {4658    var A = v[0] * w[1] - v[1] * w[0],4659        B = v[0] * w[2] - v[2] * w[0],4660        C = v[0] * w[3] - v[3] * w[0],4661        D = v[1] * w[2] - v[2] * w[1],4662        E = v[1] * w[3] - v[3] * w[1],4663        F = v[2] * w[3] - v[3] * w[2];4664    var G = u[0];4665    var H = u[1];4666    var I = u[2];4667    var J = u[3];4668    out[0] = H * F - I * E + J * D;4669    out[1] = -(G * F) + I * C - J * B;4670    out[2] = G * E - H * C + J * A;4671    out[3] = -(G * D) + H * B - I * A;4672    return out;4673  }4674  /**4675   * Performs a linear interpolation between two vec4's4676   *4677   * @param {vec4} out the receiving vector4678   * @param {vec4} a the first operand4679   * @param {vec4} b the second operand4680   * @param {Number} t interpolation amount, in the range [0-1], between the two inputs4681   * @returns {vec4} out4682   */4683  function lerp$1(out, a, b, t) {4684    var ax = a[0];4685    var ay = a[1];4686    var az = a[2];4687    var aw = a[3];4688    out[0] = ax + t * (b[0] - ax);4689    out[1] = ay + t * (b[1] - ay);4690    out[2] = az + t * (b[2] - az);4691    out[3] = aw + t * (b[3] - aw);4692    return out;4693  }4694  /**4695   * Generates a random vector with the given scale4696   *4697   * @param {vec4} out the receiving vector4698   * @param {Number} [scale] Length of the resulting vector. If ommitted, a unit vector will be returned4699   * @returns {vec4} out4700   */4701  function random$1(out, scale) {4702    scale = scale || 1.0; // Marsaglia, George. Choosing a Point from the Surface of a4703    // Sphere. Ann. Math. Statist. 43 (1972), no. 2, 645--646.4704    // http://projecteuclid.org/euclid.aoms/1177692644;4705    var v1, v2, v3, v4;4706    var s1, s2;4707    do {4708      v1 = RANDOM() * 2 - 1;4709      v2 = RANDOM() * 2 - 1;4710      s1 = v1 * v1 + v2 * v2;4711    } while (s1 >= 1);4712    do {4713      v3 = RANDOM() * 2 - 1;4714      v4 = RANDOM() * 2 - 1;4715      s2 = v3 * v3 + v4 * v4;4716    } while (s2 >= 1);4717    var d = Math.sqrt((1 - s1) / s2);4718    out[0] = scale * v1;4719    out[1] = scale * v2;4720    out[2] = scale * v3 * d;4721    out[3] = scale * v4 * d;4722    return out;4723  }4724  /**4725   * Transforms the vec4 with a mat4.4726   *4727   * @param {vec4} out the receiving vector4728   * @param {vec4} a the vector to transform4729   * @param {mat4} m matrix to transform with4730   * @returns {vec4} out4731   */4732  function transformMat4$1(out, a, m) {4733    var x = a[0],4734        y = a[1],4735        z = a[2],4736        w = a[3];4737    out[0] = m[0] * x + m[4] * y + m[8] * z + m[12] * w;4738    out[1] = m[1] * x + m[5] * y + m[9] * z + m[13] * w;4739    out[2] = m[2] * x + m[6] * y + m[10] * z + m[14] * w;4740    out[3] = m[3] * x + m[7] * y + m[11] * z + m[15] * w;4741    return out;4742  }4743  /**4744   * Transforms the vec4 with a quat4745   *4746   * @param {vec4} out the receiving vector4747   * @param {vec4} a the vector to transform4748   * @param {quat} q quaternion to transform with4749   * @returns {vec4} out4750   */4751  function transformQuat$1(out, a, q) {4752    var x = a[0],4753        y = a[1],4754        z = a[2];4755    var qx = q[0],4756        qy = q[1],4757        qz = q[2],4758        qw = q[3]; // calculate quat * vec4759    var ix = qw * x + qy * z - qz * y;4760    var iy = qw * y + qz * x - qx * z;4761    var iz = qw * z + qx * y - qy * x;4762    var iw = -qx * x - qy * y - qz * z; // calculate result * inverse quat4763    out[0] = ix * qw + iw * -qx + iy * -qz - iz * -qy;4764    out[1] = iy * qw + iw * -qy + iz * -qx - ix * -qz;4765    out[2] = iz * qw + iw * -qz + ix * -qy - iy * -qx;4766    out[3] = a[3];4767    return out;4768  }4769  /**4770   * Set the components of a vec4 to zero4771   *4772   * @param {vec4} out the receiving vector4773   * @returns {vec4} out4774   */4775  function zero$1(out) {4776    out[0] = 0.0;4777    out[1] = 0.0;4778    out[2] = 0.0;4779    out[3] = 0.0;4780    return out;4781  }4782  /**4783   * Returns a string representation of a vector4784   *4785   * @param {vec4} a vector to represent as a string4786   * @returns {String} string representation of the vector4787   */4788  function str$5(a) {4789    return 'vec4(' + a[0] + ', ' + a[1] + ', ' + a[2] + ', ' + a[3] + ')';4790  }4791  /**4792   * Returns whether or not the vectors have exactly the same elements in the same position (when compared with ===)4793   *4794   * @param {vec4} a The first vector.4795   * @param {vec4} b The second vector.4796   * @returns {Boolean} True if the vectors are equal, false otherwise.4797   */4798  function exactEquals$5(a, b) {4799    return a[0] === b[0] && a[1] === b[1] && a[2] === b[2] && a[3] === b[3];4800  }4801  /**4802   * Returns whether or not the vectors have approximately the same elements in the same position.4803   *4804   * @param {vec4} a The first vector.4805   * @param {vec4} b The second vector.4806   * @returns {Boolean} True if the vectors are equal, false otherwise.4807   */4808  function equals$6(a, b) {4809    var a0 = a[0],4810        a1 = a[1],4811        a2 = a[2],4812        a3 = a[3];4813    var b0 = b[0],4814        b1 = b[1],4815        b2 = b[2],4816        b3 = b[3];4817    return Math.abs(a0 - b0) <= EPSILON * Math.max(1.0, Math.abs(a0), Math.abs(b0)) && Math.abs(a1 - b1) <= EPSILON * Math.max(1.0, Math.abs(a1), Math.abs(b1)) && Math.abs(a2 - b2) <= EPSILON * Math.max(1.0, Math.abs(a2), Math.abs(b2)) && Math.abs(a3 - b3) <= EPSILON * Math.max(1.0, Math.abs(a3), Math.abs(b3));4818  }4819  /**4820   * Alias for {@link vec4.subtract}4821   * @function4822   */4823  var sub$5 = subtract$5;4824  /**4825   * Alias for {@link vec4.multiply}4826   * @function4827   */4828  var mul$5 = multiply$5;4829  /**4830   * Alias for {@link vec4.divide}4831   * @function4832   */4833  var div$1 = divide$1;4834  /**4835   * Alias for {@link vec4.distance}4836   * @function4837   */4838  var dist$1 = distance$1;4839  /**4840   * Alias for {@link vec4.squaredDistance}4841   * @function4842   */4843  var sqrDist$1 = squaredDistance$1;4844  /**4845   * Alias for {@link vec4.length}4846   * @function4847   */4848  var len$1 = length$1;4849  /**4850   * Alias for {@link vec4.squaredLength}4851   * @function4852   */4853  var sqrLen$1 = squaredLength$1;4854  /**4855   * Perform some operation over an array of vec4s.4856   *4857   * @param {Array} a the array of vectors to iterate over4858   * @param {Number} stride Number of elements between the start of each vec4. If 0 assumes tightly packed4859   * @param {Number} offset Number of elements to skip at the beginning of the array4860   * @param {Number} count Number of vec4s to iterate over. If 0 iterates over entire array4861   * @param {Function} fn Function to call for each vector in the array4862   * @param {Object} [arg] additional argument to pass to fn4863   * @returns {Array} a4864   * @function4865   */4866  var forEach$1 = function () {4867    var vec = create$5();4868    return function (a, stride, offset, count, fn, arg) {4869      var i, l;4870      if (!stride) {4871        stride = 4;4872      }4873      if (!offset) {4874        offset = 0;4875      }4876      if (count) {4877        l = Math.min(count * stride + offset, a.length);4878      } else {4879        l = a.length;4880      }4881      for (i = offset; i < l; i += stride) {4882        vec[0] = a[i];4883        vec[1] = a[i + 1];4884        vec[2] = a[i + 2];4885        vec[3] = a[i + 3];4886        fn(vec, vec, arg);4887        a[i] = vec[0];4888        a[i + 1] = vec[1];4889        a[i + 2] = vec[2];4890        a[i + 3] = vec[3];4891      }4892      return a;4893    };4894  }();4895  var vec4 = /*#__PURE__*/Object.freeze({4896    create: create$5,4897    clone: clone$5,4898    fromValues: fromValues$5,4899    copy: copy$5,4900    set: set$5,4901    add: add$5,4902    subtract: subtract$5,4903    multiply: multiply$5,4904    divide: divide$1,4905    ceil: ceil$1,4906    floor: floor$1,4907    min: min$1,4908    max: max$1,4909    round: round$1,4910    scale: scale$5,4911    scaleAndAdd: scaleAndAdd$1,4912    distance: distance$1,4913    squaredDistance: squaredDistance$1,4914    length: length$1,4915    squaredLength: squaredLength$1,4916    negate: negate$1,4917    inverse: inverse$1,4918    normalize: normalize$1,4919    dot: dot$1,4920    cross: cross$1,4921    lerp: lerp$1,4922    random: random$1,4923    transformMat4: transformMat4$1,4924    transformQuat: transformQuat$1,4925    zero: zero$1,4926    str: str$5,4927    exactEquals: exactEquals$5,4928    equals: equals$6,4929    sub: sub$5,4930    mul: mul$5,4931    div: div$1,4932    dist: dist$1,4933    sqrDist: sqrDist$1,4934    len: len$1,4935    sqrLen: sqrLen$1,4936    forEach: forEach$14937  });4938  /**4939   * Quaternion4940   * @module quat4941   */4942  /**4943   * Creates a new identity quat4944   *4945   * @returns {quat} a new quaternion4946   */4947  function create$6() {4948    var out = new ARRAY_TYPE(4);4949    if (ARRAY_TYPE != Float32Array) {4950      out[0] = 0;4951      out[1] = 0;4952      out[2] = 0;4953    }4954    out[3] = 1;4955    return out;4956  }4957  /**4958   * Set a quat to the identity quaternion4959   *4960   * @param {quat} out the receiving quaternion4961   * @returns {quat} out4962   */4963  function identity$4(out) {4964    out[0] = 0;4965    out[1] = 0;4966    out[2] = 0;4967    out[3] = 1;4968    return out;4969  }4970  /**4971   * Sets a quat from the given angle and rotation axis,4972   * then returns it.4973   *4974   * @param {quat} out the receiving quaternion4975   * @param {vec3} axis the axis around which to rotate4976   * @param {Number} rad the angle in radians4977   * @returns {quat} out4978   **/4979  function setAxisAngle(out, axis, rad) {4980    rad = rad * 0.5;4981    var s = Math.sin(rad);4982    out[0] = s * axis[0];4983    out[1] = s * axis[1];4984    out[2] = s * axis[2];4985    out[3] = Math.cos(rad);4986    return out;4987  }4988  /**4989   * Gets the rotation axis and angle for a given4990   *  quaternion. If a quaternion is created with4991   *  setAxisAngle, this method will return the same4992   *  values as providied in the original parameter list4993   *  OR functionally equivalent values.4994   * Example: The quaternion formed by axis [0, 0, 1] and4995   *  angle -90 is the same as the quaternion formed by4996   *  [0, 0, 1] and 270. This method favors the latter.4997   * @param  {vec3} out_axis  Vector receiving the axis of rotation4998   * @param  {quat} q     Quaternion to be decomposed4999   * @return {Number}     Angle, in radians, of the rotation5000   */5001  function getAxisAngle(out_axis, q) {5002    var rad = Math.acos(q[3]) * 2.0;5003    var s = Math.sin(rad / 2.0);5004    if (s > EPSILON) {5005      out_axis[0] = q[0] / s;5006      out_axis[1] = q[1] / s;5007      out_axis[2] = q[2] / s;5008    } else {5009      // If s is zero, return any axis (no rotation - axis does not matter)5010      out_axis[0] = 1;5011      out_axis[1] = 0;5012      out_axis[2] = 0;5013    }5014    return rad;5015  }5016  /**5017   * Multiplies two quat's5018   *5019   * @param {quat} out the receiving quaternion5020   * @param {quat} a the first operand5021   * @param {quat} b the second operand5022   * @returns {quat} out5023   */5024  function multiply$6(out, a, b) {5025    var ax = a[0],5026        ay = a[1],5027        az = a[2],5028        aw = a[3];5029    var bx = b[0],5030        by = b[1],5031        bz = b[2],5032        bw = b[3];5033    out[0] = ax * bw + aw * bx + ay * bz - az * by;5034    out[1] = ay * bw + aw * by + az * bx - ax * bz;5035    out[2] = az * bw + aw * bz + ax * by - ay * bx;5036    out[3] = aw * bw - ax * bx - ay * by - az * bz;5037    return out;5038  }5039  /**5040   * Rotates a quaternion by the given angle about the X axis5041   *5042   * @param {quat} out quat receiving operation result5043   * @param {quat} a quat to rotate5044   * @param {number} rad angle (in radians) to rotate5045   * @returns {quat} out5046   */5047  function rotateX$2(out, a, rad) {5048    rad *= 0.5;5049    var ax = a[0],5050        ay = a[1],5051        az = a[2],5052        aw = a[3];5053    var bx = Math.sin(rad),5054        bw = Math.cos(rad);5055    out[0] = ax * bw + aw * bx;5056    out[1] = ay * bw + az * bx;5057    out[2] = az * bw - ay * bx;5058    out[3] = aw * bw - ax * bx;5059    return out;5060  }5061  /**5062   * Rotates a quaternion by the given angle about the Y axis5063   *5064   * @param {quat} out quat receiving operation result5065   * @param {quat} a quat to rotate5066   * @param {number} rad angle (in radians) to rotate5067   * @returns {quat} out5068   */5069  function rotateY$2(out, a, rad) {5070    rad *= 0.5;5071    var ax = a[0],5072        ay = a[1],5073        az = a[2],5074        aw = a[3];5075    var by = Math.sin(rad),5076        bw = Math.cos(rad);5077    out[0] = ax * bw - az * by;5078    out[1] = ay * bw + aw * by;5079    out[2] = az * bw + ax * by;5080    out[3] = aw * bw - ay * by;5081    return out;5082  }5083  /**5084   * Rotates a quaternion by the given angle about the Z axis5085   *5086   * @param {quat} out quat receiving operation result5087   * @param {quat} a quat to rotate5088   * @param {number} rad angle (in radians) to rotate5089   * @returns {quat} out5090   */5091  function rotateZ$2(out, a, rad) {5092    rad *= 0.5;5093    var ax = a[0],5094        ay = a[1],5095        az = a[2],5096        aw = a[3];5097    var bz = Math.sin(rad),5098        bw = Math.cos(rad);5099    out[0] = ax * bw + ay * bz;5100    out[1] = ay * bw - ax * bz;5101    out[2] = az * bw + aw * bz;5102    out[3] = aw * bw - az * bz;5103    return out;5104  }5105  /**5106   * Calculates the W component of a quat from the X, Y, and Z components.5107   * Assumes that quaternion is 1 unit in length.5108   * Any existing W component will be ignored.5109   *5110   * @param {quat} out the receiving quaternion5111   * @param {quat} a quat to calculate W component of5112   * @returns {quat} out5113   */5114  function calculateW(out, a) {5115    var x = a[0],5116        y = a[1],5117        z = a[2];5118    out[0] = x;5119    out[1] = y;5120    out[2] = z;5121    out[3] = Math.sqrt(Math.abs(1.0 - x * x - y * y - z * z));5122    return out;5123  }5124  /**5125   * Performs a spherical linear interpolation between two quat5126   *5127   * @param {quat} out the receiving quaternion5128   * @param {quat} a the first operand5129   * @param {quat} b the second operand5130   * @param {Number} t interpolation amount, in the range [0-1], between the two inputs5131   * @returns {quat} out5132   */5133  function slerp(out, a, b, t) {5134    // benchmarks:5135    //    http://jsperf.com/quaternion-slerp-implementations5136    var ax = a[0],5137        ay = a[1],5138        az = a[2],5139        aw = a[3];5140    var bx = b[0],5141        by = b[1],5142        bz = b[2],5143        bw = b[3];5144    var omega, cosom, sinom, scale0, scale1; // calc cosine5145    cosom = ax * bx + ay * by + az * bz + aw * bw; // adjust signs (if necessary)5146    if (cosom < 0.0) {5147      cosom = -cosom;5148      bx = -bx;5149      by = -by;5150      bz = -bz;5151      bw = -bw;5152    } // calculate coefficients5153    if (1.0 - cosom > EPSILON) {5154      // standard case (slerp)5155      omega = Math.acos(cosom);5156      sinom = Math.sin(omega);5157      scale0 = Math.sin((1.0 - t) * omega) / sinom;5158      scale1 = Math.sin(t * omega) / sinom;5159    } else {5160      // "from" and "to" quaternions are very close5161      //  ... so we can do a linear interpolation5162      scale0 = 1.0 - t;5163      scale1 = t;5164    } // calculate final values5165    out[0] = scale0 * ax + scale1 * bx;5166    out[1] = scale0 * ay + scale1 * by;5167    out[2] = scale0 * az + scale1 * bz;5168    out[3] = scale0 * aw + scale1 * bw;5169    return out;5170  }5171  /**5172   * Generates a random quaternion5173   *5174   * @param {quat} out the receiving quaternion5175   * @returns {quat} out5176   */5177  function random$2(out) {5178    // Implementation of http://planning.cs.uiuc.edu/node198.html5179    // TODO: Calling random 3 times is probably not the fastest solution5180    var u1 = RANDOM();5181    var u2 = RANDOM();5182    var u3 = RANDOM();5183    var sqrt1MinusU1 = Math.sqrt(1 - u1);5184    var sqrtU1 = Math.sqrt(u1);5185    out[0] = sqrt1MinusU1 * Math.sin(2.0 * Math.PI * u2);5186    out[1] = sqrt1MinusU1 * Math.cos(2.0 * Math.PI * u2);5187    out[2] = sqrtU1 * Math.sin(2.0 * Math.PI * u3);5188    out[3] = sqrtU1 * Math.cos(2.0 * Math.PI * u3);5189    return out;5190  }5191  /**5192   * Calculates the inverse of a quat5193   *5194   * @param {quat} out the receiving quaternion5195   * @param {quat} a quat to calculate inverse of5196   * @returns {quat} out5197   */5198  function invert$4(out, a) {5199    var a0 = a[0],5200        a1 = a[1],5201        a2 = a[2],5202        a3 = a[3];5203    var dot = a0 * a0 + a1 * a1 + a2 * a2 + a3 * a3;5204    var invDot = dot ? 1.0 / dot : 0; // TODO: Would be faster to return [0,0,0,0] immediately if dot == 05205    out[0] = -a0 * invDot;5206    out[1] = -a1 * invDot;5207    out[2] = -a2 * invDot;5208    out[3] = a3 * invDot;5209    return out;5210  }5211  /**5212   * Calculates the conjugate of a quat5213   * If the quaternion is normalized, this function is faster than quat.inverse and produces the same result.5214   *5215   * @param {quat} out the receiving quaternion5216   * @param {quat} a quat to calculate conjugate of5217   * @returns {quat} out5218   */5219  function conjugate(out, a) {5220    out[0] = -a[0];5221    out[1] = -a[1];5222    out[2] = -a[2];5223    out[3] = a[3];5224    return out;5225  }5226  /**5227   * Creates a quaternion from the given 3x3 rotation matrix.5228   *5229   * NOTE: The resultant quaternion is not normalized, so you should be sure5230   * to renormalize the quaternion yourself where necessary.5231   *5232   * @param {quat} out the receiving quaternion5233   * @param {mat3} m rotation matrix5234   * @returns {quat} out5235   * @function5236   */5237  function fromMat3(out, m) {5238    // Algorithm in Ken Shoemake's article in 1987 SIGGRAPH course notes5239    // article "Quaternion Calculus and Fast Animation".5240    var fTrace = m[0] + m[4] + m[8];5241    var fRoot;5242    if (fTrace > 0.0) {5243      // |w| > 1/2, may as well choose w > 1/25244      fRoot = Math.sqrt(fTrace + 1.0); // 2w5245      out[3] = 0.5 * fRoot;5246      fRoot = 0.5 / fRoot; // 1/(4w)5247      out[0] = (m[5] - m[7]) * fRoot;5248      out[1] = (m[6] - m[2]) * fRoot;5249      out[2] = (m[1] - m[3]) * fRoot;5250    } else {5251      // |w| <= 1/25252      var i = 0;5253      if (m[4] > m[0]) i = 1;5254      if (m[8] > m[i * 3 + i]) i = 2;5255      var j = (i + 1) % 3;5256      var k = (i + 2) % 3;5257      fRoot = Math.sqrt(m[i * 3 + i] - m[j * 3 + j] - m[k * 3 + k] + 1.0);5258      out[i] = 0.5 * fRoot;5259      fRoot = 0.5 / fRoot;5260      out[3] = (m[j * 3 + k] - m[k * 3 + j]) * fRoot;5261      out[j] = (m[j * 3 + i] + m[i * 3 + j]) * fRoot;5262      out[k] = (m[k * 3 + i] + m[i * 3 + k]) * fRoot;5263    }5264    return out;5265  }5266  /**5267   * Creates a quaternion from the given euler angle x, y, z.5268   *5269   * @param {quat} out the receiving quaternion5270   * @param {x} Angle to rotate around X axis in degrees.5271   * @param {y} Angle to rotate around Y axis in degrees.5272   * @param {z} Angle to rotate around Z axis in degrees.5273   * @returns {quat} out5274   * @function5275   */5276  function fromEuler(out, x, y, z) {5277    var halfToRad = 0.5 * Math.PI / 180.0;5278    x *= halfToRad;5279    y *= halfToRad;5280    z *= halfToRad;5281    var sx = Math.sin(x);5282    var cx = Math.cos(x);5283    var sy = Math.sin(y);5284    var cy = Math.cos(y);5285    var sz = Math.sin(z);5286    var cz = Math.cos(z);5287    out[0] = sx * cy * cz - cx * sy * sz;5288    out[1] = cx * sy * cz + sx * cy * sz;5289    out[2] = cx * cy * sz - sx * sy * cz;5290    out[3] = cx * cy * cz + sx * sy * sz;5291    return out;5292  }5293  /**5294   * Returns a string representation of a quatenion5295   *5296   * @param {quat} a vector to represent as a string5297   * @returns {String} string representation of the vector5298   */5299  function str$6(a) {5300    return 'quat(' + a[0] + ', ' + a[1] + ', ' + a[2] + ', ' + a[3] + ')';5301  }5302  /**5303   * Creates a new quat initialized with values from an existing quaternion5304   *5305   * @param {quat} a quaternion to clone5306   * @returns {quat} a new quaternion5307   * @function5308   */5309  var clone$6 = clone$5;5310  /**5311   * Creates a new quat initialized with the given values5312   *5313   * @param {Number} x X component5314   * @param {Number} y Y component5315   * @param {Number} z Z component5316   * @param {Number} w W component5317   * @returns {quat} a new quaternion5318   * @function5319   */5320  var fromValues$6 = fromValues$5;5321  /**5322   * Copy the values from one quat to another5323   *5324   * @param {quat} out the receiving quaternion5325   * @param {quat} a the source quaternion5326   * @returns {quat} out5327   * @function5328   */5329  var copy$6 = copy$5;5330  /**5331   * Set the components of a quat to the given values5332   *5333   * @param {quat} out the receiving quaternion5334   * @param {Number} x X component5335   * @param {Number} y Y component5336   * @param {Number} z Z component5337   * @param {Number} w W component5338   * @returns {quat} out5339   * @function5340   */5341  var set$6 = set$5;5342  /**5343   * Adds two quat's5344   *5345   * @param {quat} out the receiving quaternion5346   * @param {quat} a the first operand5347   * @param {quat} b the second operand5348   * @returns {quat} out5349   * @function5350   */5351  var add$6 = add$5;5352  /**5353   * Alias for {@link quat.multiply}5354   * @function5355   */5356  var mul$6 = multiply$6;5357  /**5358   * Scales a quat by a scalar number5359   *5360   * @param {quat} out the receiving vector5361   * @param {quat} a the vector to scale5362   * @param {Number} b amount to scale the vector by5363   * @returns {quat} out5364   * @function5365   */5366  var scale$6 = scale$5;5367  /**5368   * Calculates the dot product of two quat's5369   *5370   * @param {quat} a the first operand5371   * @param {quat} b the second operand5372   * @returns {Number} dot product of a and b5373   * @function5374   */5375  var dot$2 = dot$1;5376  /**5377   * Performs a linear interpolation between two quat's5378   *5379   * @param {quat} out the receiving quaternion5380   * @param {quat} a the first operand5381   * @param {quat} b the second operand5382   * @param {Number} t interpolation amount, in the range [0-1], between the two inputs5383   * @returns {quat} out5384   * @function5385   */5386  var lerp$2 = lerp$1;5387  /**5388   * Calculates the length of a quat5389   *5390   * @param {quat} a vector to calculate length of5391   * @returns {Number} length of a5392   */5393  var length$2 = length$1;5394  /**5395   * Alias for {@link quat.length}5396   * @function5397   */5398  var len$2 = length$2;5399  /**5400   * Calculates the squared length of a quat5401   *5402   * @param {quat} a vector to calculate squared length of5403   * @returns {Number} squared length of a5404   * @function5405   */5406  var squaredLength$2 = squaredLength$1;5407  /**5408   * Alias for {@link quat.squaredLength}5409   * @function5410   */5411  var sqrLen$2 = squaredLength$2;5412  /**5413   * Normalize a quat5414   *5415   * @param {quat} out the receiving quaternion5416   * @param {quat} a quaternion to normalize5417   * @returns {quat} out5418   * @function5419   */5420  var normalize$2 = normalize$1;5421  /**5422   * Returns whether or not the quaternions have exactly the same elements in the same position (when compared with ===)5423   *5424   * @param {quat} a The first quaternion.5425   * @param {quat} b The second quaternion.5426   * @returns {Boolean} True if the vectors are equal, false otherwise.5427   */5428  var exactEquals$6 = exactEquals$5;5429  /**5430   * Returns whether or not the quaternions have approximately the same elements in the same position.5431   *5432   * @param {quat} a The first vector.5433   * @param {quat} b The second vector.5434   * @returns {Boolean} True if the vectors are equal, false otherwise.5435   */5436  var equals$7 = equals$6;5437  /**5438   * Sets a quaternion to represent the shortest rotation from one5439   * vector to another.5440   *5441   * Both vectors are assumed to be unit length.5442   *5443   * @param {quat} out the receiving quaternion.5444   * @param {vec3} a the initial vector5445   * @param {vec3} b the destination vector5446   * @returns {quat} out5447   */5448  var rotationTo = function () {5449    var tmpvec3 = create$4();5450    var xUnitVec3 = fromValues$4(1, 0, 0);5451    var yUnitVec3 = fromValues$4(0, 1, 0);5452    return function (out, a, b) {5453      var dot$1 = dot(a, b);5454      if (dot$1 < -0.999999) {5455        cross(tmpvec3, xUnitVec3, a);5456        if (len(tmpvec3) < 0.000001) cross(tmpvec3, yUnitVec3, a);5457        normalize(tmpvec3, tmpvec3);5458        setAxisAngle(out, tmpvec3, Math.PI);5459        return out;5460      } else if (dot$1 > 0.999999) {5461        out[0] = 0;5462        out[1] = 0;5463        out[2] = 0;5464        out[3] = 1;5465        return out;5466      } else {5467        cross(tmpvec3, a, b);5468        out[0] = tmpvec3[0];5469        out[1] = tmpvec3[1];5470        out[2] = tmpvec3[2];5471        out[3] = 1 + dot$1;5472        return normalize$2(out, out);5473      }5474    };5475  }();5476  /**5477   * Performs a spherical linear interpolation with two control points5478   *5479   * @param {quat} out the receiving quaternion5480   * @param {quat} a the first operand5481   * @param {quat} b the second operand5482   * @param {quat} c the third operand5483   * @param {quat} d the fourth operand5484   * @param {Number} t interpolation amount, in the range [0-1], between the two inputs5485   * @returns {quat} out5486   */5487  var sqlerp = function () {5488    var temp1 = create$6();5489    var temp2 = create$6();5490    return function (out, a, b, c, d, t) {5491      slerp(temp1, a, d, t);5492      slerp(temp2, b, c, t);5493      slerp(out, temp1, temp2, 2 * t * (1 - t));5494      return out;5495    };5496  }();5497  /**5498   * Sets the specified quaternion with values corresponding to the given5499   * axes. Each axis is a vec3 and is expected to be unit length and5500   * perpendicular to all other specified axes.5501   *5502   * @param {vec3} view  the vector representing the viewing direction5503   * @param {vec3} right the vector representing the local "right" direction5504   * @param {vec3} up    the vector representing the local "up" direction5505   * @returns {quat} out5506   */5507  var setAxes = function () {5508    var matr = create$2();5509    return function (out, view, right, up) {5510      matr[0] = right[0];5511      matr[3] = right[1];5512      matr[6] = right[2];5513      matr[1] = up[0];5514      matr[4] = up[1];5515      matr[7] = up[2];5516      matr[2] = -view[0];5517      matr[5] = -view[1];5518      matr[8] = -view[2];5519      return normalize$2(out, fromMat3(out, matr));5520    };5521  }();5522  var quat = /*#__PURE__*/Object.freeze({5523    create: create$6,5524    identity: identity$4,5525    setAxisAngle: setAxisAngle,5526    getAxisAngle: getAxisAngle,5527    multiply: multiply$6,5528    rotateX: rotateX$2,5529    rotateY: rotateY$2,5530    rotateZ: rotateZ$2,5531    calculateW: calculateW,5532    slerp: slerp,5533    random: random$2,5534    invert: invert$4,5535    conjugate: conjugate,5536    fromMat3: fromMat3,5537    fromEuler: fromEuler,5538    str: str$6,5539    clone: clone$6,5540    fromValues: fromValues$6,5541    copy: copy$6,5542    set: set$6,5543    add: add$6,5544    mul: mul$6,5545    scale: scale$6,5546    dot: dot$2,5547    lerp: lerp$2,5548    length: length$2,5549    len: len$2,5550    squaredLength: squaredLength$2,5551    sqrLen: sqrLen$2,5552    normalize: normalize$2,5553    exactEquals: exactEquals$6,5554    equals: equals$7,5555    rotationTo: rotationTo,5556    sqlerp: sqlerp,5557    setAxes: setAxes5558  });5559  /**5560   * Dual Quaternion<br>5561   * Format: [real, dual]<br>5562   * Quaternion format: XYZW<br>5563   * Make sure to have normalized dual quaternions, otherwise the functions may not work as intended.<br>5564   * @module quat25565   */5566  /**5567   * Creates a new identity dual quat5568   *5569   * @returns {quat2} a new dual quaternion [real -> rotation, dual -> translation]5570   */5571  function create$7() {5572    var dq = new ARRAY_TYPE(8);5573    if (ARRAY_TYPE != Float32Array) {5574      dq[0] = 0;5575      dq[1] = 0;5576      dq[2] = 0;5577      dq[4] = 0;5578      dq[5] = 0;5579      dq[6] = 0;5580      dq[7] = 0;5581    }5582    dq[3] = 1;5583    return dq;5584  }5585  /**5586   * Creates a new quat initialized with values from an existing quaternion5587   *5588   * @param {quat2} a dual quaternion to clone5589   * @returns {quat2} new dual quaternion5590   * @function5591   */5592  function clone$7(a) {5593    var dq = new ARRAY_TYPE(8);5594    dq[0] = a[0];5595    dq[1] = a[1];5596    dq[2] = a[2];5597    dq[3] = a[3];5598    dq[4] = a[4];5599    dq[5] = a[5];5600    dq[6] = a[6];5601    dq[7] = a[7];5602    return dq;5603  }5604  /**5605   * Creates a new dual quat initialized with the given values5606   *5607   * @param {Number} x1 X component5608   * @param {Number} y1 Y component5609   * @param {Number} z1 Z component5610   * @param {Number} w1 W component5611   * @param {Number} x2 X component5612   * @param {Number} y2 Y component5613   * @param {Number} z2 Z component5614   * @param {Number} w2 W component5615   * @returns {quat2} new dual quaternion5616   * @function5617   */5618  function fromValues$7(x1, y1, z1, w1, x2, y2, z2, w2) {5619    var dq = new ARRAY_TYPE(8);5620    dq[0] = x1;5621    dq[1] = y1;5622    dq[2] = z1;5623    dq[3] = w1;5624    dq[4] = x2;5625    dq[5] = y2;5626    dq[6] = z2;5627    dq[7] = w2;5628    return dq;5629  }5630  /**5631   * Creates a new dual quat from the given values (quat and translation)5632   *5633   * @param {Number} x1 X component5634   * @param {Number} y1 Y component5635   * @param {Number} z1 Z component5636   * @param {Number} w1 W component5637   * @param {Number} x2 X component (translation)5638   * @param {Number} y2 Y component (translation)5639   * @param {Number} z2 Z component (translation)5640   * @returns {quat2} new dual quaternion5641   * @function5642   */5643  function fromRotationTranslationValues(x1, y1, z1, w1, x2, y2, z2) {5644    var dq = new ARRAY_TYPE(8);5645    dq[0] = x1;5646    dq[1] = y1;5647    dq[2] = z1;5648    dq[3] = w1;5649    var ax = x2 * 0.5,5650        ay = y2 * 0.5,5651        az = z2 * 0.5;5652    dq[4] = ax * w1 + ay * z1 - az * y1;5653    dq[5] = ay * w1 + az * x1 - ax * z1;5654    dq[6] = az * w1 + ax * y1 - ay * x1;5655    dq[7] = -ax * x1 - ay * y1 - az * z1;5656    return dq;5657  }5658  /**5659   * Creates a dual quat from a quaternion and a translation5660   *5661   * @param {quat2} dual quaternion receiving operation result5662   * @param {quat} q a normalized quaternion5663   * @param {vec3} t tranlation vector5664   * @returns {quat2} dual quaternion receiving operation result5665   * @function5666   */5667  function fromRotationTranslation$1(out, q, t) {5668    var ax = t[0] * 0.5,5669        ay = t[1] * 0.5,5670        az = t[2] * 0.5,5671        bx = q[0],5672        by = q[1],5673        bz = q[2],5674        bw = q[3];5675    out[0] = bx;5676    out[1] = by;5677    out[2] = bz;5678    out[3] = bw;5679    out[4] = ax * bw + ay * bz - az * by;5680    out[5] = ay * bw + az * bx - ax * bz;5681    out[6] = az * bw + ax * by - ay * bx;5682    out[7] = -ax * bx - ay * by - az * bz;5683    return out;5684  }5685  /**5686   * Creates a dual quat from a translation5687   *5688   * @param {quat2} dual quaternion receiving operation result5689   * @param {vec3} t translation vector5690   * @returns {quat2} dual quaternion receiving operation result5691   * @function5692   */5693  function fromTranslation$3(out, t) {5694    out[0] = 0;5695    out[1] = 0;5696    out[2] = 0;5697    out[3] = 1;5698    out[4] = t[0] * 0.5;5699    out[5] = t[1] * 0.5;5700    out[6] = t[2] * 0.5;5701    out[7] = 0;5702    return out;5703  }5704  /**5705   * Creates a dual quat from a quaternion5706   *5707   * @param {quat2} dual quaternion receiving operation result5708   * @param {quat} q the quaternion5709   * @returns {quat2} dual quaternion receiving operation result5710   * @function5711   */5712  function fromRotation$4(out, q) {5713    out[0] = q[0];5714    out[1] = q[1];5715    out[2] = q[2];5716    out[3] = q[3];5717    out[4] = 0;5718    out[5] = 0;5719    out[6] = 0;5720    out[7] = 0;5721    return out;5722  }5723  /**5724   * Creates a new dual quat from a matrix (4x4)5725   *5726   * @param {quat2} out the dual quaternion5727   * @param {mat4} a the matrix5728   * @returns {quat2} dual quat receiving operation result5729   * @function5730   */5731  function fromMat4$1(out, a) {5732    //TODO Optimize this5733    var outer = create$6();5734    getRotation(outer, a);5735    var t = new ARRAY_TYPE(3);5736    getTranslation(t, a);5737    fromRotationTranslation$1(out, outer, t);5738    return out;5739  }5740  /**5741   * Copy the values from one dual quat to another5742   *5743   * @param {quat2} out the receiving dual quaternion5744   * @param {quat2} a the source dual quaternion5745   * @returns {quat2} out5746   * @function5747   */5748  function copy$7(out, a) {5749    out[0] = a[0];5750    out[1] = a[1];5751    out[2] = a[2];5752    out[3] = a[3];5753    out[4] = a[4];5754    out[5] = a[5];5755    out[6] = a[6];5756    out[7] = a[7];5757    return out;5758  }5759  /**5760   * Set a dual quat to the identity dual quaternion5761   *5762   * @param {quat2} out the receiving quaternion5763   * @returns {quat2} out5764   */5765  function identity$5(out) {5766    out[0] = 0;5767    out[1] = 0;5768    out[2] = 0;5769    out[3] = 1;5770    out[4] = 0;5771    out[5] = 0;5772    out[6] = 0;5773    out[7] = 0;5774    return out;5775  }5776  /**5777   * Set the components of a dual quat to the given values5778   *5779   * @param {quat2} out the receiving quaternion5780   * @param {Number} x1 X component5781   * @param {Number} y1 Y component5782   * @param {Number} z1 Z component5783   * @param {Number} w1 W component5784   * @param {Number} x2 X component5785   * @param {Number} y2 Y component5786   * @param {Number} z2 Z component5787   * @param {Number} w2 W component5788   * @returns {quat2} out5789   * @function5790   */5791  function set$7(out, x1, y1, z1, w1, x2, y2, z2, w2) {5792    out[0] = x1;5793    out[1] = y1;5794    out[2] = z1;5795    out[3] = w1;5796    out[4] = x2;5797    out[5] = y2;5798    out[6] = z2;5799    out[7] = w2;5800    return out;5801  }5802  /**5803   * Gets the real part of a dual quat5804   * @param  {quat} out real part5805   * @param  {quat2} a Dual Quaternion5806   * @return {quat} real part5807   */5808  var getReal = copy$6;5809  /**5810   * Gets the dual part of a dual quat5811   * @param  {quat} out dual part5812   * @param  {quat2} a Dual Quaternion5813   * @return {quat} dual part5814   */5815  function getDual(out, a) {5816    out[0] = a[4];5817    out[1] = a[5];5818    out[2] = a[6];5819    out[3] = a[7];5820    return out;5821  }5822  /**5823   * Set the real component of a dual quat to the given quaternion5824   *5825   * @param {quat2} out the receiving quaternion5826   * @param {quat} q a quaternion representing the real part5827   * @returns {quat2} out5828   * @function5829   */5830  var setReal = copy$6;5831  /**5832   * Set the dual component of a dual quat to the given quaternion5833   *5834   * @param {quat2} out the receiving quaternion5835   * @param {quat} q a quaternion representing the dual part5836   * @returns {quat2} out5837   * @function5838   */5839  function setDual(out, q) {5840    out[4] = q[0];5841    out[5] = q[1];5842    out[6] = q[2];5843    out[7] = q[3];5844    return out;5845  }5846  /**5847   * Gets the translation of a normalized dual quat5848   * @param  {vec3} out translation5849   * @param  {quat2} a Dual Quaternion to be decomposed5850   * @return {vec3} translation5851   */5852  function getTranslation$1(out, a) {5853    var ax = a[4],5854        ay = a[5],5855        az = a[6],5856        aw = a[7],5857        bx = -a[0],5858        by = -a[1],5859        bz = -a[2],5860        bw = a[3];5861    out[0] = (ax * bw + aw * bx + ay * bz - az * by) * 2;5862    out[1] = (ay * bw + aw * by + az * bx - ax * bz) * 2;5863    out[2] = (az * bw + aw * bz + ax * by - ay * bx) * 2;5864    return out;5865  }5866  /**5867   * Translates a dual quat by the given vector5868   *5869   * @param {quat2} out the receiving dual quaternion5870   * @param {quat2} a the dual quaternion to translate5871   * @param {vec3} v vector to translate by5872   * @returns {quat2} out5873   */5874  function translate$3(out, a, v) {5875    var ax1 = a[0],5876        ay1 = a[1],5877        az1 = a[2],5878        aw1 = a[3],5879        bx1 = v[0] * 0.5,5880        by1 = v[1] * 0.5,5881        bz1 = v[2] * 0.5,5882        ax2 = a[4],5883        ay2 = a[5],5884        az2 = a[6],5885        aw2 = a[7];5886    out[0] = ax1;5887    out[1] = ay1;5888    out[2] = az1;5889    out[3] = aw1;5890    out[4] = aw1 * bx1 + ay1 * bz1 - az1 * by1 + ax2;5891    out[5] = aw1 * by1 + az1 * bx1 - ax1 * bz1 + ay2;5892    out[6] = aw1 * bz1 + ax1 * by1 - ay1 * bx1 + az2;5893    out[7] = -ax1 * bx1 - ay1 * by1 - az1 * bz1 + aw2;5894    return out;5895  }5896  /**5897   * Rotates a dual quat around the X axis5898   *5899   * @param {quat2} out the receiving dual quaternion5900   * @param {quat2} a the dual quaternion to rotate5901   * @param {number} rad how far should the rotation be5902   * @returns {quat2} out5903   */5904  function rotateX$3(out, a, rad) {5905    var bx = -a[0],5906        by = -a[1],5907        bz = -a[2],5908        bw = a[3],5909        ax = a[4],5910        ay = a[5],5911        az = a[6],5912        aw = a[7],5913        ax1 = ax * bw + aw * bx + ay * bz - az * by,5914        ay1 = ay * bw + aw * by + az * bx - ax * bz,5915        az1 = az * bw + aw * bz + ax * by - ay * bx,5916        aw1 = aw * bw - ax * bx - ay * by - az * bz;5917    rotateX$2(out, a, rad);5918    bx = out[0];5919    by = out[1];5920    bz = out[2];5921    bw = out[3];5922    out[4] = ax1 * bw + aw1 * bx + ay1 * bz - az1 * by;5923    out[5] = ay1 * bw + aw1 * by + az1 * bx - ax1 * bz;5924    out[6] = az1 * bw + aw1 * bz + ax1 * by - ay1 * bx;5925    out[7] = aw1 * bw - ax1 * bx - ay1 * by - az1 * bz;5926    return out;5927  }5928  /**5929   * Rotates a dual quat around the Y axis5930   *5931   * @param {quat2} out the receiving dual quaternion5932   * @param {quat2} a the dual quaternion to rotate5933   * @param {number} rad how far should the rotation be5934   * @returns {quat2} out5935   */5936  function rotateY$3(out, a, rad) {5937    var bx = -a[0],5938        by = -a[1],5939        bz = -a[2],5940        bw = a[3],5941        ax = a[4],5942        ay = a[5],5943        az = a[6],5944        aw = a[7],5945        ax1 = ax * bw + aw * bx + ay * bz - az * by,5946        ay1 = ay * bw + aw * by + az * bx - ax * bz,5947        az1 = az * bw + aw * bz + ax * by - ay * bx,5948        aw1 = aw * bw - ax * bx - ay * by - az * bz;5949    rotateY$2(out, a, rad);5950    bx = out[0];5951    by = out[1];5952    bz = out[2];5953    bw = out[3];5954    out[4] = ax1 * bw + aw1 * bx + ay1 * bz - az1 * by;5955    out[5] = ay1 * bw + aw1 * by + az1 * bx - ax1 * bz;5956    out[6] = az1 * bw + aw1 * bz + ax1 * by - ay1 * bx;5957    out[7] = aw1 * bw - ax1 * bx - ay1 * by - az1 * bz;5958    return out;5959  }5960  /**5961   * Rotates a dual quat around the Z axis5962   *5963   * @param {quat2} out the receiving dual quaternion5964   * @param {quat2} a the dual quaternion to rotate5965   * @param {number} rad how far should the rotation be5966   * @returns {quat2} out5967   */5968  function rotateZ$3(out, a, rad) {5969    var bx = -a[0],5970        by = -a[1],5971        bz = -a[2],5972        bw = a[3],5973        ax = a[4],5974        ay = a[5],5975        az = a[6],5976        aw = a[7],5977        ax1 = ax * bw + aw * bx + ay * bz - az * by,5978        ay1 = ay * bw + aw * by + az * bx - ax * bz,5979        az1 = az * bw + aw * bz + ax * by - ay * bx,5980        aw1 = aw * bw - ax * bx - ay * by - az * bz;5981    rotateZ$2(out, a, rad);5982    bx = out[0];5983    by = out[1];5984    bz = out[2];5985    bw = out[3];5986    out[4] = ax1 * bw + aw1 * bx + ay1 * bz - az1 * by;5987    out[5] = ay1 * bw + aw1 * by + az1 * bx - ax1 * bz;5988    out[6] = az1 * bw + aw1 * bz + ax1 * by - ay1 * bx;5989    out[7] = aw1 * bw - ax1 * bx - ay1 * by - az1 * bz;5990    return out;5991  }5992  /**5993   * Rotates a dual quat by a given quaternion (a * q)5994   *5995   * @param {quat2} out the receiving dual quaternion5996   * @param {quat2} a the dual quaternion to rotate5997   * @param {quat} q quaternion to rotate by5998   * @returns {quat2} out5999   */6000  function rotateByQuatAppend(out, a, q) {6001    var qx = q[0],6002        qy = q[1],6003        qz = q[2],6004        qw = q[3],6005        ax = a[0],6006        ay = a[1],6007        az = a[2],6008        aw = a[3];6009    out[0] = ax * qw + aw * qx + ay * qz - az * qy;6010    out[1] = ay * qw + aw * qy + az * qx - ax * qz;6011    out[2] = az * qw + aw * qz + ax * qy - ay * qx;6012    out[3] = aw * qw - ax * qx - ay * qy - az * qz;6013    ax = a[4];6014    ay = a[5];6015    az = a[6];6016    aw = a[7];6017    out[4] = ax * qw + aw * qx + ay * qz - az * qy;6018    out[5] = ay * qw + aw * qy + az * qx - ax * qz;6019    out[6] = az * qw + aw * qz + ax * qy - ay * qx;6020    out[7] = aw * qw - ax * qx - ay * qy - az * qz;6021    return out;6022  }6023  /**6024   * Rotates a dual quat by a given quaternion (q * a)6025   *6026   * @param {quat2} out the receiving dual quaternion6027   * @param {quat} q quaternion to rotate by6028   * @param {quat2} a the dual quaternion to rotate6029   * @returns {quat2} out6030   */6031  function rotateByQuatPrepend(out, q, a) {6032    var qx = q[0],6033        qy = q[1],6034        qz = q[2],6035        qw = q[3],6036        bx = a[0],6037        by = a[1],6038        bz = a[2],6039        bw = a[3];6040    out[0] = qx * bw + qw * bx + qy * bz - qz * by;6041    out[1] = qy * bw + qw * by + qz * bx - qx * bz;6042    out[2] = qz * bw + qw * bz + qx * by - qy * bx;6043    out[3] = qw * bw - qx * bx - qy * by - qz * bz;6044    bx = a[4];6045    by = a[5];6046    bz = a[6];6047    bw = a[7];6048    out[4] = qx * bw + qw * bx + qy * bz - qz * by;6049    out[5] = qy * bw + qw * by + qz * bx - qx * bz;6050    out[6] = qz * bw + qw * bz + qx * by - qy * bx;6051    out[7] = qw * bw - qx * bx - qy * by - qz * bz;6052    return out;6053  }6054  /**6055   * Rotates a dual quat around a given axis. Does the normalisation automatically6056   *6057   * @param {quat2} out the receiving dual quaternion6058   * @param {quat2} a the dual quaternion to rotate6059   * @param {vec3} axis the axis to rotate around6060   * @param {Number} rad how far the rotation should be6061   * @returns {quat2} out6062   */6063  function rotateAroundAxis(out, a, axis, rad) {6064    //Special case for rad = 06065    if (Math.abs(rad) < EPSILON) {6066      return copy$7(out, a);6067    }6068    var axisLength = Math.hypot(axis[0], axis[1], axis[2]);6069    rad = rad * 0.5;6070    var s = Math.sin(rad);6071    var bx = s * axis[0] / axisLength;6072    var by = s * axis[1] / axisLength;6073    var bz = s * axis[2] / axisLength;6074    var bw = Math.cos(rad);6075    var ax1 = a[0],6076        ay1 = a[1],6077        az1 = a[2],6078        aw1 = a[3];6079    out[0] = ax1 * bw + aw1 * bx + ay1 * bz - az1 * by;6080    out[1] = ay1 * bw + aw1 * by + az1 * bx - ax1 * bz;6081    out[2] = az1 * bw + aw1 * bz + ax1 * by - ay1 * bx;6082    out[3] = aw1 * bw - ax1 * bx - ay1 * by - az1 * bz;6083    var ax = a[4],6084        ay = a[5],6085        az = a[6],6086        aw = a[7];6087    out[4] = ax * bw + aw * bx + ay * bz - az * by;6088    out[5] = ay * bw + aw * by + az * bx - ax * bz;6089    out[6] = az * bw + aw * bz + ax * by - ay * bx;6090    out[7] = aw * bw - ax * bx - ay * by - az * bz;6091    return out;6092  }6093  /**6094   * Adds two dual quat's6095   *6096   * @param {quat2} out the receiving dual quaternion6097   * @param {quat2} a the first operand6098   * @param {quat2} b the second operand6099   * @returns {quat2} out6100   * @function6101   */6102  function add$7(out, a, b) {6103    out[0] = a[0] + b[0];6104    out[1] = a[1] + b[1];6105    out[2] = a[2] + b[2];6106    out[3] = a[3] + b[3];6107    out[4] = a[4] + b[4];6108    out[5] = a[5] + b[5];6109    out[6] = a[6] + b[6];6110    out[7] = a[7] + b[7];6111    return out;6112  }6113  /**6114   * Multiplies two dual quat's6115   *6116   * @param {quat2} out the receiving dual quaternion6117   * @param {quat2} a the first operand6118   * @param {quat2} b the second operand6119   * @returns {quat2} out6120   */6121  function multiply$7(out, a, b) {6122    var ax0 = a[0],6123        ay0 = a[1],6124        az0 = a[2],6125        aw0 = a[3],6126        bx1 = b[4],6127        by1 = b[5],6128        bz1 = b[6],6129        bw1 = b[7],6130        ax1 = a[4],6131        ay1 = a[5],6132        az1 = a[6],6133        aw1 = a[7],6134        bx0 = b[0],6135        by0 = b[1],6136        bz0 = b[2],6137        bw0 = b[3];6138    out[0] = ax0 * bw0 + aw0 * bx0 + ay0 * bz0 - az0 * by0;6139    out[1] = ay0 * bw0 + aw0 * by0 + az0 * bx0 - ax0 * bz0;6140    out[2] = az0 * bw0 + aw0 * bz0 + ax0 * by0 - ay0 * bx0;6141    out[3] = aw0 * bw0 - ax0 * bx0 - ay0 * by0 - az0 * bz0;6142    out[4] = ax0 * bw1 + aw0 * bx1 + ay0 * bz1 - az0 * by1 + ax1 * bw0 + aw1 * bx0 + ay1 * bz0 - az1 * by0;6143    out[5] = ay0 * bw1 + aw0 * by1 + az0 * bx1 - ax0 * bz1 + ay1 * bw0 + aw1 * by0 + az1 * bx0 - ax1 * bz0;6144    out[6] = az0 * bw1 + aw0 * bz1 + ax0 * by1 - ay0 * bx1 + az1 * bw0 + aw1 * bz0 + ax1 * by0 - ay1 * bx0;6145    out[7] = aw0 * bw1 - ax0 * bx1 - ay0 * by1 - az0 * bz1 + aw1 * bw0 - ax1 * bx0 - ay1 * by0 - az1 * bz0;6146    return out;6147  }6148  /**6149   * Alias for {@link quat2.multiply}6150   * @function6151   */6152  var mul$7 = multiply$7;6153  /**6154   * Scales a dual quat by a scalar number6155   *6156   * @param {quat2} out the receiving dual quat6157   * @param {quat2} a the dual quat to scale6158   * @param {Number} b amount to scale the dual quat by6159   * @returns {quat2} out6160   * @function6161   */6162  function scale$7(out, a, b) {6163    out[0] = a[0] * b;6164    out[1] = a[1] * b;6165    out[2] = a[2] * b;6166    out[3] = a[3] * b;6167    out[4] = a[4] * b;6168    out[5] = a[5] * b;6169    out[6] = a[6] * b;6170    out[7] = a[7] * b;6171    return out;6172  }6173  /**6174   * Calculates the dot product of two dual quat's (The dot product of the real parts)6175   *6176   * @param {quat2} a the first operand6177   * @param {quat2} b the second operand6178   * @returns {Number} dot product of a and b6179   * @function6180   */6181  var dot$3 = dot$2;6182  /**6183   * Performs a linear interpolation between two dual quats's6184   * NOTE: The resulting dual quaternions won't always be normalized (The error is most noticeable when t = 0.5)6185   *6186   * @param {quat2} out the receiving dual quat6187   * @param {quat2} a the first operand6188   * @param {quat2} b the second operand6189   * @param {Number} t interpolation amount, in the range [0-1], between the two inputs6190   * @returns {quat2} out6191   */6192  function lerp$3(out, a, b, t) {6193    var mt = 1 - t;6194    if (dot$3(a, b) < 0) t = -t;6195    out[0] = a[0] * mt + b[0] * t;6196    out[1] = a[1] * mt + b[1] * t;6197    out[2] = a[2] * mt + b[2] * t;6198    out[3] = a[3] * mt + b[3] * t;6199    out[4] = a[4] * mt + b[4] * t;6200    out[5] = a[5] * mt + b[5] * t;6201    out[6] = a[6] * mt + b[6] * t;6202    out[7] = a[7] * mt + b[7] * t;6203    return out;6204  }6205  /**6206   * Calculates the inverse of a dual quat. If they are normalized, conjugate is cheaper6207   *6208   * @param {quat2} out the receiving dual quaternion6209   * @param {quat2} a dual quat to calculate inverse of6210   * @returns {quat2} out6211   */6212  function invert$5(out, a) {6213    var sqlen = squaredLength$3(a);6214    out[0] = -a[0] / sqlen;6215    out[1] = -a[1] / sqlen;6216    out[2] = -a[2] / sqlen;6217    out[3] = a[3] / sqlen;6218    out[4] = -a[4] / sqlen;6219    out[5] = -a[5] / sqlen;6220    out[6] = -a[6] / sqlen;6221    out[7] = a[7] / sqlen;6222    return out;6223  }6224  /**6225   * Calculates the conjugate of a dual quat6226   * If the dual quaternion is normalized, this function is faster than quat2.inverse and produces the same result.6227   *6228   * @param {quat2} out the receiving quaternion6229   * @param {quat2} a quat to calculate conjugate of6230   * @returns {quat2} out6231   */6232  function conjugate$1(out, a) {6233    out[0] = -a[0];6234    out[1] = -a[1];6235    out[2] = -a[2];6236    out[3] = a[3];6237    out[4] = -a[4];6238    out[5] = -a[5];6239    out[6] = -a[6];6240    out[7] = a[7];6241    return out;6242  }6243  /**6244   * Calculates the length of a dual quat6245   *6246   * @param {quat2} a dual quat to calculate length of6247   * @returns {Number} length of a6248   * @function6249   */6250  var length$3 = length$2;6251  /**6252   * Alias for {@link quat2.length}6253   * @function6254   */6255  var len$3 = length$3;6256  /**6257   * Calculates the squared length of a dual quat6258   *6259   * @param {quat2} a dual quat to calculate squared length of6260   * @returns {Number} squared length of a6261   * @function6262   */6263  var squaredLength$3 = squaredLength$2;6264  /**6265   * Alias for {@link quat2.squaredLength}6266   * @function6267   */6268  var sqrLen$3 = squaredLength$3;6269  /**6270   * Normalize a dual quat6271   *6272   * @param {quat2} out the receiving dual quaternion6273   * @param {quat2} a dual quaternion to normalize6274   * @returns {quat2} out6275   * @function6276   */6277  function normalize$3(out, a) {6278    var magnitude = squaredLength$3(a);6279    if (magnitude > 0) {6280      magnitude = Math.sqrt(magnitude);6281      var a0 = a[0] / magnitude;6282      var a1 = a[1] / magnitude;6283      var a2 = a[2] / magnitude;6284      var a3 = a[3] / magnitude;6285      var b0 = a[4];6286      var b1 = a[5];6287      var b2 = a[6];6288      var b3 = a[7];6289      var a_dot_b = a0 * b0 + a1 * b1 + a2 * b2 + a3 * b3;6290      out[0] = a0;6291      out[1] = a1;6292      out[2] = a2;6293      out[3] = a3;6294      out[4] = (b0 - a0 * a_dot_b) / magnitude;6295      out[5] = (b1 - a1 * a_dot_b) / magnitude;6296      out[6] = (b2 - a2 * a_dot_b) / magnitude;6297      out[7] = (b3 - a3 * a_dot_b) / magnitude;6298    }6299    return out;6300  }6301  /**6302   * Returns a string representation of a dual quatenion6303   *6304   * @param {quat2} a dual quaternion to represent as a string6305   * @returns {String} string representation of the dual quat6306   */6307  function str$7(a) {6308    return 'quat2(' + a[0] + ', ' + a[1] + ', ' + a[2] + ', ' + a[3] + ', ' + a[4] + ', ' + a[5] + ', ' + a[6] + ', ' + a[7] + ')';6309  }6310  /**6311   * Returns whether or not the dual quaternions have exactly the same elements in the same position (when compared with ===)6312   *6313   * @param {quat2} a the first dual quaternion.6314   * @param {quat2} b the second dual quaternion.6315   * @returns {Boolean} true if the dual quaternions are equal, false otherwise.6316   */6317  function exactEquals$7(a, b) {6318    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];6319  }6320  /**6321   * Returns whether or not the dual quaternions have approximately the same elements in the same position.6322   *6323   * @param {quat2} a the first dual quat.6324   * @param {quat2} b the second dual quat.6325   * @returns {Boolean} true if the dual quats are equal, false otherwise.6326   */6327  function equals$8(a, b) {6328    var a0 = a[0],6329        a1 = a[1],6330        a2 = a[2],6331        a3 = a[3],6332        a4 = a[4],6333        a5 = a[5],6334        a6 = a[6],6335        a7 = a[7];6336    var b0 = b[0],6337        b1 = b[1],6338        b2 = b[2],6339        b3 = b[3],6340        b4 = b[4],6341        b5 = b[5],6342        b6 = b[6],6343        b7 = b[7];6344    return Math.abs(a0 - b0) <= EPSILON * Math.max(1.0, Math.abs(a0), Math.abs(b0)) && Math.abs(a1 - b1) <= EPSILON * Math.max(1.0, Math.abs(a1), Math.abs(b1)) && Math.abs(a2 - b2) <= EPSILON * Math.max(1.0, Math.abs(a2), Math.abs(b2)) && Math.abs(a3 - b3) <= EPSILON * Math.max(1.0, Math.abs(a3), Math.abs(b3)) && Math.abs(a4 - b4) <= EPSILON * Math.max(1.0, Math.abs(a4), Math.abs(b4)) && Math.abs(a5 - b5) <= EPSILON * Math.max(1.0, Math.abs(a5), Math.abs(b5)) && Math.abs(a6 - b6) <= EPSILON * Math.max(1.0, Math.abs(a6), Math.abs(b6)) && Math.abs(a7 - b7) <= EPSILON * Math.max(1.0, Math.abs(a7), Math.abs(b7));6345  }6346  var quat2 = /*#__PURE__*/Object.freeze({6347    create: create$7,6348    clone: clone$7,6349    fromValues: fromValues$7,6350    fromRotationTranslationValues: fromRotationTranslationValues,6351    fromRotationTranslation: fromRotationTranslation$1,6352    fromTranslation: fromTranslation$3,6353    fromRotation: fromRotation$4,6354    fromMat4: fromMat4$1,6355    copy: copy$7,6356    identity: identity$5,6357    set: set$7,6358    getReal: getReal,6359    getDual: getDual,6360    setReal: setReal,6361    setDual: setDual,6362    getTranslation: getTranslation$1,6363    translate: translate$3,6364    rotateX: rotateX$3,6365    rotateY: rotateY$3,6366    rotateZ: rotateZ$3,6367    rotateByQuatAppend: rotateByQuatAppend,6368    rotateByQuatPrepend: rotateByQuatPrepend,6369    rotateAroundAxis: rotateAroundAxis,6370    add: add$7,6371    multiply: multiply$7,6372    mul: mul$7,6373    scale: scale$7,6374    dot: dot$3,6375    lerp: lerp$3,6376    invert: invert$5,6377    conjugate: conjugate$1,6378    length: length$3,6379    len: len$3,6380    squaredLength: squaredLength$3,6381    sqrLen: sqrLen$3,6382    normalize: normalize$3,6383    str: str$7,6384    exactEquals: exactEquals$7,6385    equals: equals$86386  });6387  /**6388   * 2 Dimensional Vector6389   * @module vec26390   */6391  /**6392   * Creates a new, empty vec26393   *6394   * @returns {vec2} a new 2D vector6395   */6396  function create$8() {6397    var out = new ARRAY_TYPE(2);6398    if (ARRAY_TYPE != Float32Array) {6399      out[0] = 0;6400      out[1] = 0;6401    }6402    return out;6403  }6404  /**6405   * Creates a new vec2 initialized with values from an existing vector6406   *6407   * @param {vec2} a vector to clone6408   * @returns {vec2} a new 2D vector6409   */6410  function clone$8(a) {6411    var out = new ARRAY_TYPE(2);6412    out[0] = a[0];6413    out[1] = a[1];6414    return out;6415  }6416  /**6417   * Creates a new vec2 initialized with the given values6418   *6419   * @param {Number} x X component6420   * @param {Number} y Y component6421   * @returns {vec2} a new 2D vector6422   */6423  function fromValues$8(x, y) {6424    var out = new ARRAY_TYPE(2);6425    out[0] = x;6426    out[1] = y;6427    return out;6428  }6429  /**6430   * Copy the values from one vec2 to another6431   *6432   * @param {vec2} out the receiving vector6433   * @param {vec2} a the source vector6434   * @returns {vec2} out6435   */6436  function copy$8(out, a) {6437    out[0] = a[0];6438    out[1] = a[1];6439    return out;6440  }6441  /**6442   * Set the components of a vec2 to the given values6443   *6444   * @param {vec2} out the receiving vector6445   * @param {Number} x X component6446   * @param {Number} y Y component6447   * @returns {vec2} out6448   */6449  function set$8(out, x, y) {6450    out[0] = x;6451    out[1] = y;6452    return out;6453  }6454  /**6455   * Adds two vec2's6456   *6457   * @param {vec2} out the receiving vector6458   * @param {vec2} a the first operand6459   * @param {vec2} b the second operand6460   * @returns {vec2} out6461   */6462  function add$8(out, a, b) {6463    out[0] = a[0] + b[0];6464    out[1] = a[1] + b[1];6465    return out;6466  }6467  /**6468   * Subtracts vector b from vector a6469   *6470   * @param {vec2} out the receiving vector6471   * @param {vec2} a the first operand6472   * @param {vec2} b the second operand6473   * @returns {vec2} out6474   */6475  function subtract$6(out, a, b) {6476    out[0] = a[0] - b[0];6477    out[1] = a[1] - b[1];6478    return out;6479  }6480  /**6481   * Multiplies two vec2's6482   *6483   * @param {vec2} out the receiving vector6484   * @param {vec2} a the first operand6485   * @param {vec2} b the second operand6486   * @returns {vec2} out6487   */6488  function multiply$8(out, a, b) {6489    out[0] = a[0] * b[0];6490    out[1] = a[1] * b[1];6491    return out;6492  }6493  /**6494   * Divides two vec2's6495   *6496   * @param {vec2} out the receiving vector6497   * @param {vec2} a the first operand6498   * @param {vec2} b the second operand6499   * @returns {vec2} out6500   */6501  function divide$2(out, a, b) {6502    out[0] = a[0] / b[0];6503    out[1] = a[1] / b[1];6504    return out;6505  }6506  /**6507   * Math.ceil the components of a vec26508   *6509   * @param {vec2} out the receiving vector6510   * @param {vec2} a vector to ceil6511   * @returns {vec2} out6512   */6513  function ceil$2(out, a) {6514    out[0] = Math.ceil(a[0]);6515    out[1] = Math.ceil(a[1]);6516    return out;6517  }6518  /**6519   * Math.floor the components of a vec26520   *6521   * @param {vec2} out the receiving vector6522   * @param {vec2} a vector to floor6523   * @returns {vec2} out6524   */6525  function floor$2(out, a) {6526    out[0] = Math.floor(a[0]);6527    out[1] = Math.floor(a[1]);6528    return out;6529  }6530  /**6531   * Returns the minimum of two vec2's6532   *6533   * @param {vec2} out the receiving vector6534   * @param {vec2} a the first operand6535   * @param {vec2} b the second operand6536   * @returns {vec2} out6537   */6538  function min$2(out, a, b) {6539    out[0] = Math.min(a[0], b[0]);6540    out[1] = Math.min(a[1], b[1]);6541    return out;6542  }6543  /**6544   * Returns the maximum of two vec2's6545   *6546   * @param {vec2} out the receiving vector6547   * @param {vec2} a the first operand6548   * @param {vec2} b the second operand6549   * @returns {vec2} out6550   */6551  function max$2(out, a, b) {6552    out[0] = Math.max(a[0], b[0]);6553    out[1] = Math.max(a[1], b[1]);6554    return out;6555  }6556  /**6557   * Math.round the components of a vec26558   *6559   * @param {vec2} out the receiving vector6560   * @param {vec2} a vector to round6561   * @returns {vec2} out6562   */6563  function round$2(out, a) {6564    out[0] = Math.round(a[0]);6565    out[1] = Math.round(a[1]);6566    return out;6567  }6568  /**6569   * Scales a vec2 by a scalar number6570   *6571   * @param {vec2} out the receiving vector6572   * @param {vec2} a the vector to scale6573   * @param {Number} b amount to scale the vector by6574   * @returns {vec2} out6575   */6576  function scale$8(out, a, b) {6577    out[0] = a[0] * b;6578    out[1] = a[1] * b;6579    return out;6580  }6581  /**6582   * Adds two vec2's after scaling the second operand by a scalar value6583   *6584   * @param {vec2} out the receiving vector6585   * @param {vec2} a the first operand6586   * @param {vec2} b the second operand6587   * @param {Number} scale the amount to scale b by before adding6588   * @returns {vec2} out6589   */6590  function scaleAndAdd$2(out, a, b, scale) {6591    out[0] = a[0] + b[0] * scale;6592    out[1] = a[1] + b[1] * scale;6593    return out;6594  }6595  /**6596   * Calculates the euclidian distance between two vec2's6597   *6598   * @param {vec2} a the first operand6599   * @param {vec2} b the second operand6600   * @returns {Number} distance between a and b6601   */6602  function distance$2(a, b) {6603    var x = b[0] - a[0],6604        y = b[1] - a[1];6605    return Math.hypot(x, y);6606  }6607  /**6608   * Calculates the squared euclidian distance between two vec2's6609   *6610   * @param {vec2} a the first operand6611   * @param {vec2} b the second operand6612   * @returns {Number} squared distance between a and b6613   */6614  function squaredDistance$2(a, b) {6615    var x = b[0] - a[0],6616        y = b[1] - a[1];6617    return x * x + y * y;6618  }6619  /**6620   * Calculates the length of a vec26621   *6622   * @param {vec2} a vector to calculate length of6623   * @returns {Number} length of a6624   */6625  function length$4(a) {6626    var x = a[0],6627        y = a[1];6628    return Math.hypot(x, y);6629  }6630  /**6631   * Calculates the squared length of a vec26632   *6633   * @param {vec2} a vector to calculate squared length of6634   * @returns {Number} squared length of a6635   */6636  function squaredLength$4(a) {6637    var x = a[0],6638        y = a[1];6639    return x * x + y * y;6640  }6641  /**6642   * Negates the components of a vec26643   *6644   * @param {vec2} out the receiving vector6645   * @param {vec2} a vector to negate6646   * @returns {vec2} out6647   */6648  function negate$2(out, a) {6649    out[0] = -a[0];6650    out[1] = -a[1];6651    return out;6652  }6653  /**6654   * Returns the inverse of the components of a vec26655   *6656   * @param {vec2} out the receiving vector6657   * @param {vec2} a vector to invert6658   * @returns {vec2} out6659   */6660  function inverse$2(out, a) {6661    out[0] = 1.0 / a[0];6662    out[1] = 1.0 / a[1];6663    return out;6664  }6665  /**6666   * Normalize a vec26667   *6668   * @param {vec2} out the receiving vector6669   * @param {vec2} a vector to normalize6670   * @returns {vec2} out6671   */6672  function normalize$4(out, a) {6673    var x = a[0],6674        y = a[1];6675    var len = x * x + y * y;6676    if (len > 0) {6677      //TODO: evaluate use of glm_invsqrt here?6678      len = 1 / Math.sqrt(len);6679    }6680    out[0] = a[0] * len;6681    out[1] = a[1] * len;6682    return out;6683  }6684  /**6685   * Calculates the dot product of two vec2's6686   *6687   * @param {vec2} a the first operand6688   * @param {vec2} b the second operand6689   * @returns {Number} dot product of a and b6690   */6691  function dot$4(a, b) {6692    return a[0] * b[0] + a[1] * b[1];6693  }6694  /**6695   * Computes the cross product of two vec2's6696   * Note that the cross product must by definition produce a 3D vector6697   *6698   * @param {vec3} out the receiving vector6699   * @param {vec2} a the first operand6700   * @param {vec2} b the second operand6701   * @returns {vec3} out6702   */6703  function cross$2(out, a, b) {6704    var z = a[0] * b[1] - a[1] * b[0];6705    out[0] = out[1] = 0;6706    out[2] = z;6707    return out;6708  }6709  /**6710   * Performs a linear interpolation between two vec2's6711   *6712   * @param {vec2} out the receiving vector6713   * @param {vec2} a the first operand6714   * @param {vec2} b the second operand6715   * @param {Number} t interpolation amount, in the range [0-1], between the two inputs6716   * @returns {vec2} out6717   */6718  function lerp$4(out, a, b, t) {6719    var ax = a[0],6720        ay = a[1];6721    out[0] = ax + t * (b[0] - ax);6722    out[1] = ay + t * (b[1] - ay);6723    return out;6724  }6725  /**6726   * Generates a random vector with the given scale6727   *6728   * @param {vec2} out the receiving vector6729   * @param {Number} [scale] Length of the resulting vector. If ommitted, a unit vector will be returned6730   * @returns {vec2} out6731   */6732  function random$3(out, scale) {6733    scale = scale || 1.0;6734    var r = RANDOM() * 2.0 * Math.PI;6735    out[0] = Math.cos(r) * scale;6736    out[1] = Math.sin(r) * scale;6737    return out;6738  }6739  /**6740   * Transforms the vec2 with a mat26741   *6742   * @param {vec2} out the receiving vector6743   * @param {vec2} a the vector to transform6744   * @param {mat2} m matrix to transform with6745   * @returns {vec2} out6746   */6747  function transformMat2(out, a, m) {6748    var x = a[0],6749        y = a[1];6750    out[0] = m[0] * x + m[2] * y;6751    out[1] = m[1] * x + m[3] * y;6752    return out;6753  }6754  /**6755   * Transforms the vec2 with a mat2d6756   *6757   * @param {vec2} out the receiving vector6758   * @param {vec2} a the vector to transform6759   * @param {mat2d} m matrix to transform with6760   * @returns {vec2} out6761   */6762  function transformMat2d(out, a, m) {6763    var x = a[0],6764        y = a[1];6765    out[0] = m[0] * x + m[2] * y + m[4];6766    out[1] = m[1] * x + m[3] * y + m[5];6767    return out;6768  }6769  /**6770   * Transforms the vec2 with a mat36771   * 3rd vector component is implicitly '1'6772   *6773   * @param {vec2} out the receiving vector6774   * @param {vec2} a the vector to transform6775   * @param {mat3} m matrix to transform with6776   * @returns {vec2} out6777   */6778  function transformMat3$1(out, a, m) {6779    var x = a[0],6780        y = a[1];6781    out[0] = m[0] * x + m[3] * y + m[6];6782    out[1] = m[1] * x + m[4] * y + m[7];6783    return out;6784  }6785  /**6786   * Transforms the vec2 with a mat46787   * 3rd vector component is implicitly '0'6788   * 4th vector component is implicitly '1'6789   *6790   * @param {vec2} out the receiving vector6791   * @param {vec2} a the vector to transform6792   * @param {mat4} m matrix to transform with6793   * @returns {vec2} out6794   */6795  function transformMat4$2(out, a, m) {6796    var x = a[0];6797    var y = a[1];6798    out[0] = m[0] * x + m[4] * y + m[12];6799    out[1] = m[1] * x + m[5] * y + m[13];6800    return out;6801  }6802  /**6803   * Rotate a 2D vector6804   * @param {vec2} out The receiving vec26805   * @param {vec2} a The vec2 point to rotate6806   * @param {vec2} b The origin of the rotation6807   * @param {Number} c The angle of rotation6808   * @returns {vec2} out6809   */6810  function rotate$4(out, a, b, c) {6811    //Translate point to the origin6812    var p0 = a[0] - b[0],6813        p1 = a[1] - b[1],6814        sinC = Math.sin(c),6815        cosC = Math.cos(c); //perform rotation and translate to correct position6816    out[0] = p0 * cosC - p1 * sinC + b[0];6817    out[1] = p0 * sinC + p1 * cosC + b[1];6818    return out;6819  }6820  /**6821   * Get the angle between two 2D vectors6822   * @param {vec2} a The first operand6823   * @param {vec2} b The second operand6824   * @returns {Number} The angle in radians6825   */6826  function angle$1(a, b) {6827    var x1 = a[0],6828        y1 = a[1],6829        x2 = b[0],6830        y2 = b[1];6831    var len1 = x1 * x1 + y1 * y1;6832    if (len1 > 0) {6833      //TODO: evaluate use of glm_invsqrt here?6834      len1 = 1 / Math.sqrt(len1);6835    }6836    var len2 = x2 * x2 + y2 * y2;6837    if (len2 > 0) {6838      //TODO: evaluate use of glm_invsqrt here?6839      len2 = 1 / Math.sqrt(len2);6840    }6841    var cosine = (x1 * x2 + y1 * y2) * len1 * len2;6842    if (cosine > 1.0) {6843      return 0;6844    } else if (cosine < -1.0) {6845      return Math.PI;6846    } else {6847      return Math.acos(cosine);6848    }6849  }6850  /**6851   * Set the components of a vec2 to zero6852   *6853   * @param {vec2} out the receiving vector6854   * @returns {vec2} out6855   */6856  function zero$2(out) {6857    out[0] = 0.0;6858    out[1] = 0.0;6859    return out;6860  }6861  /**6862   * Returns a string representation of a vector6863   *6864   * @param {vec2} a vector to represent as a string6865   * @returns {String} string representation of the vector6866   */6867  function str$8(a) {6868    return 'vec2(' + a[0] + ', ' + a[1] + ')';6869  }6870  /**6871   * Returns whether or not the vectors exactly have the same elements in the same position (when compared with ===)6872   *6873   * @param {vec2} a The first vector.6874   * @param {vec2} b The second vector.6875   * @returns {Boolean} True if the vectors are equal, false otherwise.6876   */6877  function exactEquals$8(a, b) {6878    return a[0] === b[0] && a[1] === b[1];6879  }6880  /**6881   * Returns whether or not the vectors have approximately the same elements in the same position.6882   *6883   * @param {vec2} a The first vector.6884   * @param {vec2} b The second vector.6885   * @returns {Boolean} True if the vectors are equal, false otherwise.6886   */6887  function equals$9(a, b) {6888    var a0 = a[0],6889        a1 = a[1];6890    var b0 = b[0],6891        b1 = b[1];6892    return Math.abs(a0 - b0) <= EPSILON * Math.max(1.0, Math.abs(a0), Math.abs(b0)) && Math.abs(a1 - b1) <= EPSILON * Math.max(1.0, Math.abs(a1), Math.abs(b1));6893  }6894  /**6895   * Alias for {@link vec2.length}6896   * @function6897   */6898  var len$4 = length$4;6899  /**6900   * Alias for {@link vec2.subtract}6901   * @function6902   */6903  var sub$6 = subtract$6;6904  /**6905   * Alias for {@link vec2.multiply}6906   * @function6907   */6908  var mul$8 = multiply$8;6909  /**6910   * Alias for {@link vec2.divide}6911   * @function6912   */6913  var div$2 = divide$2;6914  /**6915   * Alias for {@link vec2.distance}6916   * @function6917   */6918  var dist$2 = distance$2;6919  /**6920   * Alias for {@link vec2.squaredDistance}6921   * @function6922   */6923  var sqrDist$2 = squaredDistance$2;6924  /**6925   * Alias for {@link vec2.squaredLength}6926   * @function6927   */6928  var sqrLen$4 = squaredLength$4;6929  /**6930   * Perform some operation over an array of vec2s.6931   *6932   * @param {Array} a the array of vectors to iterate over6933   * @param {Number} stride Number of elements between the start of each vec2. If 0 assumes tightly packed6934   * @param {Number} offset Number of elements to skip at the beginning of the array6935   * @param {Number} count Number of vec2s to iterate over. If 0 iterates over entire array6936   * @param {Function} fn Function to call for each vector in the array6937   * @param {Object} [arg] additional argument to pass to fn6938   * @returns {Array} a6939   * @function6940   */6941  var forEach$2 = function () {6942    var vec = create$8();6943    return function (a, stride, offset, count, fn, arg) {6944      var i, l;6945      if (!stride) {6946        stride = 2;6947      }6948      if (!offset) {6949        offset = 0;6950      }6951      if (count) {6952        l = Math.min(count * stride + offset, a.length);6953      } else {6954        l = a.length;6955      }6956      for (i = offset; i < l; i += stride) {6957        vec[0] = a[i];6958        vec[1] = a[i + 1];6959        fn(vec, vec, arg);6960        a[i] = vec[0];6961        a[i + 1] = vec[1];6962      }6963      return a;6964    };6965  }();6966  var vec2 = /*#__PURE__*/Object.freeze({6967    create: create$8,6968    clone: clone$8,6969    fromValues: fromValues$8,6970    copy: copy$8,6971    set: set$8,6972    add: add$8,6973    subtract: subtract$6,6974    multiply: multiply$8,6975    divide: divide$2,6976    ceil: ceil$2,6977    floor: floor$2,6978    min: min$2,6979    max: max$2,6980    round: round$2,6981    scale: scale$8,6982    scaleAndAdd: scaleAndAdd$2,6983    distance: distance$2,6984    squaredDistance: squaredDistance$2,6985    length: length$4,6986    squaredLength: squaredLength$4,6987    negate: negate$2,6988    inverse: inverse$2,6989    normalize: normalize$4,6990    dot: dot$4,6991    cross: cross$2,6992    lerp: lerp$4,6993    random: random$3,6994    transformMat2: transformMat2,6995    transformMat2d: transformMat2d,6996    transformMat3: transformMat3$1,6997    transformMat4: transformMat4$2,6998    rotate: rotate$4,6999    angle: angle$1,7000    zero: zero$2,7001    str: str$8,7002    exactEquals: exactEquals$8,7003    equals: equals$9,7004    len: len$4,7005    sub: sub$6,7006    mul: mul$8,7007    div: div$2,7008    dist: dist$2,7009    sqrDist: sqrDist$2,7010    sqrLen: sqrLen$4,7011    forEach: forEach$27012  });7013  exports.glMatrix = common;7014  exports.mat2 = mat2;7015  exports.mat2d = mat2d;7016  exports.mat3 = mat3;7017  exports.mat4 = mat4;7018  exports.quat = quat;7019  exports.quat2 = quat2;7020  exports.vec2 = vec2;7021  exports.vec3 = vec3;7022  exports.vec4 = vec4;7023  Object.defineProperty(exports, '__esModule', { value: true });...

glmatrix.js

Source:glmatrix.js

1/**2 * @fileoverview gl-matrix - High performance matrix and vector operations3 * @author Brandon Jones4 * @author Colin MacKenzie IV5 * @version 2.1.06 */7/* Copyright (c) 2013, Brandon Jones, Colin MacKenzie IV. All rights reserved.8Redistribution and use in source and binary forms, with or without modification,9are permitted provided that the following conditions are met:10  * Redistributions of source code must retain the above copyright notice, this11    list of conditions and the following disclaimer.12  * Redistributions in binary form must reproduce the above copyright notice,13    this list of conditions and the following disclaimer in the documentation 14    and/or other materials provided with the distribution.15THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND16ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED17WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 18DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR19ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES20(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;21LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON22ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT23(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS24SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */25(function() {26    "use strict";27    var shim = {};28    if (typeof(exports) === 'undefined') {29        if (typeof define == 'function' && typeof define.amd == 'object' && define.amd) {30            shim.exports = {};31            define(function() {32                return shim.exports;33            });34        } else {35            // gl-matrix lives in a browser, define its namespaces in global36            shim.exports = window;37        }38    } else {39        // gl-matrix lives in commonjs, define its namespaces in exports40        shim.exports = exports;41    }42    (function(exports) {43        /* Copyright (c) 2013, Brandon Jones, Colin MacKenzie IV. All rights reserved.44Redistribution and use in source and binary forms, with or without modification,45are permitted provided that the following conditions are met:46  * Redistributions of source code must retain the above copyright notice, this47    list of conditions and the following disclaimer.48  * Redistributions in binary form must reproduce the above copyright notice,49    this list of conditions and the following disclaimer in the documentation 50    and/or other materials provided with the distribution.51THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND52ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED53WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 54DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR55ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES56(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;57LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON58ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT59(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS60SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */61        if (!GLMAT_EPSILON) {62            var GLMAT_EPSILON = 0.000001;63        }64        if (!GLMAT_ARRAY_TYPE) {65            var GLMAT_ARRAY_TYPE = (typeof Float32Array !== 'undefined') ? Float32Array : Array;66        }67        /**68         * @class Common utilities69         * @name glMatrix70         */71        var glMatrix = {};72        /**73         * Sets the type of array used when creating new vectors and matricies74         *75         * @param {Type} type Array type, such as Float32Array or Array76         */77        glMatrix.setMatrixArrayType = function(type) {78            GLMAT_ARRAY_TYPE = type;79        }80        if (typeof(exports) !== 'undefined') {81            exports.glMatrix = glMatrix;82        };83        /* Copyright (c) 2013, Brandon Jones, Colin MacKenzie IV. All rights reserved.84Redistribution and use in source and binary forms, with or without modification,85are permitted provided that the following conditions are met:86  * Redistributions of source code must retain the above copyright notice, this87    list of conditions and the following disclaimer.88  * Redistributions in binary form must reproduce the above copyright notice,89    this list of conditions and the following disclaimer in the documentation 90    and/or other materials provided with the distribution.91THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND92ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED93WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 94DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR95ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES96(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;97LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON98ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT99(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS100SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */101        /**102         * @class 2 Dimensional Vector103         * @name vec2104         */105        var vec2 = {};106        /**107         * Creates a new, empty vec2108         *109         * @returns {vec2} a new 2D vector110         */111        vec2.create = function() {112            var out = new GLMAT_ARRAY_TYPE(2);113            out[0] = 0;114            out[1] = 0;115            return out;116        };117        /**118         * Creates a new vec2 initialized with values from an existing vector119         *120         * @param {vec2} a vector to clone121         * @returns {vec2} a new 2D vector122         */123        vec2.clone = function(a) {124            var out = new GLMAT_ARRAY_TYPE(2);125            out[0] = a[0];126            out[1] = a[1];127            return out;128        };129        /**130         * Creates a new vec2 initialized with the given values131         *132         * @param {Number} x X component133         * @param {Number} y Y component134         * @returns {vec2} a new 2D vector135         */136        vec2.fromValues = function(x, y) {137            var out = new GLMAT_ARRAY_TYPE(2);138            out[0] = x;139            out[1] = y;140            return out;141        };142        /**143         * Copy the values from one vec2 to another144         *145         * @param {vec2} out the receiving vector146         * @param {vec2} a the source vector147         * @returns {vec2} out148         */149        vec2.copy = function(out, a) {150            out[0] = a[0];151            out[1] = a[1];152            return out;153        };154        /**155         * Set the components of a vec2 to the given values156         *157         * @param {vec2} out the receiving vector158         * @param {Number} x X component159         * @param {Number} y Y component160         * @returns {vec2} out161         */162        vec2.set = function(out, x, y) {163            out[0] = x;164            out[1] = y;165            return out;166        };167        /**168         * Adds two vec2's169         *170         * @param {vec2} out the receiving vector171         * @param {vec2} a the first operand172         * @param {vec2} b the second operand173         * @returns {vec2} out174         */175        vec2.add = function(out, a, b) {176            out[0] = a[0] + b[0];177            out[1] = a[1] + b[1];178            return out;179        };180        /**181         * Subtracts two vec2's182         *183         * @param {vec2} out the receiving vector184         * @param {vec2} a the first operand185         * @param {vec2} b the second operand186         * @returns {vec2} out187         */188        vec2.subtract = function(out, a, b) {189            out[0] = a[0] - b[0];190            out[1] = a[1] - b[1];191            return out;192        };193        /**194         * Alias for {@link vec2.subtract}195         * @function196         */197        vec2.sub = vec2.subtract;198        /**199         * Multiplies two vec2's200         *201         * @param {vec2} out the receiving vector202         * @param {vec2} a the first operand203         * @param {vec2} b the second operand204         * @returns {vec2} out205         */206        vec2.multiply = function(out, a, b) {207            out[0] = a[0] * b[0];208            out[1] = a[1] * b[1];209            return out;210        };211        /**212         * Alias for {@link vec2.multiply}213         * @function214         */215        vec2.mul = vec2.multiply;216        /**217         * Divides two vec2's218         *219         * @param {vec2} out the receiving vector220         * @param {vec2} a the first operand221         * @param {vec2} b the second operand222         * @returns {vec2} out223         */224        vec2.divide = function(out, a, b) {225            out[0] = a[0] / b[0];226            out[1] = a[1] / b[1];227            return out;228        };229        /**230         * Alias for {@link vec2.divide}231         * @function232         */233        vec2.div = vec2.divide;234        /**235         * Returns the minimum of two vec2's236         *237         * @param {vec2} out the receiving vector238         * @param {vec2} a the first operand239         * @param {vec2} b the second operand240         * @returns {vec2} out241         */242        vec2.min = function(out, a, b) {243            out[0] = Math.min(a[0], b[0]);244            out[1] = Math.min(a[1], b[1]);245            return out;246        };247        /**248         * Returns the maximum of two vec2's249         *250         * @param {vec2} out the receiving vector251         * @param {vec2} a the first operand252         * @param {vec2} b the second operand253         * @returns {vec2} out254         */255        vec2.max = function(out, a, b) {256            out[0] = Math.max(a[0], b[0]);257            out[1] = Math.max(a[1], b[1]);258            return out;259        };260        /**261         * Scales a vec2 by a scalar number262         *263         * @param {vec2} out the receiving vector264         * @param {vec2} a the vector to scale265         * @param {Number} b amount to scale the vector by266         * @returns {vec2} out267         */268        vec2.scale = function(out, a, b) {269            out[0] = a[0] * b;270            out[1] = a[1] * b;271            return out;272        };273        /**274         * Calculates the euclidian distance between two vec2's275         *276         * @param {vec2} a the first operand277         * @param {vec2} b the second operand278         * @returns {Number} distance between a and b279         */280        vec2.distance = function(a, b) {281            var x = b[0] - a[0],282                y = b[1] - a[1];283            return Math.sqrt(x * x + y * y);284        };285        /**286         * Alias for {@link vec2.distance}287         * @function288         */289        vec2.dist = vec2.distance;290        /**291         * Calculates the squared euclidian distance between two vec2's292         *293         * @param {vec2} a the first operand294         * @param {vec2} b the second operand295         * @returns {Number} squared distance between a and b296         */297        vec2.squaredDistance = function(a, b) {298            var x = b[0] - a[0],299                y = b[1] - a[1];300            return x * x + y * y;301        };302        /**303         * Alias for {@link vec2.squaredDistance}304         * @function305         */306        vec2.sqrDist = vec2.squaredDistance;307        /**308         * Calculates the length of a vec2309         *310         * @param {vec2} a vector to calculate length of311         * @returns {Number} length of a312         */313        vec2.length = function(a) {314            var x = a[0],315                y = a[1];316            return Math.sqrt(x * x + y * y);317        };318        /**319         * Alias for {@link vec2.length}320         * @function321         */322        vec2.len = vec2.length;323        /**324         * Calculates the squared length of a vec2325         *326         * @param {vec2} a vector to calculate squared length of327         * @returns {Number} squared length of a328         */329        vec2.squaredLength = function(a) {330            var x = a[0],331                y = a[1];332            return x * x + y * y;333        };334        /**335         * Alias for {@link vec2.squaredLength}336         * @function337         */338        vec2.sqrLen = vec2.squaredLength;339        /**340         * Negates the components of a vec2341         *342         * @param {vec2} out the receiving vector343         * @param {vec2} a vector to negate344         * @returns {vec2} out345         */346        vec2.negate = function(out, a) {347            out[0] = -a[0];348            out[1] = -a[1];349            return out;350        };351        /**352         * Normalize a vec2353         *354         * @param {vec2} out the receiving vector355         * @param {vec2} a vector to normalize356         * @returns {vec2} out357         */358        vec2.normalize = function(out, a) {359            var x = a[0],360                y = a[1];361            var len = x * x + y * y;362            if (len > 0) {363                //TODO: evaluate use of glm_invsqrt here?364                len = 1 / Math.sqrt(len);365                out[0] = a[0] * len;366                out[1] = a[1] * len;367            }368            return out;369        };370        /**371         * Calculates the dot product of two vec2's372         *373         * @param {vec2} a the first operand374         * @param {vec2} b the second operand375         * @returns {Number} dot product of a and b376         */377        vec2.dot = function(a, b) {378            return a[0] * b[0] + a[1] * b[1];379        };380        /**381         * Computes the cross product of two vec2's382         * Note that the cross product must by definition produce a 3D vector383         *384         * @param {vec3} out the receiving vector385         * @param {vec2} a the first operand386         * @param {vec2} b the second operand387         * @returns {vec3} out388         */389        vec2.cross = function(out, a, b) {390            var z = a[0] * b[1] - a[1] * b[0];391            out[0] = out[1] = 0;392            out[2] = z;393            return out;394        };395        /**396         * Performs a linear interpolation between two vec2's397         *398         * @param {vec2} out the receiving vector399         * @param {vec2} a the first operand400         * @param {vec2} b the second operand401         * @param {Number} t interpolation amount between the two inputs402         * @returns {vec2} out403         */404        vec2.lerp = function(out, a, b, t) {405            var ax = a[0],406                ay = a[1];407            out[0] = ax + t * (b[0] - ax);408            out[1] = ay + t * (b[1] - ay);409            return out;410        };411        /**412         * Transforms the vec2 with a mat2413         *414         * @param {vec2} out the receiving vector415         * @param {vec2} a the vector to transform416         * @param {mat2} m matrix to transform with417         * @returns {vec2} out418         */419        vec2.transformMat2 = function(out, a, m) {420            var x = a[0],421                y = a[1];422            out[0] = m[0] * x + m[2] * y;423            out[1] = m[1] * x + m[3] * y;424            return out;425        };426        /**427         * Transforms the vec2 with a mat2d428         *429         * @param {vec2} out the receiving vector430         * @param {vec2} a the vector to transform431         * @param {mat2d} m matrix to transform with432         * @returns {vec2} out433         */434        vec2.transformMat2d = function(out, a, m) {435            var x = a[0],436                y = a[1];437            out[0] = m[0] * x + m[2] * y + m[4];438            out[1] = m[1] * x + m[3] * y + m[5];439            return out;440        };441        /**442         * Transforms the vec2 with a mat3443         * 3rd vector component is implicitly '1'444         *445         * @param {vec2} out the receiving vector446         * @param {vec2} a the vector to transform447         * @param {mat3} m matrix to transform with448         * @returns {vec2} out449         */450        vec2.transformMat3 = function(out, a, m) {451            var x = a[0],452                y = a[1];453            out[0] = m[0] * x + m[3] * y + m[6];454            out[1] = m[1] * x + m[4] * y + m[7];455            return out;456        };457        /**458         * Transforms the vec2 with a mat4459         * 3rd vector component is implicitly '0'460         * 4th vector component is implicitly '1'461         *462         * @param {vec2} out the receiving vector463         * @param {vec2} a the vector to transform464         * @param {mat4} m matrix to transform with465         * @returns {vec2} out466         */467        vec2.transformMat4 = function(out, a, m) {468            var x = a[0],469                y = a[1];470            out[0] = m[0] * x + m[4] * y + m[12];471            out[1] = m[1] * x + m[5] * y + m[13];472            return out;473        };474        /**475         * Perform some operation over an array of vec2s.476         *477         * @param {Array} a the array of vectors to iterate over478         * @param {Number} stride Number of elements between the start of each vec2. If 0 assumes tightly packed479         * @param {Number} offset Number of elements to skip at the beginning of the array480         * @param {Number} count Number of vec2s to iterate over. If 0 iterates over entire array481         * @param {Function} fn Function to call for each vector in the array482         * @param {Object} [arg] additional argument to pass to fn483         * @returns {Array} a484         * @function485         */486        vec2.forEach = (function() {487            var vec = vec2.create();488            return function(a, stride, offset, count, fn, arg) {489                var i, l;490                if (!stride) {491                    stride = 2;492                }493                if (!offset) {494                    offset = 0;495                }496                if (count) {497                    l = Math.min((count * stride) + offset, a.length);498                } else {499                    l = a.length;500                }501                for (i = offset; i < l; i += stride) {502                    vec[0] = a[i];503                    vec[1] = a[i + 1];504                    fn(vec, vec, arg);505                    a[i] = vec[0];506                    a[i + 1] = vec[1];507                }508                return a;509            };510        })();511        /**512         * Returns a string representation of a vector513         *514         * @param {vec2} vec vector to represent as a string515         * @returns {String} string representation of the vector516         */517        vec2.str = function(a) {518            return 'vec2(' + a[0] + ', ' + a[1] + ')';519        };520        if (typeof(exports) !== 'undefined') {521            exports.vec2 = vec2;522        };523        /* Copyright (c) 2013, Brandon Jones, Colin MacKenzie IV. All rights reserved.524Redistribution and use in source and binary forms, with or without modification,525are permitted provided that the following conditions are met:526  * Redistributions of source code must retain the above copyright notice, this527    list of conditions and the following disclaimer.528  * Redistributions in binary form must reproduce the above copyright notice,529    this list of conditions and the following disclaimer in the documentation 530    and/or other materials provided with the distribution.531THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND532ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED533WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 534DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR535ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES536(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;537LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON538ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT539(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS540SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */541        /**542         * @class 3 Dimensional Vector543         * @name vec3544         */545        var vec3 = {};546        /**547         * Creates a new, empty vec3548         *549         * @returns {vec3} a new 3D vector550         */551        vec3.create = function() {552            var out = new GLMAT_ARRAY_TYPE(3);553            out[0] = 0;554            out[1] = 0;555            out[2] = 0;556            return out;557        };558        /**559         * Creates a new vec3 initialized with values from an existing vector560         *561         * @param {vec3} a vector to clone562         * @returns {vec3} a new 3D vector563         */564        vec3.clone = function(a) {565            var out = new GLMAT_ARRAY_TYPE(3);566            out[0] = a[0];567            out[1] = a[1];568            out[2] = a[2];569            return out;570        };571        /**572         * Creates a new vec3 initialized with the given values573         *574         * @param {Number} x X component575         * @param {Number} y Y component576         * @param {Number} z Z component577         * @returns {vec3} a new 3D vector578         */579        vec3.fromValues = function(x, y, z) {580            var out = new GLMAT_ARRAY_TYPE(3);581            out[0] = x;582            out[1] = y;583            out[2] = z;584            return out;585        };586        /**587         * Copy the values from one vec3 to another588         *589         * @param {vec3} out the receiving vector590         * @param {vec3} a the source vector591         * @returns {vec3} out592         */593        vec3.copy = function(out, a) {594            out[0] = a[0];595            out[1] = a[1];596            out[2] = a[2];597            return out;598        };599        /**600         * Set the components of a vec3 to the given values601         *602         * @param {vec3} out the receiving vector603         * @param {Number} x X component604         * @param {Number} y Y component605         * @param {Number} z Z component606         * @returns {vec3} out607         */608        vec3.set = function(out, x, y, z) {609            out[0] = x;610            out[1] = y;611            out[2] = z;612            return out;613        };614        /**615         * Adds two vec3's616         *617         * @param {vec3} out the receiving vector618         * @param {vec3} a the first operand619         * @param {vec3} b the second operand620         * @returns {vec3} out621         */622        vec3.add = function(out, a, b) {623            out[0] = a[0] + b[0];624            out[1] = a[1] + b[1];625            out[2] = a[2] + b[2];626            return out;627        };628        /**629         * Subtracts two vec3's630         *631         * @param {vec3} out the receiving vector632         * @param {vec3} a the first operand633         * @param {vec3} b the second operand634         * @returns {vec3} out635         */636        vec3.subtract = function(out, a, b) {637            out[0] = a[0] - b[0];638            out[1] = a[1] - b[1];639            out[2] = a[2] - b[2];640            return out;641        };642        /**643         * Alias for {@link vec3.subtract}644         * @function645         */646        vec3.sub = vec3.subtract;647        /**648         * Multiplies two vec3's649         *650         * @param {vec3} out the receiving vector651         * @param {vec3} a the first operand652         * @param {vec3} b the second operand653         * @returns {vec3} out654         */655        vec3.multiply = function(out, a, b) {656            out[0] = a[0] * b[0];657            out[1] = a[1] * b[1];658            out[2] = a[2] * b[2];659            return out;660        };661        /**662         * Alias for {@link vec3.multiply}663         * @function664         */665        vec3.mul = vec3.multiply;666        /**667         * Divides two vec3's668         *669         * @param {vec3} out the receiving vector670         * @param {vec3} a the first operand671         * @param {vec3} b the second operand672         * @returns {vec3} out673         */674        vec3.divide = function(out, a, b) {675            out[0] = a[0] / b[0];676            out[1] = a[1] / b[1];677            out[2] = a[2] / b[2];678            return out;679        };680        /**681         * Alias for {@link vec3.divide}682         * @function683         */684        vec3.div = vec3.divide;685        /**686         * Returns the minimum of two vec3's687         *688         * @param {vec3} out the receiving vector689         * @param {vec3} a the first operand690         * @param {vec3} b the second operand691         * @returns {vec3} out692         */693        vec3.min = function(out, a, b) {694            out[0] = Math.min(a[0], b[0]);695            out[1] = Math.min(a[1], b[1]);696            out[2] = Math.min(a[2], b[2]);697            return out;698        };699        /**700         * Returns the maximum of two vec3's701         *702         * @param {vec3} out the receiving vector703         * @param {vec3} a the first operand704         * @param {vec3} b the second operand705         * @returns {vec3} out706         */707        vec3.max = function(out, a, b) {708            out[0] = Math.max(a[0], b[0]);709            out[1] = Math.max(a[1], b[1]);710            out[2] = Math.max(a[2], b[2]);711            return out;712        };713        /**714         * Scales a vec3 by a scalar number715         *716         * @param {vec3} out the receiving vector717         * @param {vec3} a the vector to scale718         * @param {Number} b amount to scale the vector by719         * @returns {vec3} out720         */721        vec3.scale = function(out, a, b) {722            out[0] = a[0] * b;723            out[1] = a[1] * b;724            out[2] = a[2] * b;725            return out;726        };727        /**728         * Calculates the euclidian distance between two vec3's729         *730         * @param {vec3} a the first operand731         * @param {vec3} b the second operand732         * @returns {Number} distance between a and b733         */734        vec3.distance = function(a, b) {735            var x = b[0] - a[0],736                y = b[1] - a[1],737                z = b[2] - a[2];738            return Math.sqrt(x * x + y * y + z * z);739        };740        /**741         * Alias for {@link vec3.distance}742         * @function743         */744        vec3.dist = vec3.distance;745        /**746         * Calculates the squared euclidian distance between two vec3's747         *748         * @param {vec3} a the first operand749         * @param {vec3} b the second operand750         * @returns {Number} squared distance between a and b751         */752        vec3.squaredDistance = function(a, b) {753            var x = b[0] - a[0],754                y = b[1] - a[1],755                z = b[2] - a[2];756            return x * x + y * y + z * z;757        };758        /**759         * Alias for {@link vec3.squaredDistance}760         * @function761         */762        vec3.sqrDist = vec3.squaredDistance;763        /**764         * Calculates the length of a vec3765         *766         * @param {vec3} a vector to calculate length of767         * @returns {Number} length of a768         */769        vec3.length = function(a) {770            var x = a[0],771                y = a[1],772                z = a[2];773            return Math.sqrt(x * x + y * y + z * z);774        };775        /**776         * Alias for {@link vec3.length}777         * @function778         */779        vec3.len = vec3.length;780        /**781         * Calculates the squared length of a vec3782         *783         * @param {vec3} a vector to calculate squared length of784         * @returns {Number} squared length of a785         */786        vec3.squaredLength = function(a) {787            var x = a[0],788                y = a[1],789                z = a[2];790            return x * x + y * y + z * z;791        };792        /**793         * Alias for {@link vec3.squaredLength}794         * @function795         */796        vec3.sqrLen = vec3.squaredLength;797        /**798         * Negates the components of a vec3799         *800         * @param {vec3} out the receiving vector801         * @param {vec3} a vector to negate802         * @returns {vec3} out803         */804        vec3.negate = function(out, a) {805            out[0] = -a[0];806            out[1] = -a[1];807            out[2] = -a[2];808            return out;809        };810        /**811         * Normalize a vec3812         *813         * @param {vec3} out the receiving vector814         * @param {vec3} a vector to normalize815         * @returns {vec3} out816         */817        vec3.normalize = function(out, a) {818            var x = a[0],819                y = a[1],820                z = a[2];821            var len = x * x + y * y + z * z;822            if (len > 0) {823                //TODO: evaluate use of glm_invsqrt here?824                len = 1 / Math.sqrt(len);825                out[0] = a[0] * len;826                out[1] = a[1] * len;827                out[2] = a[2] * len;828            }829            return out;830        };831        /**832         * Calculates the dot product of two vec3's833         *834         * @param {vec3} a the first operand835         * @param {vec3} b the second operand836         * @returns {Number} dot product of a and b837         */838        vec3.dot = function(a, b) {839            return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];840        };841        /**842         * Computes the cross product of two vec3's843         *844         * @param {vec3} out the receiving vector845         * @param {vec3} a the first operand846         * @param {vec3} b the second operand847         * @returns {vec3} out848         */849        vec3.cross = function(out, a, b) {850            var ax = a[0],851                ay = a[1],852                az = a[2],853                bx = b[0],854                by = b[1],855                bz = b[2];856            out[0] = ay * bz - az * by;857            out[1] = az * bx - ax * bz;858            out[2] = ax * by - ay * bx;859            return out;860        };861        /**862         * Performs a linear interpolation between two vec3's863         *864         * @param {vec3} out the receiving vector865         * @param {vec3} a the first operand866         * @param {vec3} b the second operand867         * @param {Number} t interpolation amount between the two inputs868         * @returns {vec3} out869         */870        vec3.lerp = function(out, a, b, t) {871            var ax = a[0],872                ay = a[1],873                az = a[2];874            out[0] = ax + t * (b[0] - ax);875            out[1] = ay + t * (b[1] - ay);876            out[2] = az + t * (b[2] - az);877            return out;878        };879        /**880         * Transforms the vec3 with a mat4.881         * 4th vector component is implicitly '1'882         *883         * @param {vec3} out the receiving vector884         * @param {vec3} a the vector to transform885         * @param {mat4} m matrix to transform with886         * @returns {vec3} out887         */888        vec3.transformMat4 = function(out, a, m) {889            var x = a[0],890                y = a[1],891                z = a[2];892            out[0] = m[0] * x + m[4] * y + m[8] * z + m[12];893            out[1] = m[1] * x + m[5] * y + m[9] * z + m[13];894            out[2] = m[2] * x + m[6] * y + m[10] * z + m[14];895            return out;896        };897        /**898         * Transforms the vec3 with a quat899         *900         * @param {vec3} out the receiving vector901         * @param {vec3} a the vector to transform902         * @param {quat} q quaternion to transform with903         * @returns {vec3} out904         */905        vec3.transformQuat = function(out, a, q) {906            var x = a[0],907                y = a[1],908                z = a[2],909                qx = q[0],910                qy = q[1],911                qz = q[2],912                qw = q[3],913                // calculate quat * vec914                ix = qw * x + qy * z - qz * y,915                iy = qw * y + qz * x - qx * z,916                iz = qw * z + qx * y - qy * x,917                iw = -qx * x - qy * y - qz * z;918            // calculate result * inverse quat919            out[0] = ix * qw + iw * -qx + iy * -qz - iz * -qy;920            out[1] = iy * qw + iw * -qy + iz * -qx - ix * -qz;921            out[2] = iz * qw + iw * -qz + ix * -qy - iy * -qx;922            return out;923        };924        /**925         * Perform some operation over an array of vec3s.926         *927         * @param {Array} a the array of vectors to iterate over928         * @param {Number} stride Number of elements between the start of each vec3. If 0 assumes tightly packed929         * @param {Number} offset Number of elements to skip at the beginning of the array930         * @param {Number} count Number of vec3s to iterate over. If 0 iterates over entire array931         * @param {Function} fn Function to call for each vector in the array932         * @param {Object} [arg] additional argument to pass to fn933         * @returns {Array} a934         * @function935         */936        vec3.forEach = (function() {937            var vec = vec3.create();938            return function(a, stride, offset, count, fn, arg) {939                var i, l;940                if (!stride) {941                    stride = 3;942                }943                if (!offset) {944                    offset = 0;945                }946                if (count) {947                    l = Math.min((count * stride) + offset, a.length);948                } else {949                    l = a.length;950                }951                for (i = offset; i < l; i += stride) {952                    vec[0] = a[i];953                    vec[1] = a[i + 1];954                    vec[2] = a[i + 2];955                    fn(vec, vec, arg);956                    a[i] = vec[0];957                    a[i + 1] = vec[1];958                    a[i + 2] = vec[2];959                }960                return a;961            };962        })();963        /**964         * Returns a string representation of a vector965         *966         * @param {vec3} vec vector to represent as a string967         * @returns {String} string representation of the vector968         */969        vec3.str = function(a) {970            return 'vec3(' + a[0] + ', ' + a[1] + ', ' + a[2] + ')';971        };972        if (typeof(exports) !== 'undefined') {973            exports.vec3 = vec3;974        };975        /* Copyright (c) 2013, Brandon Jones, Colin MacKenzie IV. All rights reserved.976Redistribution and use in source and binary forms, with or without modification,977are permitted provided that the following conditions are met:978  * Redistributions of source code must retain the above copyright notice, this979    list of conditions and the following disclaimer.980  * Redistributions in binary form must reproduce the above copyright notice,981    this list of conditions and the following disclaimer in the documentation 982    and/or other materials provided with the distribution.983THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND984ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED985WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 986DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR987ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES988(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;989LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON990ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT991(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS992SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */993        /**994         * @class 4 Dimensional Vector995         * @name vec4996         */997        var vec4 = {};998        /**999         * Creates a new, empty vec41000         *1001         * @returns {vec4} a new 4D vector1002         */1003        vec4.create = function() {1004            var out = new GLMAT_ARRAY_TYPE(4);1005            out[0] = 0;1006            out[1] = 0;1007            out[2] = 0;1008            out[3] = 0;1009            return out;1010        };1011        /**1012         * Creates a new vec4 initialized with values from an existing vector1013         *1014         * @param {vec4} a vector to clone1015         * @returns {vec4} a new 4D vector1016         */1017        vec4.clone = function(a) {1018            var out = new GLMAT_ARRAY_TYPE(4);1019            out[0] = a[0];1020            out[1] = a[1];1021            out[2] = a[2];1022            out[3] = a[3];1023            return out;1024        };1025        /**1026         * Creates a new vec4 initialized with the given values1027         *1028         * @param {Number} x X component1029         * @param {Number} y Y component1030         * @param {Number} z Z component1031         * @param {Number} w W component1032         * @returns {vec4} a new 4D vector1033         */1034        vec4.fromValues = function(x, y, z, w) {1035            var out = new GLMAT_ARRAY_TYPE(4);1036            out[0] = x;1037            out[1] = y;1038            out[2] = z;1039            out[3] = w;1040            return out;1041        };1042        /**1043         * Copy the values from one vec4 to another1044         *1045         * @param {vec4} out the receiving vector1046         * @param {vec4} a the source vector1047         * @returns {vec4} out1048         */1049        vec4.copy = function(out, a) {1050            out[0] = a[0];1051            out[1] = a[1];1052            out[2] = a[2];1053            out[3] = a[3];1054            return out;1055        };1056        /**1057         * Set the components of a vec4 to the given values1058         *1059         * @param {vec4} out the receiving vector1060         * @param {Number} x X component1061         * @param {Number} y Y component1062         * @param {Number} z Z component1063         * @param {Number} w W component1064         * @returns {vec4} out1065         */1066        vec4.set = function(out, x, y, z, w) {1067            out[0] = x;1068            out[1] = y;1069            out[2] = z;1070            out[3] = w;1071            return out;1072        };1073        /**1074         * Adds two vec4's1075         *1076         * @param {vec4} out the receiving vector1077         * @param {vec4} a the first operand1078         * @param {vec4} b the second operand1079         * @returns {vec4} out1080         */1081        vec4.add = function(out, a, b) {1082            out[0] = a[0] + b[0];1083            out[1] = a[1] + b[1];1084            out[2] = a[2] + b[2];1085            out[3] = a[3] + b[3];1086            return out;1087        };1088        /**1089         * Subtracts two vec4's1090         *1091         * @param {vec4} out the receiving vector1092         * @param {vec4} a the first operand1093         * @param {vec4} b the second operand1094         * @returns {vec4} out1095         */1096        vec4.subtract = function(out, a, b) {1097            out[0] = a[0] - b[0];1098            out[1] = a[1] - b[1];1099            out[2] = a[2] - b[2];1100            out[3] = a[3] - b[3];1101            return out;1102        };1103        /**1104         * Alias for {@link vec4.subtract}1105         * @function1106         */1107        vec4.sub = vec4.subtract;1108        /**1109         * Multiplies two vec4's1110         *1111         * @param {vec4} out the receiving vector1112         * @param {vec4} a the first operand1113         * @param {vec4} b the second operand1114         * @returns {vec4} out1115         */1116        vec4.multiply = function(out, a, b) {1117            out[0] = a[0] * b[0];1118            out[1] = a[1] * b[1];1119            out[2] = a[2] * b[2];1120            out[3] = a[3] * b[3];1121            return out;1122        };1123        /**1124         * Alias for {@link vec4.multiply}1125         * @function1126         */1127        vec4.mul = vec4.multiply;1128        /**1129         * Divides two vec4's1130         *1131         * @param {vec4} out the receiving vector1132         * @param {vec4} a the first operand1133         * @param {vec4} b the second operand1134         * @returns {vec4} out1135         */1136        vec4.divide = function(out, a, b) {1137            out[0] = a[0] / b[0];1138            out[1] = a[1] / b[1];1139            out[2] = a[2] / b[2];1140            out[3] = a[3] / b[3];1141            return out;1142        };1143        /**1144         * Alias for {@link vec4.divide}1145         * @function1146         */1147        vec4.div = vec4.divide;1148        /**1149         * Returns the minimum of two vec4's1150         *1151         * @param {vec4} out the receiving vector1152         * @param {vec4} a the first operand1153         * @param {vec4} b the second operand1154         * @returns {vec4} out1155         */1156        vec4.min = function(out, a, b) {1157            out[0] = Math.min(a[0], b[0]);1158            out[1] = Math.min(a[1], b[1]);1159            out[2] = Math.min(a[2], b[2]);1160            out[3] = Math.min(a[3], b[3]);1161            return out;1162        };1163        /**1164         * Returns the maximum of two vec4's1165         *1166         * @param {vec4} out the receiving vector1167         * @param {vec4} a the first operand1168         * @param {vec4} b the second operand1169         * @returns {vec4} out1170         */1171        vec4.max = function(out, a, b) {1172            out[0] = Math.max(a[0], b[0]);1173            out[1] = Math.max(a[1], b[1]);1174            out[2] = Math.max(a[2], b[2]);1175            out[3] = Math.max(a[3], b[3]);1176            return out;1177        };1178        /**1179         * Scales a vec4 by a scalar number1180         *1181         * @param {vec4} out the receiving vector1182         * @param {vec4} a the vector to scale1183         * @param {Number} b amount to scale the vector by1184         * @returns {vec4} out1185         */1186        vec4.scale = function(out, a, b) {1187            out[0] = a[0] * b;1188            out[1] = a[1] * b;1189            out[2] = a[2] * b;1190            out[3] = a[3] * b;1191            return out;1192        };1193        /**1194         * Calculates the euclidian distance between two vec4's1195         *1196         * @param {vec4} a the first operand1197         * @param {vec4} b the second operand1198         * @returns {Number} distance between a and b1199         */1200        vec4.distance = function(a, b) {1201            var x = b[0] - a[0],1202                y = b[1] - a[1],1203                z = b[2] - a[2],1204                w = b[3] - a[3];1205            return Math.sqrt(x * x + y * y + z * z + w * w);1206        };1207        /**1208         * Alias for {@link vec4.distance}1209         * @function1210         */1211        vec4.dist = vec4.distance;1212        /**1213         * Calculates the squared euclidian distance between two vec4's1214         *1215         * @param {vec4} a the first operand1216         * @param {vec4} b the second operand1217         * @returns {Number} squared distance between a and b1218         */1219        vec4.squaredDistance = function(a, b) {1220            var x = b[0] - a[0],1221                y = b[1] - a[1],1222                z = b[2] - a[2],1223                w = b[3] - a[3];1224            return x * x + y * y + z * z + w * w;1225        };1226        /**1227         * Alias for {@link vec4.squaredDistance}1228         * @function1229         */1230        vec4.sqrDist = vec4.squaredDistance;1231        /**1232         * Calculates the length of a vec41233         *1234         * @param {vec4} a vector to calculate length of1235         * @returns {Number} length of a1236         */1237        vec4.length = function(a) {1238            var x = a[0],1239                y = a[1],1240                z = a[2],1241                w = a[3];1242            return Math.sqrt(x * x + y * y + z * z + w * w);1243        };1244        /**1245         * Alias for {@link vec4.length}1246         * @function1247         */1248        vec4.len = vec4.length;1249        /**1250         * Calculates the squared length of a vec41251         *1252         * @param {vec4} a vector to calculate squared length of1253         * @returns {Number} squared length of a1254         */1255        vec4.squaredLength = function(a) {1256            var x = a[0],1257                y = a[1],1258                z = a[2],1259                w = a[3];1260            return x * x + y * y + z * z + w * w;1261        };1262        /**1263         * Alias for {@link vec4.squaredLength}1264         * @function1265         */1266        vec4.sqrLen = vec4.squaredLength;1267        /**1268         * Negates the components of a vec41269         *1270         * @param {vec4} out the receiving vector1271         * @param {vec4} a vector to negate1272         * @returns {vec4} out1273         */1274        vec4.negate = function(out, a) {1275            out[0] = -a[0];1276            out[1] = -a[1];1277            out[2] = -a[2];1278            out[3] = -a[3];1279            return out;1280        };1281        /**1282         * Normalize a vec41283         *1284         * @param {vec4} out the receiving vector1285         * @param {vec4} a vector to normalize1286         * @returns {vec4} out1287         */1288        vec4.normalize = function(out, a) {1289            var x = a[0],1290                y = a[1],1291                z = a[2],1292                w = a[3];1293            var len = x * x + y * y + z * z + w * w;1294            if (len > 0) {1295                len = 1 / Math.sqrt(len);1296                out[0] = a[0] * len;1297                out[1] = a[1] * len;1298                out[2] = a[2] * len;1299                out[3] = a[3] * len;1300            }1301            return out;1302        };1303        /**1304         * Calculates the dot product of two vec4's1305         *1306         * @param {vec4} a the first operand1307         * @param {vec4} b the second operand1308         * @returns {Number} dot product of a and b1309         */1310        vec4.dot = function(a, b) {1311            return a[0] * b[0] + a[1] * b[1] + a[2] * b[2] + a[3] * b[3];1312        };1313        /**1314         * Performs a linear interpolation between two vec4's1315         *1316         * @param {vec4} out the receiving vector1317         * @param {vec4} a the first operand1318         * @param {vec4} b the second operand1319         * @param {Number} t interpolation amount between the two inputs1320         * @returns {vec4} out1321         */1322        vec4.lerp = function(out, a, b, t) {1323            var ax = a[0],1324                ay = a[1],1325                az = a[2],1326                aw = a[3];1327            out[0] = ax + t * (b[0] - ax);1328            out[1] = ay + t * (b[1] - ay);1329            out[2] = az + t * (b[2] - az);1330            out[3] = aw + t * (b[3] - aw);1331            return out;1332        };1333        /**1334         * Transforms the vec4 with a mat4.1335         *1336         * @param {vec4} out the receiving vector1337         * @param {vec4} a the vector to transform1338         * @param {mat4} m matrix to transform with1339         * @returns {vec4} out1340         */1341        vec4.transformMat4 = function(out, a, m) {1342            var x = a[0],1343                y = a[1],1344                z = a[2],1345                w = a[3];1346            out[0] = m[0] * x + m[4] * y + m[8] * z + m[12] * w;1347            out[1] = m[1] * x + m[5] * y + m[9] * z + m[13] * w;1348            out[2] = m[2] * x + m[6] * y + m[10] * z + m[14] * w;1349            out[3] = m[3] * x + m[7] * y + m[11] * z + m[15] * w;1350            return out;1351        };1352        /**1353         * Transforms the vec4 with a quat1354         *1355         * @param {vec4} out the receiving vector1356         * @param {vec4} a the vector to transform1357         * @param {quat} q quaternion to transform with1358         * @returns {vec4} out1359         */1360        vec4.transformQuat = function(out, a, q) {1361            var x = a[0],1362                y = a[1],1363                z = a[2],1364                qx = q[0],1365                qy = q[1],1366                qz = q[2],1367                qw = q[3],1368                // calculate quat * vec1369                ix = qw * x + qy * z - qz * y,1370                iy = qw * y + qz * x - qx * z,1371                iz = qw * z + qx * y - qy * x,1372                iw = -qx * x - qy * y - qz * z;1373            // calculate result * inverse quat1374            out[0] = ix * qw + iw * -qx + iy * -qz - iz * -qy;1375            out[1] = iy * qw + iw * -qy + iz * -qx - ix * -qz;1376            out[2] = iz * qw + iw * -qz + ix * -qy - iy * -qx;1377            return out;1378        };1379        /**1380         * Perform some operation over an array of vec4s.1381         *1382         * @param {Array} a the array of vectors to iterate over1383         * @param {Number} stride Number of elements between the start of each vec4. If 0 assumes tightly packed1384         * @param {Number} offset Number of elements to skip at the beginning of the array1385         * @param {Number} count Number of vec2s to iterate over. If 0 iterates over entire array1386         * @param {Function} fn Function to call for each vector in the array1387         * @param {Object} [arg] additional argument to pass to fn1388         * @returns {Array} a1389         * @function1390         */1391        vec4.forEach = (function() {1392            var vec = vec4.create();1393            return function(a, stride, offset, count, fn, arg) {1394                var i, l;1395                if (!stride) {1396                    stride = 4;1397                }1398                if (!offset) {1399                    offset = 0;1400                }1401                if (count) {1402                    l = Math.min((count * stride) + offset, a.length);1403                } else {1404                    l = a.length;1405                }1406                for (i = offset; i < l; i += stride) {1407                    vec[0] = a[i];1408                    vec[1] = a[i + 1];1409                    vec[2] = a[i + 2];1410                    vec[3] = a[i + 3];1411                    fn(vec, vec, arg);1412                    a[i] = vec[0];1413                    a[i + 1] = vec[1];1414                    a[i + 2] = vec[2];1415                    a[i + 3] = vec[3];1416                }1417                return a;1418            };1419        })();1420        /**1421         * Returns a string representation of a vector1422         *1423         * @param {vec4} vec vector to represent as a string1424         * @returns {String} string representation of the vector1425         */1426        vec4.str = function(a) {1427            return 'vec4(' + a[0] + ', ' + a[1] + ', ' + a[2] + ', ' + a[3] + ')';1428        };1429        if (typeof(exports) !== 'undefined') {1430            exports.vec4 = vec4;1431        };1432        /* Copyright (c) 2013, Brandon Jones, Colin MacKenzie IV. All rights reserved.1433Redistribution and use in source and binary forms, with or without modification,1434are permitted provided that the following conditions are met:1435  * Redistributions of source code must retain the above copyright notice, this1436    list of conditions and the following disclaimer.1437  * Redistributions in binary form must reproduce the above copyright notice,1438    this list of conditions and the following disclaimer in the documentation 1439    and/or other materials provided with the distribution.1440THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND1441ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED1442WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 1443DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR1444ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES1445(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;1446LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON1447ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT1448(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS1449SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */1450        /**1451         * @class 2x2 Matrix1452         * @name mat21453         */1454        var mat2 = {};1455        var mat2Identity = new Float32Array([1456            1, 0,1457            0, 11458        ]);1459        /**1460         * Creates a new identity mat21461         *1462         * @returns {mat2} a new 2x2 matrix1463         */1464        mat2.create = function() {1465            var out = new GLMAT_ARRAY_TYPE(4);1466            out[0] = 1;1467            out[1] = 0;1468            out[2] = 0;1469            out[3] = 1;1470            return out;1471        };1472        /**1473         * Creates a new mat2 initialized with values from an existing matrix1474         *1475         * @param {mat2} a matrix to clone1476         * @returns {mat2} a new 2x2 matrix1477         */1478        mat2.clone = function(a) {1479            var out = new GLMAT_ARRAY_TYPE(4);1480            out[0] = a[0];1481            out[1] = a[1];1482            out[2] = a[2];1483            out[3] = a[3];1484            return out;1485        };1486        /**1487         * Copy the values from one mat2 to another1488         *1489         * @param {mat2} out the receiving matrix1490         * @param {mat2} a the source matrix1491         * @returns {mat2} out1492         */1493        mat2.copy = function(out, a) {1494            out[0] = a[0];1495            out[1] = a[1];1496            out[2] = a[2];1497            out[3] = a[3];1498            return out;1499        };1500        /**1501         * Set a mat2 to the identity matrix1502         *1503         * @param {mat2} out the receiving matrix1504         * @returns {mat2} out1505         */1506        mat2.identity = function(out) {1507            out[0] = 1;1508            out[1] = 0;1509            out[2] = 0;1510            out[3] = 1;1511            return out;1512        };1513        /**1514         * Transpose the values of a mat21515         *1516         * @param {mat2} out the receiving matrix1517         * @param {mat2} a the source matrix1518         * @returns {mat2} out1519         */1520        mat2.transpose = function(out, a) {1521            // If we are transposing ourselves we can skip a few steps but have to cache some values1522            if (out === a) {1523                var a1 = a[1];1524                out[1] = a[2];1525                out[2] = a1;1526            } else {1527                out[0] = a[0];1528                out[1] = a[2];1529                out[2] = a[1];1530                out[3] = a[3];1531            }1532            return out;1533        };1534        /**1535         * Inverts a mat21536         *1537         * @param {mat2} out the receiving matrix1538         * @param {mat2} a the source matrix1539         * @returns {mat2} out1540         */1541        mat2.invert = function(out, a) {1542            var a0 = a[0],1543                a1 = a[1],1544                a2 = a[2],1545                a3 = a[3],1546                // Calculate the determinant1547                det = a0 * a3 - a2 * a1;1548            if (!det) {1549                return null;1550            }1551            det = 1.0 / det;1552            out[0] = a3 * det;1553            out[1] = -a1 * det;1554            out[2] = -a2 * det;1555            out[3] = a0 * det;1556            return out;1557        };1558        /**1559         * Calculates the adjugate of a mat21560         *1561         * @param {mat2} out the receiving matrix1562         * @param {mat2} a the source matrix1563         * @returns {mat2} out1564         */1565        mat2.adjoint = function(out, a) {1566            // Caching this value is nessecary if out == a1567            var a0 = a[0];1568            out[0] = a[3];1569            out[1] = -a[1];1570            out[2] = -a[2];1571            out[3] = a0;1572            return out;1573        };1574        /**1575         * Calculates the determinant of a mat21576         *1577         * @param {mat2} a the source matrix1578         * @returns {Number} determinant of a1579         */1580        mat2.determinant = function(a) {1581            return a[0] * a[3] - a[2] * a[1];1582        };1583        /**1584         * Multiplies two mat2's1585         *1586         * @param {mat2} out the receiving matrix1587         * @param {mat2} a the first operand1588         * @param {mat2} b the second operand1589         * @returns {mat2} out1590         */1591        mat2.multiply = function(out, a, b) {1592            var a0 = a[0],1593                a1 = a[1],1594                a2 = a[2],1595                a3 = a[3];1596            var b0 = b[0],1597                b1 = b[1],1598                b2 = b[2],1599                b3 = b[3];1600            out[0] = a0 * b0 + a1 * b2;1601            out[1] = a0 * b1 + a1 * b3;1602            out[2] = a2 * b0 + a3 * b2;1603            out[3] = a2 * b1 + a3 * b3;1604            return out;1605        };1606        /**1607         * Alias for {@link mat2.multiply}1608         * @function1609         */1610        mat2.mul = mat2.multiply;1611        /**1612         * Rotates a mat2 by the given angle1613         *1614         * @param {mat2} out the receiving matrix1615         * @param {mat2} a the matrix to rotate1616         * @param {Number} rad the angle to rotate the matrix by1617         * @returns {mat2} out1618         */1619        mat2.rotate = function(out, a, rad) {1620            var a0 = a[0],1621                a1 = a[1],1622                a2 = a[2],1623                a3 = a[3],1624                s = Math.sin(rad),1625                c = Math.cos(rad);1626            out[0] = a0 * c + a1 * s;1627            out[1] = a0 * -s + a1 * c;1628            out[2] = a2 * c + a3 * s;1629            out[3] = a2 * -s + a3 * c;1630            return out;1631        };1632        /**1633         * Scales the mat2 by the dimensions in the given vec21634         *1635         * @param {mat2} out the receiving matrix1636         * @param {mat2} a the matrix to rotate1637         * @param {vec2} v the vec2 to scale the matrix by1638         * @returns {mat2} out1639         **/1640        mat2.scale = function(out, a, v) {1641            var a0 = a[0],1642                a1 = a[1],1643                a2 = a[2],1644                a3 = a[3],1645                v0 = v[0],1646                v1 = v[1];1647            out[0] = a0 * v0;1648            out[1] = a1 * v1;1649            out[2] = a2 * v0;1650            out[3] = a3 * v1;1651            return out;1652        };1653        /**1654         * Returns a string representation of a mat21655         *1656         * @param {mat2} mat matrix to represent as a string1657         * @returns {String} string representation of the matrix1658         */1659        mat2.str = function(a) {1660            return 'mat2(' + a[0] + ', ' + a[1] + ', ' + a[2] + ', ' + a[3] + ')';1661        };1662        if (typeof(exports) !== 'undefined') {1663            exports.mat2 = mat2;1664        };1665        /* Copyright (c) 2013, Brandon Jones, Colin MacKenzie IV. All rights reserved.1666Redistribution and use in source and binary forms, with or without modification,1667are permitted provided that the following conditions are met:1668  * Redistributions of source code must retain the above copyright notice, this1669    list of conditions and the following disclaimer.1670  * Redistributions in binary form must reproduce the above copyright notice,1671    this list of conditions and the following disclaimer in the documentation 1672    and/or other materials provided with the distribution.1673THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND1674ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED1675WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 1676DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR1677ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES1678(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;1679LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON1680ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT1681(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS1682SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */1683        /**1684         * @class 2x3 Matrix1685         * @name mat2d1686         *1687         * @description1688         * A mat2d contains six elements defined as:1689         * <pre>1690         * [a, b,1691         *  c, d,1692         *  tx,ty]1693         * </pre>1694         * This is a short form for the 3x3 matrix:1695         * <pre>1696         * [a, b, 01697         *  c, d, 01698         *  tx,ty,1]1699         * </pre>1700         * The last column is ignored so the array is shorter and operations are faster.1701         */1702        var mat2d = {};1703        var mat2dIdentity = new Float32Array([1704            1, 0,1705            0, 1,1706            0, 01707        ]);1708        /**1709         * Creates a new identity mat2d1710         *1711         * @returns {mat2d} a new 2x3 matrix1712         */1713        mat2d.create = function() {1714            var out = new GLMAT_ARRAY_TYPE(6);1715            out[0] = 1;1716            out[1] = 0;1717            out[2] = 0;1718            out[3] = 1;1719            out[4] = 0;1720            out[5] = 0;1721            return out;1722        };1723        /**1724         * Creates a new mat2d initialized with values from an existing matrix1725         *1726         * @param {mat2d} a matrix to clone1727         * @returns {mat2d} a new 2x3 matrix1728         */1729        mat2d.clone = function(a) {1730            var out = new GLMAT_ARRAY_TYPE(6);1731            out[0] = a[0];1732            out[1] = a[1];1733            out[2] = a[2];1734            out[3] = a[3];1735            out[4] = a[4];1736            out[5] = a[5];1737            return out;1738        };1739        /**1740         * Copy the values from one mat2d to another1741         *1742         * @param {mat2d} out the receiving matrix1743         * @param {mat2d} a the source matrix1744         * @returns {mat2d} out1745         */1746        mat2d.copy = function(out, a) {1747            out[0] = a[0];1748            out[1] = a[1];1749            out[2] = a[2];1750            out[3] = a[3];1751            out[4] = a[4];1752            out[5] = a[5];1753            return out;1754        };1755        /**1756         * Set a mat2d to the identity matrix1757         *1758         * @param {mat2d} out the receiving matrix1759         * @returns {mat2d} out1760         */1761        mat2d.identity = function(out) {1762            out[0] = 1;1763            out[1] = 0;1764            out[2] = 0;1765            out[3] = 1;1766            out[4] = 0;1767            out[5] = 0;1768            return out;1769        };1770        /**1771         * Inverts a mat2d1772         *1773         * @param {mat2d} out the receiving matrix1774         * @param {mat2d} a the source matrix1775         * @returns {mat2d} out1776         */1777        mat2d.invert = function(out, a) {1778            var aa = a[0],1779                ab = a[1],1780                ac = a[2],1781                ad = a[3],1782                atx = a[4],1783                aty = a[5];1784            var det = aa * ad - ab * ac;1785            if (!det) {1786                return null;1787            }1788            det = 1.0 / det;1789            out[0] = ad * det;1790            out[1] = -ab * det;1791            out[2] = -ac * det;1792            out[3] = aa * det;1793            out[4] = (ac * aty - ad * atx) * det;1794            out[5] = (ab * atx - aa * aty) * det;1795            return out;1796        };1797        /**1798         * Calculates the determinant of a mat2d1799         *1800         * @param {mat2d} a the source matrix1801         * @returns {Number} determinant of a1802         */1803        mat2d.determinant = function(a) {1804            return a[0] * a[3] - a[1] * a[2];1805        };1806        /**1807         * Multiplies two mat2d's1808         *1809         * @param {mat2d} out the receiving matrix1810         * @param {mat2d} a the first operand1811         * @param {mat2d} b the second operand1812         * @returns {mat2d} out1813         */1814        mat2d.multiply = function(out, a, b) {1815            var aa = a[0],1816                ab = a[1],1817                ac = a[2],1818                ad = a[3],1819                atx = a[4],1820                aty = a[5],1821                ba = b[0],1822                bb = b[1],1823                bc = b[2],1824                bd = b[3],1825                btx = b[4],1826                bty = b[5];1827            out[0] = aa * ba + ab * bc;1828            out[1] = aa * bb + ab * bd;1829            out[2] = ac * ba + ad * bc;1830            out[3] = ac * bb + ad * bd;1831            out[4] = ba * atx + bc * aty + btx;1832            out[5] = bb * atx + bd * aty + bty;1833            return out;1834        };1835        /**1836         * Alias for {@link mat2d.multiply}1837         * @function1838         */1839        mat2d.mul = mat2d.multiply;1840        /**1841         * Rotates a mat2d by the given angle1842         *1843         * @param {mat2d} out the receiving matrix1844         * @param {mat2d} a the matrix to rotate1845         * @param {Number} rad the angle to rotate the matrix by1846         * @returns {mat2d} out1847         */1848        mat2d.rotate = function(out, a, rad) {1849            var aa = a[0],1850                ab = a[1],1851                ac = a[2],1852                ad = a[3],1853                atx = a[4],1854                aty = a[5],1855                st = Math.sin(rad),1856                ct = Math.cos(rad);1857            out[0] = aa * ct + ab * st;1858            out[1] = -aa * st + ab * ct;1859            out[2] = ac * ct + ad * st;1860            out[3] = -ac * st + ct * ad;1861            out[4] = ct * atx + st * aty;1862            out[5] = ct * aty - st * atx;1863            return out;1864        };1865        /**1866         * Scales the mat2d by the dimensions in the given vec21867         *1868         * @param {mat2d} out the receiving matrix1869         * @param {mat2d} a the matrix to translate1870         * @param {mat2d} v the vec2 to scale the matrix by1871         * @returns {mat2d} out1872         **/1873        mat2d.scale = function(out, a, v) {1874            var vx = v[0],1875                vy = v[1];1876            out[0] = a[0] * vx;1877            out[1] = a[1] * vy;1878            out[2] = a[2] * vx;1879            out[3] = a[3] * vy;1880            out[4] = a[4] * vx;1881            out[5] = a[5] * vy;1882            return out;1883        };1884        /**1885         * Translates the mat2d by the dimensions in the given vec21886         *1887         * @param {mat2d} out the receiving matrix1888         * @param {mat2d} a the matrix to translate1889         * @param {mat2d} v the vec2 to translate the matrix by1890         * @returns {mat2d} out1891         **/1892        mat2d.translate = function(out, a, v) {1893            out[0] = a[0];1894            out[1] = a[1];1895            out[2] = a[2];1896            out[3] = a[3];1897            out[4] = a[4] + v[0];1898            out[5] = a[5] + v[1];1899            return out;1900        };1901        /**1902         * Returns a string representation of a mat2d1903         *1904         * @param {mat2d} a matrix to represent as a string1905         * @returns {String} string representation of the matrix1906         */1907        mat2d.str = function(a) {1908            return 'mat2d(' + a[0] + ', ' + a[1] + ', ' + a[2] + ', ' +1909                a[3] + ', ' + a[4] + ', ' + a[5] + ')';1910        };1911        if (typeof(exports) !== 'undefined') {1912            exports.mat2d = mat2d;1913        };1914        /* Copyright (c) 2013, Brandon Jones, Colin MacKenzie IV. All rights reserved.1915Redistribution and use in source and binary forms, with or without modification,1916are permitted provided that the following conditions are met:1917  * Redistributions of source code must retain the above copyright notice, this1918    list of conditions and the following disclaimer.1919  * Redistributions in binary form must reproduce the above copyright notice,1920    this list of conditions and the following disclaimer in the documentation 1921    and/or other materials provided with the distribution.1922THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND1923ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED1924WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 1925DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR1926ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES1927(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;1928LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON1929ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT1930(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS1931SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */1932        /**1933         * @class 3x3 Matrix1934         * @name mat31935         */1936        var mat3 = {};1937        var mat3Identity = new Float32Array([1938            1, 0, 0,1939            0, 1, 0,1940            0, 0, 11941        ]);1942        /**1943         * Creates a new identity mat31944         *1945         * @returns {mat3} a new 3x3 matrix1946         */1947        mat3.create = function() {1948            var out = new GLMAT_ARRAY_TYPE(9);1949            out[0] = 1;1950            out[1] = 0;1951            out[2] = 0;1952            out[3] = 0;1953            out[4] = 1;1954            out[5] = 0;1955            out[6] = 0;1956            out[7] = 0;1957            out[8] = 1;1958            return out;1959        };1960        /**1961         * Creates a new mat3 initialized with values from an existing matrix1962         *1963         * @param {mat3} a matrix to clone1964         * @returns {mat3} a new 3x3 matrix1965         */1966        mat3.clone = function(a) {1967            var out = new GLMAT_ARRAY_TYPE(9);1968            out[0] = a[0];1969            out[1] = a[1];1970            out[2] = a[2];1971            out[3] = a[3];1972            out[4] = a[4];1973            out[5] = a[5];1974            out[6] = a[6];1975            out[7] = a[7];1976            out[8] = a[8];1977            return out;1978        };1979        /**1980         * Copy the values from one mat3 to another1981         *1982         * @param {mat3} out the receiving matrix1983         * @param {mat3} a the source matrix1984         * @returns {mat3} out1985         */1986        mat3.copy = function(out, a) {1987            out[0] = a[0];1988            out[1] = a[1];1989            out[2] = a[2];1990            out[3] = a[3];1991            out[4] = a[4];1992            out[5] = a[5];1993            out[6] = a[6];1994            out[7] = a[7];1995            out[8] = a[8];1996            return out;1997        };1998        /**1999         * Set a mat3 to the identity matrix2000         *2001         * @param {mat3} out the receiving matrix2002         * @returns {mat3} out2003         */2004        mat3.identity = function(out) {2005            out[0] = 1;2006            out[1] = 0;2007            out[2] = 0;2008            out[3] = 0;2009            out[4] = 1;2010            out[5] = 0;2011            out[6] = 0;2012            out[7] = 0;2013            out[8] = 1;2014            return out;2015        };2016        /**2017         * Transpose the values of a mat32018         *2019         * @param {mat3} out the receiving matrix2020         * @param {mat3} a the source matrix2021         * @returns {mat3} out2022         */2023        mat3.transpose = function(out, a) {2024            // If we are transposing ourselves we can skip a few steps but have to cache some values2025            if (out === a) {2026                var a01 = a[1],2027                    a02 = a[2],2028                    a12 = a[5];2029                out[1] = a[3];2030                out[2] = a[6];2031                out[3] = a01;2032                out[5] = a[7];2033                out[6] = a02;2034                out[7] = a12;2035            } else {2036                out[0] = a[0];2037                out[1] = a[3];2038                out[2] = a[6];2039                out[3] = a[1];2040                out[4] = a[4];2041                out[5] = a[7];2042                out[6] = a[2];2043                out[7] = a[5];2044                out[8] = a[8];2045            }2046            return out;2047        };2048        /**2049         * Inverts a mat32050         *2051         * @param {mat3} out the receiving matrix2052         * @param {mat3} a the source matrix2053         * @returns {mat3} out2054         */2055        mat3.invert = function(out, a) {2056            var a00 = a[0],2057                a01 = a[1],2058                a02 = a[2],2059                a10 = a[3],2060                a11 = a[4],2061                a12 = a[5],2062                a20 = a[6],2063                a21 = a[7],2064                a22 = a[8],2065                b01 = a22 * a11 - a12 * a21,2066                b11 = -a22 * a10 + a12 * a20,2067                b21 = a21 * a10 - a11 * a20,2068                // Calculate the determinant2069                det = a00 * b01 + a01 * b11 + a02 * b21;2070            if (!det) {2071                return null;2072            }2073            det = 1.0 / det;2074            out[0] = b01 * det;2075            out[1] = (-a22 * a01 + a02 * a21) * det;2076            out[2] = (a12 * a01 - a02 * a11) * det;2077            out[3] = b11 * det;2078            out[4] = (a22 * a00 - a02 * a20) * det;2079            out[5] = (-a12 * a00 + a02 * a10) * det;2080            out[6] = b21 * det;2081            out[7] = (-a21 * a00 + a01 * a20) * det;2082            out[8] = (a11 * a00 - a01 * a10) * det;2083            return out;2084        };2085        /**2086         * Calculates the adjugate of a mat32087         *2088         * @param {mat3} out the receiving matrix2089         * @param {mat3} a the source matrix2090         * @returns {mat3} out2091         */2092        mat3.adjoint = function(out, a) {2093            var a00 = a[0],2094                a01 = a[1],2095                a02 = a[2],2096                a10 = a[3],2097                a11 = a[4],2098                a12 = a[5],2099                a20 = a[6],2100                a21 = a[7],2101                a22 = a[8];2102            out[0] = (a11 * a22 - a12 * a21);2103            out[1] = (a02 * a21 - a01 * a22);2104            out[2] = (a01 * a12 - a02 * a11);2105            out[3] = (a12 * a20 - a10 * a22);2106            out[4] = (a00 * a22 - a02 * a20);2107            out[5] = (a02 * a10 - a00 * a12);2108            out[6] = (a10 * a21 - a11 * a20);2109            out[7] = (a01 * a20 - a00 * a21);2110            out[8] = (a00 * a11 - a01 * a10);2111            return out;2112        };2113        /**2114         * Calculates the determinant of a mat32115         *2116         * @param {mat3} a the source matrix2117         * @returns {Number} determinant of a2118         */2119        mat3.determinant = function(a) {2120            var a00 = a[0],2121                a01 = a[1],2122                a02 = a[2],2123                a10 = a[3],2124                a11 = a[4],2125                a12 = a[5],2126                a20 = a[6],2127                a21 = a[7],2128                a22 = a[8];2129            return a00 * (a22 * a11 - a12 * a21) + a01 * (-a22 * a10 + a12 * a20) + a02 * (a21 * a10 - a11 * a20);2130        };2131        /**2132         * Multiplies two mat3's2133         *2134         * @param {mat3} out the receiving matrix2135         * @param {mat3} a the first operand2136         * @param {mat3} b the second operand2137         * @returns {mat3} out2138         */2139        mat3.multiply = function(out, a, b) {2140            var a00 = a[0],2141                a01 = a[1],2142                a02 = a[2],2143                a10 = a[3],2144                a11 = a[4],2145                a12 = a[5],2146                a20 = a[6],2147                a21 = a[7],2148                a22 = a[8],2149                b00 = b[0],2150                b01 = b[1],2151                b02 = b[2],2152                b10 = b[3],2153                b11 = b[4],2154                b12 = b[5],2155                b20 = b[6],2156                b21 = b[7],2157                b22 = b[8];2158            out[0] = b00 * a00 + b01 * a10 + b02 * a20;2159            out[1] = b00 * a01 + b01 * a11 + b02 * a21;2160            out[2] = b00 * a02 + b01 * a12 + b02 * a22;2161            out[3] = b10 * a00 + b11 * a10 + b12 * a20;2162            out[4] = b10 * a01 + b11 * a11 + b12 * a21;2163            out[5] = b10 * a02 + b11 * a12 + b12 * a22;2164            out[6] = b20 * a00 + b21 * a10 + b22 * a20;2165            out[7] = b20 * a01 + b21 * a11 + b22 * a21;2166            out[8] = b20 * a02 + b21 * a12 + b22 * a22;2167            return out;2168        };2169        /**2170         * Alias for {@link mat3.multiply}2171         * @function2172         */2173        mat3.mul = mat3.multiply;2174        /**2175         * Translate a mat3 by the given vector2176         *2177         * @param {mat3} out the receiving matrix2178         * @param {mat3} a the matrix to translate2179         * @param {vec2} v vector to translate by2180         * @returns {mat3} out2181         */2182        mat3.translate = function(out, a, v) {2183            var a00 = a[0],2184                a01 = a[1],2185                a02 = a[2],2186                a10 = a[3],2187                a11 = a[4],2188                a12 = a[5],2189                a20 = a[6],2190                a21 = a[7],2191                a22 = a[8],2192                x = v[0],2193                y = v[1];2194            out[0] = a00;2195            out[1] = a01;2196            out[2] = a02;2197            out[3] = a10;2198            out[4] = a11;2199            out[5] = a12;2200            out[6] = x * a00 + y * a10 + a20;2201            out[7] = x * a01 + y * a11 + a21;2202            out[8] = x * a02 + y * a12 + a22;2203            return out;2204        };2205        /**2206         * Rotates a mat3 by the given angle2207         *2208         * @param {mat3} out the receiving matrix2209         * @param {mat3} a the matrix to rotate2210         * @param {Number} rad the angle to rotate the matrix by2211         * @returns {mat3} out2212         */2213        mat3.rotate = function(out, a, rad) {2214            var a00 = a[0],2215                a01 = a[1],2216                a02 = a[2],2217                a10 = a[3],2218                a11 = a[4],2219                a12 = a[5],2220                a20 = a[6],2221                a21 = a[7],2222                a22 = a[8],2223                s = Math.sin(rad),2224                c = Math.cos(rad);2225            out[0] = c * a00 + s * a10;2226            out[1] = c * a01 + s * a11;2227            out[2] = c * a02 + s * a12;2228            out[3] = c * a10 - s * a00;2229            out[4] = c * a11 - s * a01;2230            out[5] = c * a12 - s * a02;2231            out[6] = a20;2232            out[7] = a21;2233            out[8] = a22;2234            return out;2235        };2236        /**2237         * Scales the mat3 by the dimensions in the given vec22238         *2239         * @param {mat3} out the receiving matrix2240         * @param {mat3} a the matrix to rotate2241         * @param {vec2} v the vec2 to scale the matrix by2242         * @returns {mat3} out2243         **/2244        mat3.scale = function(out, a, v) {2245            var x = v[0],2246                y = v[2];2247            out[0] = x * a[0];2248            out[1] = x * a[1];2249            out[2] = x * a[2];2250            out[3] = y * a[3];2251            out[4] = y * a[4];2252            out[5] = y * a[5];2253            out[6] = a[6];2254            out[7] = a[7];2255            out[8] = a[8];2256            return out;2257        };2258        /**2259         * Copies the values from a mat2d into a mat32260         *2261         * @param {mat3} out the receiving matrix2262         * @param {mat3} a the matrix to rotate2263         * @param {vec2} v the vec2 to scale the matrix by2264         * @returns {mat3} out2265         **/2266        mat3.fromMat2d = function(out, a) {2267            out[0] = a[0];2268            out[1] = a[1];2269            out[2] = 0;2270            out[3] = a[2];2271            out[4] = a[3];2272            out[5] = 0;2273            out[6] = a[4];2274            out[7] = a[5];2275            out[8] = 1;2276            return out;2277        };2278        /**2279         * Calculates a 3x3 matrix from the given quaternion2280         *2281         * @param {mat3} out mat3 receiving operation result2282         * @param {quat} q Quaternion to create matrix from2283         *2284         * @returns {mat3} out2285         */2286        mat3.fromQuat = function(out, q) {2287            var x = q[0],2288                y = q[1],2289                z = q[2],2290                w = q[3],2291                x2 = x + x,2292                y2 = y + y,2293                z2 = z + z,2294                xx = x * x2,2295                xy = x * y2,2296                xz = x * z2,2297                yy = y * y2,2298                yz = y * z2,2299                zz = z * z2,2300                wx = w * x2,2301                wy = w * y2,2302                wz = w * z2;2303            out[0] = 1 - (yy + zz);2304            out[1] = xy + wz;2305            out[2] = xz - wy;2306            out[3] = xy - wz;2307            out[4] = 1 - (xx + zz);2308            out[5] = yz + wx;2309            out[6] = xz + wy;2310            out[7] = yz - wx;2311            out[8] = 1 - (xx + yy);2312            return out;2313        };2314        /**2315         * Returns a string representation of a mat32316         *2317         * @param {mat3} mat matrix to represent as a string2318         * @returns {String} string representation of the matrix2319         */2320        mat3.str = function(a) {2321            return 'mat3(' + a[0] + ', ' + a[1] + ', ' + a[2] + ', ' +2322                a[3] + ', ' + a[4] + ', ' + a[5] + ', ' +2323                a[6] + ', ' + a[7] + ', ' + a[8] + ')';2324        };2325        if (typeof(exports) !== 'undefined') {2326            exports.mat3 = mat3;2327        };2328        /* Copyright (c) 2013, Brandon Jones, Colin MacKenzie IV. All rights reserved.2329Redistribution and use in source and binary forms, with or without modification,2330are permitted provided that the following conditions are met:2331  * Redistributions of source code must retain the above copyright notice, this2332    list of conditions and the following disclaimer.2333  * Redistributions in binary form must reproduce the above copyright notice,2334    this list of conditions and the following disclaimer in the documentation 2335    and/or other materials provided with the distribution.2336THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND2337ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED2338WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 2339DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR2340ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES2341(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;2342LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON2343ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT2344(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS2345SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */2346        /**2347         * @class 4x4 Matrix2348         * @name mat42349         */2350        var mat4 = {};2351        var mat4Identity = new Float32Array([2352            1, 0, 0, 0,2353            0, 1, 0, 0,2354            0, 0, 1, 0,2355            0, 0, 0, 12356        ]);2357        /**2358         * Creates a new identity mat42359         *2360         * @returns {mat4} a new 4x4 matrix2361         */2362        mat4.create = function() {2363            var out = new GLMAT_ARRAY_TYPE(16);2364            out[0] = 1;2365            out[1] = 0;2366            out[2] = 0;2367            out[3] = 0;2368            out[4] = 0;2369            out[5] = 1;2370            out[6] = 0;2371            out[7] = 0;2372            out[8] = 0;2373            out[9] = 0;2374            out[10] = 1;2375            out[11] = 0;2376            out[12] = 0;2377            out[13] = 0;2378            out[14] = 0;2379            out[15] = 1;2380            return out;2381        };2382        /**2383         * Creates a new mat4 initialized with values from an existing matrix2384         *2385         * @param {mat4} a matrix to clone2386         * @returns {mat4} a new 4x4 matrix2387         */2388        mat4.clone = function(a) {2389            var out = new GLMAT_ARRAY_TYPE(16);2390            out[0] = a[0];2391            out[1] = a[1];2392            out[2] = a[2];2393            out[3] = a[3];2394            out[4] = a[4];2395            out[5] = a[5];2396            out[6] = a[6];2397            out[7] = a[7];2398            out[8] = a[8];2399            out[9] = a[9];2400            out[10] = a[10];2401            out[11] = a[11];2402            out[12] = a[12];2403            out[13] = a[13];2404            out[14] = a[14];2405            out[15] = a[15];2406            return out;2407        };2408        /**2409         * Copy the values from one mat4 to another2410         *2411         * @param {mat4} out the receiving matrix2412         * @param {mat4} a the source matrix2413         * @returns {mat4} out2414         */2415        mat4.copy = function(out, a) {2416            out[0] = a[0];2417            out[1] = a[1];2418            out[2] = a[2];2419            out[3] = a[3];2420            out[4] = a[4];2421            out[5] = a[5];2422            out[6] = a[6];2423            out[7] = a[7];2424            out[8] = a[8];2425            out[9] = a[9];2426            out[10] = a[10];2427            out[11] = a[11];2428            out[12] = a[12];2429            out[13] = a[13];2430            out[14] = a[14];2431            out[15] = a[15];2432            return out;2433        };2434        /**2435         * Set a mat4 to the identity matrix2436         *2437         * @param {mat4} out the receiving matrix2438         * @returns {mat4} out2439         */2440        mat4.identity = function(out) {2441            out[0] = 1;2442            out[1] = 0;2443            out[2] = 0;2444            out[3] = 0;2445            out[4] = 0;2446            out[5] = 1;2447            out[6] = 0;2448            out[7] = 0;2449            out[8] = 0;2450            out[9] = 0;2451            out[10] = 1;2452            out[11] = 0;2453            out[12] = 0;2454            out[13] = 0;2455            out[14] = 0;2456            out[15] = 1;2457            return out;2458        };2459        /**2460         * Transpose the values of a mat42461         *2462         * @param {mat4} out the receiving matrix2463         * @param {mat4} a the source matrix2464         * @returns {mat4} out2465         */2466        mat4.transpose = function(out, a) {2467            // If we are transposing ourselves we can skip a few steps but have to cache some values2468            if (out === a) {2469                var a01 = a[1],2470                    a02 = a[2],2471                    a03 = a[3],2472                    a12 = a[6],2473                    a13 = a[7],2474                    a23 = a[11];2475                out[1] = a[4];2476                out[2] = a[8];2477                out[3] = a[12];2478                out[4] = a01;2479                out[6] = a[9];2480                out[7] = a[13];2481                out[8] = a02;2482                out[9] = a12;2483                out[11] = a[14];2484                out[12] = a03;2485                out[13] = a13;2486                out[14] = a23;2487            } else {2488                out[0] = a[0];2489                out[1] = a[4];2490                out[2] = a[8];2491                out[3] = a[12];2492                out[4] = a[1];2493                out[5] = a[5];2494                out[6] = a[9];2495                out[7] = a[13];2496                out[8] = a[2];2497                out[9] = a[6];2498                out[10] = a[10];2499                out[11] = a[14];2500                out[12] = a[3];2501                out[13] = a[7];2502                out[14] = a[11];2503                out[15] = a[15];2504            }2505            return out;2506        };2507        /**2508         * Inverts a mat42509         *2510         * @param {mat4} out the receiving matrix2511         * @param {mat4} a the source matrix2512         * @returns {mat4} out2513         */2514        mat4.invert = function(out, a) {2515            var a00 = a[0],2516                a01 = a[1],2517                a02 = a[2],2518                a03 = a[3],2519                a10 = a[4],2520                a11 = a[5],2521                a12 = a[6],2522                a13 = a[7],2523                a20 = a[8],2524                a21 = a[9],2525                a22 = a[10],2526                a23 = a[11],2527                a30 = a[12],2528                a31 = a[13],2529                a32 = a[14],2530                a33 = a[15],2531                b00 = a00 * a11 - a01 * a10,2532                b01 = a00 * a12 - a02 * a10,2533                b02 = a00 * a13 - a03 * a10,2534                b03 = a01 * a12 - a02 * a11,2535                b04 = a01 * a13 - a03 * a11,2536                b05 = a02 * a13 - a03 * a12,2537                b06 = a20 * a31 - a21 * a30,2538                b07 = a20 * a32 - a22 * a30,2539                b08 = a20 * a33 - a23 * a30,2540                b09 = a21 * a32 - a22 * a31,2541                b10 = a21 * a33 - a23 * a31,2542                b11 = a22 * a33 - a23 * a32,2543                // Calculate the determinant2544                det = b00 * b11 - b01 * b10 + b02 * b09 + b03 * b08 - b04 * b07 + b05 * b06;2545            if (!det) {2546                return null;2547            }2548            det = 1.0 / det;2549            out[0] = (a11 * b11 - a12 * b10 + a13 * b09) * det;2550            out[1] = (a02 * b10 - a01 * b11 - a03 * b09) * det;2551            out[2] = (a31 * b05 - a32 * b04 + a33 * b03) * det;2552            out[3] = (a22 * b04 - a21 * b05 - a23 * b03) * det;2553            out[4] = (a12 * b08 - a10 * b11 - a13 * b07) * det;2554            out[5] = (a00 * b11 - a02 * b08 + a03 * b07) * det;2555            out[6] = (a32 * b02 - a30 * b05 - a33 * b01) * det;2556            out[7] = (a20 * b05 - a22 * b02 + a23 * b01) * det;2557            out[8] = (a10 * b10 - a11 * b08 + a13 * b06) * det;2558            out[9] = (a01 * b08 - a00 * b10 - a03 * b06) * det;2559            out[10] = (a30 * b04 - a31 * b02 + a33 * b00) * det;2560            out[11] = (a21 * b02 - a20 * b04 - a23 * b00) * det;2561            out[12] = (a11 * b07 - a10 * b09 - a12 * b06) * det;2562            out[13] = (a00 * b09 - a01 * b07 + a02 * b06) * det;2563            out[14] = (a31 * b01 - a30 * b03 - a32 * b00) * det;2564            out[15] = (a20 * b03 - a21 * b01 + a22 * b00) * det;2565            return out;2566        };2567        /**2568         * Calculates the adjugate of a mat42569         *2570         * @param {mat4} out the receiving matrix2571         * @param {mat4} a the source matrix2572         * @returns {mat4} out2573         */2574        mat4.adjoint = function(out, a) {2575            var a00 = a[0],2576                a01 = a[1],2577                a02 = a[2],2578                a03 = a[3],2579                a10 = a[4],2580                a11 = a[5],2581                a12 = a[6],2582                a13 = a[7],2583                a20 = a[8],2584                a21 = a[9],2585                a22 = a[10],2586                a23 = a[11],2587                a30 = a[12],2588                a31 = a[13],2589                a32 = a[14],2590                a33 = a[15];2591            out[0] = (a11 * (a22 * a33 - a23 * a32) - a21 * (a12 * a33 - a13 * a32) + a31 * (a12 * a23 - a13 * a22));2592            out[1] = -(a01 * (a22 * a33 - a23 * a32) - a21 * (a02 * a33 - a03 * a32) + a31 * (a02 * a23 - a03 * a22));2593            out[2] = (a01 * (a12 * a33 - a13 * a32) - a11 * (a02 * a33 - a03 * a32) + a31 * (a02 * a13 - a03 * a12));2594            out[3] = -(a01 * (a12 * a23 - a13 * a22) - a11 * (a02 * a23 - a03 * a22) + a21 * (a02 * a13 - a03 * a12));2595            out[4] = -(a10 * (a22 * a33 - a23 * a32) - a20 * (a12 * a33 - a13 * a32) + a30 * (a12 * a23 - a13 * a22));2596            out[5] = (a00 * (a22 * a33 - a23 * a32) - a20 * (a02 * a33 - a03 * a32) + a30 * (a02 * a23 - a03 * a22));2597            out[6] = -(a00 * (a12 * a33 - a13 * a32) - a10 * (a02 * a33 - a03 * a32) + a30 * (a02 * a13 - a03 * a12));2598            out[7] = (a00 * (a12 * a23 - a13 * a22) - a10 * (a02 * a23 - a03 * a22) + a20 * (a02 * a13 - a03 * a12));2599            out[8] = (a10 * (a21 * a33 - a23 * a31) - a20 * (a11 * a33 - a13 * a31) + a30 * (a11 * a23 - a13 * a21));2600            out[9] = -(a00 * (a21 * a33 - a23 * a31) - a20 * (a01 * a33 - a03 * a31) + a30 * (a01 * a23 - a03 * a21));2601            out[10] = (a00 * (a11 * a33 - a13 * a31) - a10 * (a01 * a33 - a03 * a31) + a30 * (a01 * a13 - a03 * a11));2602            out[11] = -(a00 * (a11 * a23 - a13 * a21) - a10 * (a01 * a23 - a03 * a21) + a20 * (a01 * a13 - a03 * a11));2603            out[12] = -(a10 * (a21 * a32 - a22 * a31) - a20 * (a11 * a32 - a12 * a31) + a30 * (a11 * a22 - a12 * a21));2604            out[13] = (a00 * (a21 * a32 - a22 * a31) - a20 * (a01 * a32 - a02 * a31) + a30 * (a01 * a22 - a02 * a21));2605            out[14] = -(a00 * (a11 * a32 - a12 * a31) - a10 * (a01 * a32 - a02 * a31) + a30 * (a01 * a12 - a02 * a11));2606            out[15] = (a00 * (a11 * a22 - a12 * a21) - a10 * (a01 * a22 - a02 * a21) + a20 * (a01 * a12 - a02 * a11));2607            return out;2608        };2609        /**2610         * Calculates the determinant of a mat42611         *2612         * @param {mat4} a the source matrix2613         * @returns {Number} determinant of a2614         */2615        mat4.determinant = function(a) {2616            var a00 = a[0],2617                a01 = a[1],2618                a02 = a[2],2619                a03 = a[3],2620                a10 = a[4],2621                a11 = a[5],2622                a12 = a[6],2623                a13 = a[7],2624                a20 = a[8],2625                a21 = a[9],2626                a22 = a[10],2627                a23 = a[11],2628                a30 = a[12],2629                a31 = a[13],2630                a32 = a[14],2631                a33 = a[15],2632                b00 = a00 * a11 - a01 * a10,2633                b01 = a00 * a12 - a02 * a10,2634                b02 = a00 * a13 - a03 * a10,2635                b03 = a01 * a12 - a02 * a11,2636                b04 = a01 * a13 - a03 * a11,2637                b05 = a02 * a13 - a03 * a12,2638                b06 = a20 * a31 - a21 * a30,2639                b07 = a20 * a32 - a22 * a30,2640                b08 = a20 * a33 - a23 * a30,2641                b09 = a21 * a32 - a22 * a31,2642                b10 = a21 * a33 - a23 * a31,2643                b11 = a22 * a33 - a23 * a32;2644            // Calculate the determinant2645            return b00 * b11 - b01 * b10 + b02 * b09 + b03 * b08 - b04 * b07 + b05 * b06;2646        };2647        /**2648         * Multiplies two mat4's2649         *2650         * @param {mat4} out the receiving matrix2651         * @param {mat4} a the first operand2652         * @param {mat4} b the second operand2653         * @returns {mat4} out2654         */2655        mat4.multiply = function(out, a, b) {2656            var a00 = a[0],2657                a01 = a[1],2658                a02 = a[2],2659                a03 = a[3],2660                a10 = a[4],2661                a11 = a[5],2662                a12 = a[6],2663                a13 = a[7],2664                a20 = a[8],2665                a21 = a[9],2666                a22 = a[10],2667                a23 = a[11],2668                a30 = a[12],2669                a31 = a[13],2670                a32 = a[14],2671                a33 = a[15];2672            // Cache only the current line of the second matrix2673            var b0 = b[0],2674                b1 = b[1],2675                b2 = b[2],2676                b3 = b[3];2677            out[0] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30;2678            out[1] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31;2679            out[2] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32;2680            out[3] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33;2681            b0 = b[4];2682            b1 = b[5];2683            b2 = b[6];2684            b3 = b[7];2685            out[4] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30;2686            out[5] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31;2687            out[6] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32;2688            out[7] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33;2689            b0 = b[8];2690            b1 = b[9];2691            b2 = b[10];2692            b3 = b[11];2693            out[8] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30;2694            out[9] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31;2695            out[10] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32;2696            out[11] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33;2697            b0 = b[12];2698            b1 = b[13];2699            b2 = b[14];2700            b3 = b[15];2701            out[12] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30;2702            out[13] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31;2703            out[14] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32;2704            out[15] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33;2705            return out;2706        };2707        /**2708         * Alias for {@link mat4.multiply}2709         * @function2710         */2711        mat4.mul = mat4.multiply;2712        /**2713         * Translate a mat4 by the given vector2714         *2715         * @param {mat4} out the receiving matrix2716         * @param {mat4} a the matrix to translate2717         * @param {vec3} v vector to translate by2718         * @returns {mat4} out2719         */2720        mat4.translate = function(out, a, v) {2721            var x = v[0],2722                y = v[1],2723                z = v[2],2724                a00, a01, a02, a03,2725                a10, a11, a12, a13,2726                a20, a21, a22, a23;2727            if (a === out) {2728                out[12] = a[0] * x + a[4] * y + a[8] * z + a[12];2729                out[13] = a[1] * x + a[5] * y + a[9] * z + a[13];2730                out[14] = a[2] * x + a[6] * y + a[10] * z + a[14];2731                out[15] = a[3] * x + a[7] * y + a[11] * z + a[15];2732            } else {2733                a00 = a[0];2734                a01 = a[1];2735                a02 = a[2];2736                a03 = a[3];2737                a10 = a[4];2738                a11 = a[5];2739                a12 = a[6];2740                a13 = a[7];2741                a20 = a[8];2742                a21 = a[9];2743                a22 = a[10];2744                a23 = a[11];2745                out[0] = a00;2746                out[1] = a01;2747                out[2] = a02;2748                out[3] = a03;2749                out[4] = a10;2750                out[5] = a11;2751                out[6] = a12;2752                out[7] = a13;2753                out[8] = a20;2754                out[9] = a21;2755                out[10] = a22;2756                out[11] = a23;2757                out[12] = a00 * x + a10 * y + a20 * z + a[12];2758                out[13] = a01 * x + a11 * y + a21 * z + a[13];2759                out[14] = a02 * x + a12 * y + a22 * z + a[14];2760                out[15] = a03 * x + a13 * y + a23 * z + a[15];2761            }2762            return out;2763        };2764        /**2765         * Scales the mat4 by the dimensions in the given vec32766         *2767         * @param {mat4} out the receiving matrix2768         * @param {mat4} a the matrix to scale2769         * @param {vec3} v the vec3 to scale the matrix by2770         * @returns {mat4} out2771         **/2772        mat4.scale = function(out, a, v) {2773            var x = v[0],2774                y = v[1],2775                z = v[2];2776            out[0] = a[0] * x;2777            out[1] = a[1] * x;2778            out[2] = a[2] * x;2779            out[3] = a[3] * x;2780            out[4] = a[4] * y;2781            out[5] = a[5] * y;2782            out[6] = a[6] * y;2783            out[7] = a[7] * y;2784            out[8] = a[8] * z;2785            out[9] = a[9] * z;2786            out[10] = a[10] * z;2787            out[11] = a[11] * z;2788            out[12] = a[12];2789            out[13] = a[13];2790            out[14] = a[14];2791            out[15] = a[15];2792            return out;2793        };2794        /**2795         * Rotates a mat4 by the given angle2796         *2797         * @param {mat4} out the receiving matrix2798         * @param {mat4} a the matrix to rotate2799         * @param {Number} rad the angle to rotate the matrix by2800         * @param {vec3} axis the axis to rotate around2801         * @returns {mat4} out2802         */2803        mat4.rotate = function(out, a, rad, axis) {2804            var x = axis[0],2805                y = axis[1],2806                z = axis[2],2807                len = Math.sqrt(x * x + y * y + z * z),2808                s, c, t,2809                a00, a01, a02, a03,2810                a10, a11, a12, a13,2811                a20, a21, a22, a23,2812                b00, b01, b02,2813                b10, b11, b12,2814                b20, b21, b22;2815            if (Math.abs(len) < GLMAT_EPSILON) {2816                return null;2817            }2818            len = 1 / len;2819            x *= len;2820            y *= len;2821            z *= len;2822            s = Math.sin(rad);2823            c = Math.cos(rad);2824            t = 1 - c;2825            a00 = a[0];2826            a01 = a[1];2827            a02 = a[2];2828            a03 = a[3];2829            a10 = a[4];2830            a11 = a[5];2831            a12 = a[6];2832            a13 = a[7];2833            a20 = a[8];2834            a21 = a[9];2835            a22 = a[10];2836            a23 = a[11];2837            // Construct the elements of the rotation matrix2838            b00 = x * x * t + c;2839            b01 = y * x * t + z * s;2840            b02 = z * x * t - y * s;2841            b10 = x * y * t - z * s;2842            b11 = y * y * t + c;2843            b12 = z * y * t + x * s;2844            b20 = x * z * t + y * s;2845            b21 = y * z * t - x * s;2846            b22 = z * z * t + c;2847            // Perform rotation-specific matrix multiplication2848            out[0] = a00 * b00 + a10 * b01 + a20 * b02;2849            out[1] = a01 * b00 + a11 * b01 + a21 * b02;2850            out[2] = a02 * b00 + a12 * b01 + a22 * b02;2851            out[3] = a03 * b00 + a13 * b01 + a23 * b02;2852            out[4] = a00 * b10 + a10 * b11 + a20 * b12;2853            out[5] = a01 * b10 + a11 * b11 + a21 * b12;2854            out[6] = a02 * b10 + a12 * b11 + a22 * b12;2855            out[7] = a03 * b10 + a13 * b11 + a23 * b12;2856            out[8] = a00 * b20 + a10 * b21 + a20 * b22;2857            out[9] = a01 * b20 + a11 * b21 + a21 * b22;2858            out[10] = a02 * b20 + a12 * b21 + a22 * b22;2859            out[11] = a03 * b20 + a13 * b21 + a23 * b22;2860            if (a !== out) { // If the source and destination differ, copy the unchanged last row2861                out[12] = a[12];2862                out[13] = a[13];2863                out[14] = a[14];2864                out[15] = a[15];2865            }2866            return out;2867        };2868        /**2869         * Rotates a matrix by the given angle around the X axis2870         *2871         * @param {mat4} out the receiving matrix2872         * @param {mat4} a the matrix to rotate2873         * @param {Number} rad the angle to rotate the matrix by2874         * @returns {mat4} out2875         */2876        mat4.rotateX = function(out, a, rad) {2877            var s = Math.sin(rad),2878                c = Math.cos(rad),2879                a10 = a[4],2880                a11 = a[5],2881                a12 = a[6],2882                a13 = a[7],2883                a20 = a[8],2884                a21 = a[9],2885                a22 = a[10],2886                a23 = a[11];2887            if (a !== out) { // If the source and destination differ, copy the unchanged rows2888                out[0] = a[0];2889                out[1] = a[1];2890                out[2] = a[2];2891                out[3] = a[3];2892                out[12] = a[12];2893                out[13] = a[13];2894                out[14] = a[14];2895                out[15] = a[15];2896            }2897            // Perform axis-specific matrix multiplication2898            out[4] = a10 * c + a20 * s;2899            out[5] = a11 * c + a21 * s;2900            out[6] = a12 * c + a22 * s;2901            out[7] = a13 * c + a23 * s;2902            out[8] = a20 * c - a10 * s;2903            out[9] = a21 * c - a11 * s;2904            out[10] = a22 * c - a12 * s;2905            out[11] = a23 * c - a13 * s;2906            return out;2907        };2908        /**2909         * Rotates a matrix by the given angle around the Y axis2910         *2911         * @param {mat4} out the receiving matrix2912         * @param {mat4} a the matrix to rotate2913         * @param {Number} rad the angle to rotate the matrix by2914         * @returns {mat4} out2915         */2916        mat4.rotateY = function(out, a, rad) {2917            var s = Math.sin(rad),2918                c = Math.cos(rad),2919                a00 = a[0],2920                a01 = a[1],2921                a02 = a[2],2922                a03 = a[3],2923                a20 = a[8],2924                a21 = a[9],2925                a22 = a[10],2926                a23 = a[11];2927            if (a !== out) { // If the source and destination differ, copy the unchanged rows2928                out[4] = a[4];2929                out[5] = a[5];2930                out[6] = a[6];2931                out[7] = a[7];2932                out[12] = a[12];2933                out[13] = a[13];2934                out[14] = a[14];2935                out[15] = a[15];2936            }2937            // Perform axis-specific matrix multiplication2938            out[0] = a00 * c - a20 * s;2939            out[1] = a01 * c - a21 * s;2940            out[2] = a02 * c - a22 * s;2941            out[3] = a03 * c - a23 * s;2942            out[8] = a00 * s + a20 * c;2943            out[9] = a01 * s + a21 * c;2944            out[10] = a02 * s + a22 * c;2945            out[11] = a03 * s + a23 * c;2946            return out;2947        };2948        /**2949         * Rotates a matrix by the given angle around the Z axis2950         *2951         * @param {mat4} out the receiving matrix2952         * @param {mat4} a the matrix to rotate2953         * @param {Number} rad the angle to rotate the matrix by2954         * @returns {mat4} out2955         */2956        mat4.rotateZ = function(out, a, rad) {2957            var s = Math.sin(rad),2958                c = Math.cos(rad),2959                a00 = a[0],2960                a01 = a[1],2961                a02 = a[2],2962                a03 = a[3],2963                a10 = a[4],2964                a11 = a[5],2965                a12 = a[6],2966                a13 = a[7];2967            if (a !== out) { // If the source and destination differ, copy the unchanged last row2968                out[8] = a[8];2969                out[9] = a[9];2970                out[10] = a[10];2971                out[11] = a[11];2972                out[12] = a[12];2973                out[13] = a[13];2974                out[14] = a[14];2975                out[15] = a[15];2976            }2977            // Perform axis-specific matrix multiplication2978            out[0] = a00 * c + a10 * s;2979            out[1] = a01 * c + a11 * s;2980            out[2] = a02 * c + a12 * s;2981            out[3] = a03 * c + a13 * s;2982            out[4] = a10 * c - a00 * s;2983            out[5] = a11 * c - a01 * s;2984            out[6] = a12 * c - a02 * s;2985            out[7] = a13 * c - a03 * s;2986            return out;2987        };2988        /**2989         * Creates a matrix from a quaternion rotation and vector translation2990         * This is equivalent to (but much faster than):2991         *2992         *     mat4.identity(dest);2993         *     mat4.translate(dest, vec);2994         *     var quatMat = mat4.create();2995         *     quat4.toMat4(quat, quatMat);2996         *     mat4.multiply(dest, quatMat);2997         *2998         * @param {mat4} out mat4 receiving operation result2999         * @param {quat4} q Rotation quaternion3000         * @param {vec3} v Translation vector3001         * @returns {mat4} out3002         */3003        mat4.fromRotationTranslation = function(out, q, v) {3004            // Quaternion math3005            var x = q[0],3006                y = q[1],3007                z = q[2],3008                w = q[3],3009                x2 = x + x,3010                y2 = y + y,3011                z2 = z + z,3012                xx = x * x2,3013                xy = x * y2,3014                xz = x * z2,3015                yy = y * y2,3016                yz = y * z2,3017                zz = z * z2,3018                wx = w * x2,3019                wy = w * y2,3020                wz = w * z2;3021            out[0] = 1 - (yy + zz);3022            out[1] = xy + wz;3023            out[2] = xz - wy;3024            out[3] = 0;3025            out[4] = xy - wz;3026            out[5] = 1 - (xx + zz);3027            out[6] = yz + wx;3028            out[7] = 0;3029            out[8] = xz + wy;3030            out[9] = yz - wx;3031            out[10] = 1 - (xx + yy);3032            out[11] = 0;3033            out[12] = v[0];3034            out[13] = v[1];3035            out[14] = v[2];3036            out[15] = 1;3037            return out;3038        };3039        /**3040         * Calculates a 4x4 matrix from the given quaternion3041         *3042         * @param {mat4} out mat4 receiving operation result3043         * @param {quat} q Quaternion to create matrix from3044         *3045         * @returns {mat4} out3046         */3047        mat4.fromQuat = function(out, q) {3048            var x = q[0],3049                y = q[1],3050                z = q[2],3051                w = q[3],3052                x2 = x + x,3053                y2 = y + y,3054                z2 = z + z,3055                xx = x * x2,3056                xy = x * y2,3057                xz = x * z2,3058                yy = y * y2,3059                yz = y * z2,3060                zz = z * z2,3061                wx = w * x2,3062                wy = w * y2,3063                wz = w * z2;3064            out[0] = 1 - (yy + zz);3065            out[1] = xy + wz;3066            out[2] = xz - wy;3067            out[3] = 0;3068            out[4] = xy - wz;3069            out[5] = 1 - (xx + zz);3070            out[6] = yz + wx;3071            out[7] = 0;3072            out[8] = xz + wy;3073            out[9] = yz - wx;3074            out[10] = 1 - (xx + yy);3075            out[11] = 0;3076            out[12] = 0;3077            out[13] = 0;3078            out[14] = 0;3079            out[15] = 1;3080            return out;3081        };3082        /**3083         * Generates a frustum matrix with the given bounds3084         *3085         * @param {mat4} out mat4 frustum matrix will be written into3086         * @param {Number} left Left bound of the frustum3087         * @param {Number} right Right bound of the frustum3088         * @param {Number} bottom Bottom bound of the frustum3089         * @param {Number} top Top bound of the frustum3090         * @param {Number} near Near bound of the frustum3091         * @param {Number} far Far bound of the frustum3092         * @returns {mat4} out3093         */3094        mat4.frustum = function(out, left, right, bottom, top, near, far) {3095            var rl = 1 / (right - left),3096                tb = 1 / (top - bottom),3097                nf = 1 / (near - far);3098            out[0] = (near * 2) * rl;3099            out[1] = 0;3100            out[2] = 0;3101            out[3] = 0;3102            out[4] = 0;3103            out[5] = (near * 2) * tb;3104            out[6] = 0;3105            out[7] = 0;3106            out[8] = (right + left) * rl;3107            out[9] = (top + bottom) * tb;3108            out[10] = (far + near) * nf;3109            out[11] = -1;3110            out[12] = 0;3111            out[13] = 0;3112            out[14] = (far * near * 2) * nf;3113            out[15] = 0;3114            return out;3115        };3116        /**3117         * Generates a perspective projection matrix with the given bounds3118         *3119         * @param {mat4} out mat4 frustum matrix will be written into3120         * @param {number} fovy Vertical field of view in radians3121         * @param {number} aspect Aspect ratio. typically viewport width/height3122         * @param {number} near Near bound of the frustum3123         * @param {number} far Far bound of the frustum3124         * @returns {mat4} out3125         */3126        mat4.perspective = function(out, fovy, aspect, near, far) {3127            var f = 1.0 / Math.tan(fovy / 2),3128                nf = 1 / (near - far);3129            out[0] = f / aspect;3130            out[1] = 0;3131            out[2] = 0;3132            out[3] = 0;3133            out[4] = 0;3134            out[5] = f;3135            out[6] = 0;3136            out[7] = 0;3137            out[8] = 0;3138            out[9] = 0;3139            out[10] = (far + near) * nf;3140            out[11] = -1;3141            out[12] = 0;3142            out[13] = 0;3143            out[14] = (2 * far * near) * nf;3144            out[15] = 0;3145            return out;3146        };3147        /**3148         * Generates a orthogonal projection matrix with the given bounds3149         *3150         * @param {mat4} out mat4 frustum matrix will be written into3151         * @param {number} left Left bound of the frustum3152         * @param {number} right Right bound of the frustum3153         * @param {number} bottom Bottom bound of the frustum3154         * @param {number} top Top bound of the frustum3155         * @param {number} near Near bound of the frustum3156         * @param {number} far Far bound of the frustum3157         * @returns {mat4} out3158         */3159        mat4.ortho = function(out, left, right, bottom, top, near, far) {3160            var lr = 1 / (left - right),3161                bt = 1 / (bottom - top),3162                nf = 1 / (near - far);3163            out[0] = -2 * lr;3164            out[1] = 0;3165            out[2] = 0;3166            out[3] = 0;3167            out[4] = 0;3168            out[5] = -2 * bt;3169            out[6] = 0;3170            out[7] = 0;3171            out[8] = 0;3172            out[9] = 0;3173            out[10] = 2 * nf;3174            out[11] = 0;3175            out[12] = (left + right) * lr;3176            out[13] = (top + bottom) * bt;3177            out[14] = (far + near) * nf;3178            out[15] = 1;3179            return out;3180        };3181        /**3182         * Generates a look-at matrix with the given eye position, focal point, and up axis3183         *3184         * @param {mat4} out mat4 frustum matrix will be written into3185         * @param {vec3} eye Position of the viewer3186         * @param {vec3} center Point the viewer is looking at3187         * @param {vec3} up vec3 pointing up3188         * @returns {mat4} out3189         */3190        mat4.lookAt = function(out, eye, center, up) {3191            var x0, x1, x2, y0, y1, y2, z0, z1, z2, len,3192                eyex = eye[0],3193                eyey = eye[1],3194                eyez = eye[2],3195                upx = up[0],3196                upy = up[1],3197                upz = up[2],3198                centerx = center[0],3199                centery = center[1],3200                centerz = center[2];3201            if (Math.abs(eyex - centerx) < GLMAT_EPSILON &&3202                Math.abs(eyey - centery) < GLMAT_EPSILON &&3203                Math.abs(eyez - centerz) < GLMAT_EPSILON) {3204                return mat4.identity(out);3205            }3206            z0 = eyex - centerx;3207            z1 = eyey - centery;3208            z2 = eyez - centerz;3209            len = 1 / Math.sqrt(z0 * z0 + z1 * z1 + z2 * z2);3210            z0 *= len;3211            z1 *= len;3212            z2 *= len;3213            x0 = upy * z2 - upz * z1;3214            x1 = upz * z0 - upx * z2;3215            x2 = upx * z1 - upy * z0;3216            len = Math.sqrt(x0 * x0 + x1 * x1 + x2 * x2);3217            if (!len) {3218                x0 = 0;3219                x1 = 0;3220                x2 = 0;3221            } else {3222                len = 1 / len;3223                x0 *= len;3224                x1 *= len;3225                x2 *= len;3226            }3227            y0 = z1 * x2 - z2 * x1;3228            y1 = z2 * x0 - z0 * x2;3229            y2 = z0 * x1 - z1 * x0;3230            len = Math.sqrt(y0 * y0 + y1 * y1 + y2 * y2);3231            if (!len) {3232                y0 = 0;3233                y1 = 0;3234                y2 = 0;3235            } else {3236                len = 1 / len;3237                y0 *= len;3238                y1 *= len;3239                y2 *= len;3240            }3241            out[0] = x0;3242            out[1] = y0;3243            out[2] = z0;3244            out[3] = 0;3245            out[4] = x1;3246            out[5] = y1;3247            out[6] = z1;3248            out[7] = 0;3249            out[8] = x2;3250            out[9] = y2;3251            out[10] = z2;3252            out[11] = 0;3253            out[12] = -(x0 * eyex + x1 * eyey + x2 * eyez);3254            out[13] = -(y0 * eyex + y1 * eyey + y2 * eyez);3255            out[14] = -(z0 * eyex + z1 * eyey + z2 * eyez);3256            out[15] = 1;3257            return out;3258        };3259        /**3260         * Returns a string representation of a mat43261         *3262         * @param {mat4} mat matrix to represent as a string3263         * @returns {String} string representation of the matrix3264         */3265        mat4.str = function(a) {3266            return 'mat4(' + a[0] + ', ' + a[1] + ', ' + a[2] + ', ' + a[3] + ', ' +3267                a[4] + ', ' + a[5] + ', ' + a[6] + ', ' + a[7] + ', ' +3268                a[8] + ', ' + a[9] + ', ' + a[10] + ', ' + a[11] + ', ' +3269                a[12] + ', ' + a[13] + ', ' + a[14] + ', ' + a[15] + ')';3270        };3271        if (typeof(exports) !== 'undefined') {3272            exports.mat4 = mat4;3273        };3274        /* Copyright (c) 2013, Brandon Jones, Colin MacKenzie IV. All rights reserved.3275Redistribution and use in source and binary forms, with or without modification,3276are permitted provided that the following conditions are met:3277  * Redistributions of source code must retain the above copyright notice, this3278    list of conditions and the following disclaimer.3279  * Redistributions in binary form must reproduce the above copyright notice,3280    this list of conditions and the following disclaimer in the documentation 3281    and/or other materials provided with the distribution.3282THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND3283ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED3284WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 3285DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR3286ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES3287(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;3288LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON3289ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT3290(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS3291SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */3292        /**3293         * @class Quaternion3294         * @name quat3295         */3296        var quat = {};3297        var quatIdentity = new Float32Array([0, 0, 0, 1]);3298        /**3299         * Creates a new identity quat3300         *3301         * @returns {quat} a new quaternion3302         */3303        quat.create = function() {3304            var out = new GLMAT_ARRAY_TYPE(4);3305            out[0] = 0;3306            out[1] = 0;3307            out[2] = 0;3308            out[3] = 1;3309            return out;3310        };3311        /**3312         * Creates a new quat initialized with values from an existing quaternion3313         *3314         * @param {quat} a quaternion to clone3315         * @returns {quat} a new quaternion3316         * @function3317         */3318        quat.clone = vec4.clone;3319        /**3320         * Creates a new quat initialized with the given values3321         *3322         * @param {Number} x X component3323         * @param {Number} y Y component3324         * @param {Number} z Z component3325         * @param {Number} w W component3326         * @returns {quat} a new quaternion3327         * @function3328         */3329        quat.fromValues = vec4.fromValues;3330        /**3331         * Copy the values from one quat to another3332         *3333         * @param {quat} out the receiving quaternion3334         * @param {quat} a the source quaternion3335         * @returns {quat} out3336         * @function3337         */3338        quat.copy = vec4.copy;3339        /**3340         * Set the components of a quat to the given values3341         *3342         * @param {quat} out the receiving quaternion3343         * @param {Number} x X component3344         * @param {Number} y Y component3345         * @param {Number} z Z component3346         * @param {Number} w W component3347         * @returns {quat} out3348         * @function3349         */3350        quat.set = vec4.set;3351        /**3352         * Set a quat to the identity quaternion3353         *3354         * @param {quat} out the receiving quaternion3355         * @returns {quat} out3356         */3357        quat.identity = function(out) {3358            out[0] = 0;3359            out[1] = 0;3360            out[2] = 0;3361            out[3] = 1;3362            return out;3363        };3364        /**3365         * Sets a quat from the given angle and rotation axis,3366         * then returns it.3367         *3368         * @param {quat} out the receiving quaternion3369         * @param {vec3} axis the axis around which to rotate3370         * @param {Number} rad the angle in radians3371         * @returns {quat} out3372         **/3373        quat.setAxisAngle = function(out, axis, rad) {3374            rad = rad * 0.5;3375            var s = Math.sin(rad);3376            out[0] = s * axis[0];3377            out[1] = s * axis[1];3378            out[2] = s * axis[2];3379            out[3] = Math.cos(rad);3380            return out;3381        };3382        /**3383         * Adds two quat's3384         *3385         * @param {quat} out the receiving quaternion3386         * @param {quat} a the first operand3387         * @param {quat} b the second operand3388         * @returns {quat} out3389         * @function3390         */3391        quat.add = vec4.add;3392        /**3393         * Multiplies two quat's3394         *3395         * @param {quat} out the receiving quaternion3396         * @param {quat} a the first operand3397         * @param {quat} b the second operand3398         * @returns {quat} out3399         */3400        quat.multiply = function(out, a, b) {3401            var ax = a[0],3402                ay = a[1],3403                az = a[2],3404                aw = a[3],3405                bx = b[0],3406                by = b[1],3407                bz = b[2],3408                bw = b[3];3409            out[0] = ax * bw + aw * bx + ay * bz - az * by;3410            out[1] = ay * bw + aw * by + az * bx - ax * bz;3411            out[2] = az * bw + aw * bz + ax * by - ay * bx;3412            out[3] = aw * bw - ax * bx - ay * by - az * bz;3413            return out;3414        };3415        /**3416         * Alias for {@link quat.multiply}3417         * @function3418         */3419        quat.mul = quat.multiply;3420        /**3421         * Scales a quat by a scalar number3422         *3423         * @param {quat} out the receiving vector3424         * @param {quat} a the vector to scale3425         * @param {Number} b amount to scale the vector by3426         * @returns {quat} out3427         * @function3428         */3429        quat.scale = vec4.scale;3430        /**3431         * Rotates a quaternion by the given angle around the X axis3432         *3433         * @param {quat} out quat receiving operation result3434         * @param {quat} a quat to rotate3435         * @param {number} rad angle (in radians) to rotate3436         * @returns {quat} out3437         */3438        quat.rotateX = function(out, a, rad) {3439            rad *= 0.5;3440            var ax = a[0],3441                ay = a[1],3442                az = a[2],3443                aw = a[3],3444                bx = Math.sin(rad),3445                bw = Math.cos(rad);3446            out[0] = ax * bw + aw * bx;3447            out[1] = ay * bw + az * bx;3448            out[2] = az * bw - ay * bx;3449            out[3] = aw * bw - ax * bx;3450            return out;3451        };3452        /**3453         * Rotates a quaternion by the given angle around the Y axis3454         *3455         * @param {quat} out quat receiving operation result3456         * @param {quat} a quat to rotate3457         * @param {number} rad angle (in radians) to rotate3458         * @returns {quat} out3459         */3460        quat.rotateY = function(out, a, rad) {3461            rad *= 0.5;3462            var ax = a[0],3463                ay = a[1],3464                az = a[2],3465                aw = a[3],3466                by = Math.sin(rad),3467                bw = Math.cos(rad);3468            out[0] = ax * bw - az * by;3469            out[1] = ay * bw + aw * by;3470            out[2] = az * bw + ax * by;3471            out[3] = aw * bw - ay * by;3472            return out;3473        };3474        /**3475         * Rotates a quaternion by the given angle around the Z axis3476         *3477         * @param {quat} out quat receiving operation result3478         * @param {quat} a quat to rotate3479         * @param {number} rad angle (in radians) to rotate3480         * @returns {quat} out3481         */3482        quat.rotateZ = function(out, a, rad) {3483            rad *= 0.5;3484            var ax = a[0],3485                ay = a[1],3486                az = a[2],3487                aw = a[3],3488                bz = Math.sin(rad),3489                bw = Math.cos(rad);3490            out[0] = ax * bw + ay * bz;3491            out[1] = ay * bw - ax * bz;3492            out[2] = az * bw + aw * bz;3493            out[3] = aw * bw - az * bz;3494            return out;3495        };3496        /**3497         * Calculates the W component of a quat from the X, Y, and Z components.3498         * Assumes that quaternion is 1 unit in length.3499         * Any existing W component will be ignored.3500         *3501         * @param {quat} out the receiving quaternion3502         * @param {quat} a quat to calculate W component of3503         * @returns {quat} out3504         */3505        quat.calculateW = function(out, a) {3506            var x = a[0],3507                y = a[1],3508                z = a[2];3509            out[0] = x;3510            out[1] = y;3511            out[2] = z;3512            out[3] = -Math.sqrt(Math.abs(1.0 - x * x - y * y - z * z));3513            return out;3514        };3515        /**3516         * Calculates the dot product of two quat's3517         *3518         * @param {quat} a the first operand3519         * @param {quat} b the second operand3520         * @returns {Number} dot product of a and b3521         * @function3522         */3523        quat.dot = vec4.dot;3524        /**3525         * Performs a linear interpolation between two quat's3526         *3527         * @param {quat} out the receiving quaternion3528         * @param {quat} a the first operand3529         * @param {quat} b the second operand3530         * @param {Number} t interpolation amount between the two inputs3531         * @returns {quat} out3532         * @function3533         */3534        quat.lerp = vec4.lerp;3535        /**3536         * Performs a spherical linear interpolation between two quat3537         *3538         * @param {quat} out the receiving quaternion3539         * @param {quat} a the first operand3540         * @param {quat} b the second operand3541         * @param {Number} t interpolation amount between the two inputs3542         * @returns {quat} out3543         */3544        quat.slerp = function(out, a, b, t) {3545            var ax = a[0],3546                ay = a[1],3547                az = a[2],3548                aw = a[3],3549                bx = b[0],3550                by = b[1],3551                bz = b[2],3552                bw = b[3];3553            var cosHalfTheta = ax * bx + ay * by + az * bz + aw * bw,3554                halfTheta,3555                sinHalfTheta,3556                ratioA,3557                ratioB;3558            if (Math.abs(cosHalfTheta) >= 1.0) {3559                if (out !== a) {3560                    out[0] = ax;3561                    out[1] = ay;3562                    out[2] = az;3563                    out[3] = aw;3564                }3565                return out;3566            }3567            halfTheta = Math.acos(cosHalfTheta);3568            sinHalfTheta = Math.sqrt(1.0 - cosHalfTheta * cosHalfTheta);3569            if (Math.abs(sinHalfTheta) < 0.001) {3570                out[0] = (ax * 0.5 + bx * 0.5);3571                out[1] = (ay * 0.5 + by * 0.5);3572                out[2] = (az * 0.5 + bz * 0.5);3573                out[3] = (aw * 0.5 + bw * 0.5);3574                return out;3575            }3576            ratioA = Math.sin((1 - t) * halfTheta) / sinHalfTheta;3577            ratioB = Math.sin(t * halfTheta) / sinHalfTheta;3578            out[0] = (ax * ratioA + bx * ratioB);3579            out[1] = (ay * ratioA + by * ratioB);3580            out[2] = (az * ratioA + bz * ratioB);3581            out[3] = (aw * ratioA + bw * ratioB);3582            return out;3583        };3584        /**3585         * Calculates the inverse of a quat3586         *3587         * @param {quat} out the receiving quaternion3588         * @param {quat} a quat to calculate inverse of3589         * @returns {quat} out3590         */3591        quat.invert = function(out, a) {3592            var a0 = a[0],3593                a1 = a[1],3594                a2 = a[2],3595                a3 = a[3],3596                dot = a0 * a0 + a1 * a1 + a2 * a2 + a3 * a3,3597                invDot = dot ? 1.0 / dot : 0;3598            // TODO: Would be faster to return [0,0,0,0] immediately if dot == 03599            out[0] = -a0 * invDot;3600            out[1] = -a1 * invDot;3601            out[2] = -a2 * invDot;3602            out[3] = a3 * invDot;3603            return out;3604        };3605        /**3606         * Calculates the conjugate of a quat3607         * If the quaternion is normalized, this function is faster than quat.inverse and produces the same result.3608         *3609         * @param {quat} out the receiving quaternion3610         * @param {quat} a quat to calculate conjugate of3611         * @returns {quat} out3612         */3613        quat.conjugate = function(out, a) {3614            out[0] = -a[0];3615            out[1] = -a[1];3616            out[2] = -a[2];3617            out[3] = a[3];3618            return out;3619        };3620        /**3621         * Calculates the length of a quat3622         *3623         * @param {quat} a vector to calculate length of3624         * @returns {Number} length of a3625         * @function3626         */3627        quat.length = vec4.length;3628        /**3629         * Alias for {@link quat.length}3630         * @function3631         */3632        quat.len = quat.length;3633        /**3634         * Calculates the squared length of a quat3635         *3636         * @param {quat} a vector to calculate squared length of3637         * @returns {Number} squared length of a3638         * @function3639         */3640        quat.squaredLength = vec4.squaredLength;3641        /**3642         * Alias for {@link quat.squaredLength}3643         * @function3644         */3645        quat.sqrLen = quat.squaredLength;3646        /**3647         * Normalize a quat3648         *3649         * @param {quat} out the receiving quaternion3650         * @param {quat} a quaternion to normalize3651         * @returns {quat} out3652         * @function3653         */3654        quat.normalize = vec4.normalize;3655        /**3656         * Creates a quaternion from the given 3x3 rotation matrix.3657         *3658         * @param {quat} out the receiving quaternion3659         * @param {mat3} m rotation matrix3660         * @returns {quat} out3661         * @function3662         */3663        quat.fromMat3 = (function() {3664            var s_iNext = [1, 2, 0];3665            return function(out, m) {3666                // Algorithm in Ken Shoemake's article in 1987 SIGGRAPH course notes3667                // article "Quaternion Calculus and Fast Animation".3668                var fTrace = m[0] + m[4] + m[8];3669                var fRoot;3670                if (fTrace > 0.0) {3671                    // |w| > 1/2, may as well choose w > 1/23672                    fRoot = Math.sqrt(fTrace + 1.0); // 2w3673                    out[3] = 0.5 * fRoot;3674                    fRoot = 0.5 / fRoot; // 1/(4w)3675                    out[0] = (m[7] - m[5]) * fRoot;3676                    out[1] = (m[2] - m[6]) * fRoot;3677                    out[2] = (m[3] - m[1]) * fRoot;3678                } else {3679                    // |w| <= 1/23680                    var i = 0;3681                    if (m[4] > m[0])3682                        i = 1;3683                    if (m[8] > m[i * 3 + i])3684                        i = 2;3685                    var j = s_iNext[i];3686                    var k = s_iNext[j];3687                    fRoot = Math.sqrt(m[i * 3 + i] - m[j * 3 + j] - m[k * 3 + k] + 1.0);3688                    out[i] = 0.5 * fRoot;3689                    fRoot = 0.5 / fRoot;3690                    out[3] = (m[k * 3 + j] - m[j * 3 + k]) * fRoot;3691                    out[j] = (m[j * 3 + i] + m[i * 3 + j]) * fRoot;3692                    out[k] = (m[k * 3 + i] + m[i * 3 + k]) * fRoot;3693                }3694                return out;3695            };3696        })();3697        /**3698         * Returns a string representation of a quatenion3699         *3700         * @param {quat} vec vector to represent as a string3701         * @returns {String} string representation of the vector3702         */3703        quat.str = function(a) {3704            return 'quat(' + a[0] + ', ' + a[1] + ', ' + a[2] + ', ' + a[3] + ')';3705        };3706        if (typeof(exports) !== 'undefined') {3707            exports.quat = quat;3708        };3709    })(shim.exports);...

mat4.js

Source:mat4.js

1import * 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 mat45 */6/**7 * Creates a new identity mat48 *9 * @returns {mat4} a new 4x4 matrix10 */11export function create() {12  let out = new glMatrix.ARRAY_TYPE(16);13  if (glMatrix.ARRAY_TYPE != Float32Array) {14    out[1] = 0;15    out[2] = 0;16    out[3] = 0;17    out[4] = 0;18    out[6] = 0;19    out[7] = 0;20    out[8] = 0;21    out[9] = 0;22    out[11] = 0;23    out[12] = 0;24    out[13] = 0;25    out[14] = 0;26  }27  out[0] = 1;28  out[5] = 1;29  out[10] = 1;30  out[15] = 1;31  return out;32}33/**34 * Creates a new mat4 initialized with values from an existing matrix35 *36 * @param {ReadonlyMat4} a matrix to clone37 * @returns {mat4} a new 4x4 matrix38 */39export function clone(a) {40  let out = new glMatrix.ARRAY_TYPE(16);41  out[0] = a[0];42  out[1] = a[1];43  out[2] = a[2];44  out[3] = a[3];45  out[4] = a[4];46  out[5] = a[5];47  out[6] = a[6];48  out[7] = a[7];49  out[8] = a[8];50  out[9] = a[9];51  out[10] = a[10];52  out[11] = a[11];53  out[12] = a[12];54  out[13] = a[13];55  out[14] = a[14];56  out[15] = a[15];57  return out;58}59/**60 * Copy the values from one mat4 to another61 *62 * @param {mat4} out the receiving matrix63 * @param {ReadonlyMat4} a the source matrix64 * @returns {mat4} out65 */66export function copy(out, a) {67  out[0] = a[0];68  out[1] = a[1];69  out[2] = a[2];70  out[3] = a[3];71  out[4] = a[4];72  out[5] = a[5];73  out[6] = a[6];74  out[7] = a[7];75  out[8] = a[8];76  out[9] = a[9];77  out[10] = a[10];78  out[11] = a[11];79  out[12] = a[12];80  out[13] = a[13];81  out[14] = a[14];82  out[15] = a[15];83  return out;84}85/**86 * Create a new mat4 with the given values87 *88 * @param {Number} m00 Component in column 0, row 0 position (index 0)89 * @param {Number} m01 Component in column 0, row 1 position (index 1)90 * @param {Number} m02 Component in column 0, row 2 position (index 2)91 * @param {Number} m03 Component in column 0, row 3 position (index 3)92 * @param {Number} m10 Component in column 1, row 0 position (index 4)93 * @param {Number} m11 Component in column 1, row 1 position (index 5)94 * @param {Number} m12 Component in column 1, row 2 position (index 6)95 * @param {Number} m13 Component in column 1, row 3 position (index 7)96 * @param {Number} m20 Component in column 2, row 0 position (index 8)97 * @param {Number} m21 Component in column 2, row 1 position (index 9)98 * @param {Number} m22 Component in column 2, row 2 position (index 10)99 * @param {Number} m23 Component in column 2, row 3 position (index 11)100 * @param {Number} m30 Component in column 3, row 0 position (index 12)101 * @param {Number} m31 Component in column 3, row 1 position (index 13)102 * @param {Number} m32 Component in column 3, row 2 position (index 14)103 * @param {Number} m33 Component in column 3, row 3 position (index 15)104 * @returns {mat4} A new mat4105 */106export function fromValues(107  m00,108  m01,109  m02,110  m03,111  m10,112  m11,113  m12,114  m13,115  m20,116  m21,117  m22,118  m23,119  m30,120  m31,121  m32,122  m33123) {124  let out = new glMatrix.ARRAY_TYPE(16);125  out[0] = m00;126  out[1] = m01;127  out[2] = m02;128  out[3] = m03;129  out[4] = m10;130  out[5] = m11;131  out[6] = m12;132  out[7] = m13;133  out[8] = m20;134  out[9] = m21;135  out[10] = m22;136  out[11] = m23;137  out[12] = m30;138  out[13] = m31;139  out[14] = m32;140  out[15] = m33;141  return out;142}143/**144 * Set the components of a mat4 to the given values145 *146 * @param {mat4} out the receiving matrix147 * @param {Number} m00 Component in column 0, row 0 position (index 0)148 * @param {Number} m01 Component in column 0, row 1 position (index 1)149 * @param {Number} m02 Component in column 0, row 2 position (index 2)150 * @param {Number} m03 Component in column 0, row 3 position (index 3)151 * @param {Number} m10 Component in column 1, row 0 position (index 4)152 * @param {Number} m11 Component in column 1, row 1 position (index 5)153 * @param {Number} m12 Component in column 1, row 2 position (index 6)154 * @param {Number} m13 Component in column 1, row 3 position (index 7)155 * @param {Number} m20 Component in column 2, row 0 position (index 8)156 * @param {Number} m21 Component in column 2, row 1 position (index 9)157 * @param {Number} m22 Component in column 2, row 2 position (index 10)158 * @param {Number} m23 Component in column 2, row 3 position (index 11)159 * @param {Number} m30 Component in column 3, row 0 position (index 12)160 * @param {Number} m31 Component in column 3, row 1 position (index 13)161 * @param {Number} m32 Component in column 3, row 2 position (index 14)162 * @param {Number} m33 Component in column 3, row 3 position (index 15)163 * @returns {mat4} out164 */165export function set(166  out,167  m00,168  m01,169  m02,170  m03,171  m10,172  m11,173  m12,174  m13,175  m20,176  m21,177  m22,178  m23,179  m30,180  m31,181  m32,182  m33183) {184  out[0] = m00;185  out[1] = m01;186  out[2] = m02;187  out[3] = m03;188  out[4] = m10;189  out[5] = m11;190  out[6] = m12;191  out[7] = m13;192  out[8] = m20;193  out[9] = m21;194  out[10] = m22;195  out[11] = m23;196  out[12] = m30;197  out[13] = m31;198  out[14] = m32;199  out[15] = m33;200  return out;201}202/**203 * Set a mat4 to the identity matrix204 *205 * @param {mat4} out the receiving matrix206 * @returns {mat4} out207 */208export function identity(out) {209  out[0] = 1;210  out[1] = 0;211  out[2] = 0;212  out[3] = 0;213  out[4] = 0;214  out[5] = 1;215  out[6] = 0;216  out[7] = 0;217  out[8] = 0;218  out[9] = 0;219  out[10] = 1;220  out[11] = 0;221  out[12] = 0;222  out[13] = 0;223  out[14] = 0;224  out[15] = 1;225  return out;226}227/**228 * Transpose the values of a mat4229 *230 * @param {mat4} out the receiving matrix231 * @param {ReadonlyMat4} a the source matrix232 * @returns {mat4} out233 */234export function transpose(out, a) {235  // If we are transposing ourselves we can skip a few steps but have to cache some values236  if (out === a) {237    let a01 = a[1],238      a02 = a[2],239      a03 = a[3];240    let a12 = a[6],241      a13 = a[7];242    let a23 = a[11];243    out[1] = a[4];244    out[2] = a[8];245    out[3] = a[12];246    out[4] = a01;247    out[6] = a[9];248    out[7] = a[13];249    out[8] = a02;250    out[9] = a12;251    out[11] = a[14];252    out[12] = a03;253    out[13] = a13;254    out[14] = a23;255  } else {256    out[0] = a[0];257    out[1] = a[4];258    out[2] = a[8];259    out[3] = a[12];260    out[4] = a[1];261    out[5] = a[5];262    out[6] = a[9];263    out[7] = a[13];264    out[8] = a[2];265    out[9] = a[6];266    out[10] = a[10];267    out[11] = a[14];268    out[12] = a[3];269    out[13] = a[7];270    out[14] = a[11];271    out[15] = a[15];272  }273  return out;274}275/**276 * Inverts a mat4277 *278 * @param {mat4} out the receiving matrix279 * @param {ReadonlyMat4} a the source matrix280 * @returns {mat4} out281 */282export function invert(out, a) {283  let a00 = a[0],284    a01 = a[1],285    a02 = a[2],286    a03 = a[3];287  let a10 = a[4],288    a11 = a[5],289    a12 = a[6],290    a13 = a[7];291  let a20 = a[8],292    a21 = a[9],293    a22 = a[10],294    a23 = a[11];295  let a30 = a[12],296    a31 = a[13],297    a32 = a[14],298    a33 = a[15];299  let b00 = a00 * a11 - a01 * a10;300  let b01 = a00 * a12 - a02 * a10;301  let b02 = a00 * a13 - a03 * a10;302  let b03 = a01 * a12 - a02 * a11;303  let b04 = a01 * a13 - a03 * a11;304  let b05 = a02 * a13 - a03 * a12;305  let b06 = a20 * a31 - a21 * a30;306  let b07 = a20 * a32 - a22 * a30;307  let b08 = a20 * a33 - a23 * a30;308  let b09 = a21 * a32 - a22 * a31;309  let b10 = a21 * a33 - a23 * a31;310  let b11 = a22 * a33 - a23 * a32;311  // Calculate the determinant312  let det =313    b00 * b11 - b01 * b10 + b02 * b09 + b03 * b08 - b04 * b07 + b05 * b06;314  if (!det) {315    return null;316  }317  det = 1.0 / det;318  out[0] = (a11 * b11 - a12 * b10 + a13 * b09) * det;319  out[1] = (a02 * b10 - a01 * b11 - a03 * b09) * det;320  out[2] = (a31 * b05 - a32 * b04 + a33 * b03) * det;321  out[3] = (a22 * b04 - a21 * b05 - a23 * b03) * det;322  out[4] = (a12 * b08 - a10 * b11 - a13 * b07) * det;323  out[5] = (a00 * b11 - a02 * b08 + a03 * b07) * det;324  out[6] = (a32 * b02 - a30 * b05 - a33 * b01) * det;325  out[7] = (a20 * b05 - a22 * b02 + a23 * b01) * det;326  out[8] = (a10 * b10 - a11 * b08 + a13 * b06) * det;327  out[9] = (a01 * b08 - a00 * b10 - a03 * b06) * det;328  out[10] = (a30 * b04 - a31 * b02 + a33 * b00) * det;329  out[11] = (a21 * b02 - a20 * b04 - a23 * b00) * det;330  out[12] = (a11 * b07 - a10 * b09 - a12 * b06) * det;331  out[13] = (a00 * b09 - a01 * b07 + a02 * b06) * det;332  out[14] = (a31 * b01 - a30 * b03 - a32 * b00) * det;333  out[15] = (a20 * b03 - a21 * b01 + a22 * b00) * det;334  return out;335}336/**337 * Calculates the adjugate of a mat4338 *339 * @param {mat4} out the receiving matrix340 * @param {ReadonlyMat4} a the source matrix341 * @returns {mat4} out342 */343export function adjoint(out, a) {344  let a00 = a[0],345    a01 = a[1],346    a02 = a[2],347    a03 = a[3];348  let a10 = a[4],349    a11 = a[5],350    a12 = a[6],351    a13 = a[7];352  let a20 = a[8],353    a21 = a[9],354    a22 = a[10],355    a23 = a[11];356  let a30 = a[12],357    a31 = a[13],358    a32 = a[14],359    a33 = a[15];360  let b00 = a00 * a11 - a01 * a10;361  let b01 = a00 * a12 - a02 * a10;362  let b02 = a00 * a13 - a03 * a10;363  let b03 = a01 * a12 - a02 * a11;364  let b04 = a01 * a13 - a03 * a11;365  let b05 = a02 * a13 - a03 * a12;366  let b06 = a20 * a31 - a21 * a30;367  let b07 = a20 * a32 - a22 * a30;368  let b08 = a20 * a33 - a23 * a30;369  let b09 = a21 * a32 - a22 * a31;370  let b10 = a21 * a33 - a23 * a31;371  let b11 = a22 * a33 - a23 * a32;372  out[0] = a11 * b11 - a12 * b10 + a13 * b09;373  out[1] = a02 * b10 - a01 * b11 - a03 * b09;374  out[2] = a31 * b05 - a32 * b04 + a33 * b03;375  out[3] = a22 * b04 - a21 * b05 - a23 * b03;376  out[4] = a12 * b08 - a10 * b11 - a13 * b07;377  out[5] = a00 * b11 - a02 * b08 + a03 * b07;378  out[6] = a32 * b02 - a30 * b05 - a33 * b01;379  out[7] = a20 * b05 - a22 * b02 + a23 * b01;380  out[8] = a10 * b10 - a11 * b08 + a13 * b06;381  out[9] = a01 * b08 - a00 * b10 - a03 * b06;382  out[10] = a30 * b04 - a31 * b02 + a33 * b00;383  out[11] = a21 * b02 - a20 * b04 - a23 * b00;384  out[12] = a11 * b07 - a10 * b09 - a12 * b06;385  out[13] = a00 * b09 - a01 * b07 + a02 * b06;386  out[14] = a31 * b01 - a30 * b03 - a32 * b00;387  out[15] = a20 * b03 - a21 * b01 + a22 * b00;388  return out;389}390/**391 * Calculates the determinant of a mat4392 *393 * @param {ReadonlyMat4} a the source matrix394 * @returns {Number} determinant of a395 */396export function determinant(a) {397  let a00 = a[0],398    a01 = a[1],399    a02 = a[2],400    a03 = a[3];401  let a10 = a[4],402    a11 = a[5],403    a12 = a[6],404    a13 = a[7];405  let a20 = a[8],406    a21 = a[9],407    a22 = a[10],408    a23 = a[11];409  let a30 = a[12],410    a31 = a[13],411    a32 = a[14],412    a33 = a[15];413  let b0 = a00 * a11 - a01 * a10;414  let b1 = a00 * a12 - a02 * a10;415  let b2 = a01 * a12 - a02 * a11;416  let b3 = a20 * a31 - a21 * a30;417  let b4 = a20 * a32 - a22 * a30;418  let b5 = a21 * a32 - a22 * a31;419  let b6 = a00 * b5 - a01 * b4 + a02 * b3;420  let b7 = a10 * b5 - a11 * b4 + a12 * b3;421  let b8 = a20 * b2 - a21 * b1 + a22 * b0;422  let b9 = a30 * b2 - a31 * b1 + a32 * b0;423  // Calculate the determinant424  return a13 * b6 - a03 * b7 + a33 * b8 - a23 * b9;425}426/**427 * Multiplies two mat4s428 *429 * @param {mat4} out the receiving matrix430 * @param {ReadonlyMat4} a the first operand431 * @param {ReadonlyMat4} b the second operand432 * @returns {mat4} out433 */434export function multiply(out, a, b) {435  let a00 = a[0],436    a01 = a[1],437    a02 = a[2],438    a03 = a[3];439  let a10 = a[4],440    a11 = a[5],441    a12 = a[6],442    a13 = a[7];443  let a20 = a[8],444    a21 = a[9],445    a22 = a[10],446    a23 = a[11];447  let a30 = a[12],448    a31 = a[13],449    a32 = a[14],450    a33 = a[15];451  // Cache only the current line of the second matrix452  let b0 = b[0],453    b1 = b[1],454    b2 = b[2],455    b3 = b[3];456  out[0] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30;457  out[1] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31;458  out[2] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32;459  out[3] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33;460  b0 = b[4];461  b1 = b[5];462  b2 = b[6];463  b3 = b[7];464  out[4] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30;465  out[5] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31;466  out[6] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32;467  out[7] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33;468  b0 = b[8];469  b1 = b[9];470  b2 = b[10];471  b3 = b[11];472  out[8] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30;473  out[9] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31;474  out[10] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32;475  out[11] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33;476  b0 = b[12];477  b1 = b[13];478  b2 = b[14];479  b3 = b[15];480  out[12] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30;481  out[13] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31;482  out[14] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32;483  out[15] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33;484  return out;485}486/**487 * Translate a mat4 by the given vector488 *489 * @param {mat4} out the receiving matrix490 * @param {ReadonlyMat4} a the matrix to translate491 * @param {ReadonlyVec3} v vector to translate by492 * @returns {mat4} out493 */494export function translate(out, a, v) {495  let x = v[0],496    y = v[1],497    z = v[2];498  let a00, a01, a02, a03;499  let a10, a11, a12, a13;500  let a20, a21, a22, a23;501  if (a === out) {502    out[12] = a[0] * x + a[4] * y + a[8] * z + a[12];503    out[13] = a[1] * x + a[5] * y + a[9] * z + a[13];504    out[14] = a[2] * x + a[6] * y + a[10] * z + a[14];505    out[15] = a[3] * x + a[7] * y + a[11] * z + a[15];506  } else {507    a00 = a[0];508    a01 = a[1];509    a02 = a[2];510    a03 = a[3];511    a10 = a[4];512    a11 = a[5];513    a12 = a[6];514    a13 = a[7];515    a20 = a[8];516    a21 = a[9];517    a22 = a[10];518    a23 = a[11];519    out[0] = a00;520    out[1] = a01;521    out[2] = a02;522    out[3] = a03;523    out[4] = a10;524    out[5] = a11;525    out[6] = a12;526    out[7] = a13;527    out[8] = a20;528    out[9] = a21;529    out[10] = a22;530    out[11] = a23;531    out[12] = a00 * x + a10 * y + a20 * z + a[12];532    out[13] = a01 * x + a11 * y + a21 * z + a[13];533    out[14] = a02 * x + a12 * y + a22 * z + a[14];534    out[15] = a03 * x + a13 * y + a23 * z + a[15];535  }536  return out;537}538/**539 * Scales the mat4 by the dimensions in the given vec3 not using vectorization540 *541 * @param {mat4} out the receiving matrix542 * @param {ReadonlyMat4} a the matrix to scale543 * @param {ReadonlyVec3} v the vec3 to scale the matrix by544 * @returns {mat4} out545 **/546export function scale(out, a, v) {547  let x = v[0],548    y = v[1],549    z = v[2];550  out[0] = a[0] * x;551  out[1] = a[1] * x;552  out[2] = a[2] * x;553  out[3] = a[3] * x;554  out[4] = a[4] * y;555  out[5] = a[5] * y;556  out[6] = a[6] * y;557  out[7] = a[7] * y;558  out[8] = a[8] * z;559  out[9] = a[9] * z;560  out[10] = a[10] * z;561  out[11] = a[11] * z;562  out[12] = a[12];563  out[13] = a[13];564  out[14] = a[14];565  out[15] = a[15];566  return out;567}568/**569 * Rotates a mat4 by the given angle around the given axis570 *571 * @param {mat4} out the receiving matrix572 * @param {ReadonlyMat4} a the matrix to rotate573 * @param {Number} rad the angle to rotate the matrix by574 * @param {ReadonlyVec3} axis the axis to rotate around575 * @returns {mat4} out576 */577export function rotate(out, a, rad, axis) {578  let x = axis[0],579    y = axis[1],580    z = axis[2];581  let len = Math.hypot(x, y, z);582  let s, c, t;583  let a00, a01, a02, a03;584  let a10, a11, a12, a13;585  let a20, a21, a22, a23;586  let b00, b01, b02;587  let b10, b11, b12;588  let b20, b21, b22;589  if (len < glMatrix.EPSILON) {590    return null;591  }592  len = 1 / len;593  x *= len;594  y *= len;595  z *= len;596  s = Math.sin(rad);597  c = Math.cos(rad);598  t = 1 - c;599  a00 = a[0];600  a01 = a[1];601  a02 = a[2];602  a03 = a[3];603  a10 = a[4];604  a11 = a[5];605  a12 = a[6];606  a13 = a[7];607  a20 = a[8];608  a21 = a[9];609  a22 = a[10];610  a23 = a[11];611  // Construct the elements of the rotation matrix612  b00 = x * x * t + c;613  b01 = y * x * t + z * s;614  b02 = z * x * t - y * s;615  b10 = x * y * t - z * s;616  b11 = y * y * t + c;617  b12 = z * y * t + x * s;618  b20 = x * z * t + y * s;619  b21 = y * z * t - x * s;620  b22 = z * z * t + c;621  // Perform rotation-specific matrix multiplication622  out[0] = a00 * b00 + a10 * b01 + a20 * b02;623  out[1] = a01 * b00 + a11 * b01 + a21 * b02;624  out[2] = a02 * b00 + a12 * b01 + a22 * b02;625  out[3] = a03 * b00 + a13 * b01 + a23 * b02;626  out[4] = a00 * b10 + a10 * b11 + a20 * b12;627  out[5] = a01 * b10 + a11 * b11 + a21 * b12;628  out[6] = a02 * b10 + a12 * b11 + a22 * b12;629  out[7] = a03 * b10 + a13 * b11 + a23 * b12;630  out[8] = a00 * b20 + a10 * b21 + a20 * b22;631  out[9] = a01 * b20 + a11 * b21 + a21 * b22;632  out[10] = a02 * b20 + a12 * b21 + a22 * b22;633  out[11] = a03 * b20 + a13 * b21 + a23 * b22;634  if (a !== out) {635    // If the source and destination differ, copy the unchanged last row636    out[12] = a[12];637    out[13] = a[13];638    out[14] = a[14];639    out[15] = a[15];640  }641  return out;642}643/**644 * Rotates a matrix by the given angle around the X axis645 *646 * @param {mat4} out the receiving matrix647 * @param {ReadonlyMat4} a the matrix to rotate648 * @param {Number} rad the angle to rotate the matrix by649 * @returns {mat4} out650 */651export function rotateX(out, a, rad) {652  let s = Math.sin(rad);653  let c = Math.cos(rad);654  let a10 = a[4];655  let a11 = a[5];656  let a12 = a[6];657  let a13 = a[7];658  let a20 = a[8];659  let a21 = a[9];660  let a22 = a[10];661  let a23 = a[11];662  if (a !== out) {663    // If the source and destination differ, copy the unchanged rows664    out[0] = a[0];665    out[1] = a[1];666    out[2] = a[2];667    out[3] = a[3];668    out[12] = a[12];669    out[13] = a[13];670    out[14] = a[14];671    out[15] = a[15];672  }673  // Perform axis-specific matrix multiplication674  out[4] = a10 * c + a20 * s;675  out[5] = a11 * c + a21 * s;676  out[6] = a12 * c + a22 * s;677  out[7] = a13 * c + a23 * s;678  out[8] = a20 * c - a10 * s;679  out[9] = a21 * c - a11 * s;680  out[10] = a22 * c - a12 * s;681  out[11] = a23 * c - a13 * s;682  return out;683}684/**685 * Rotates a matrix by the given angle around the Y axis686 *687 * @param {mat4} out the receiving matrix688 * @param {ReadonlyMat4} a the matrix to rotate689 * @param {Number} rad the angle to rotate the matrix by690 * @returns {mat4} out691 */692export function rotateY(out, a, rad) {693  let s = Math.sin(rad);694  let c = Math.cos(rad);695  let a00 = a[0];696  let a01 = a[1];697  let a02 = a[2];698  let a03 = a[3];699  let a20 = a[8];700  let a21 = a[9];701  let a22 = a[10];702  let a23 = a[11];703  if (a !== out) {704    // If the source and destination differ, copy the unchanged rows705    out[4] = a[4];706    out[5] = a[5];707    out[6] = a[6];708    out[7] = a[7];709    out[12] = a[12];710    out[13] = a[13];711    out[14] = a[14];712    out[15] = a[15];713  }714  // Perform axis-specific matrix multiplication715  out[0] = a00 * c - a20 * s;716  out[1] = a01 * c - a21 * s;717  out[2] = a02 * c - a22 * s;718  out[3] = a03 * c - a23 * s;719  out[8] = a00 * s + a20 * c;720  out[9] = a01 * s + a21 * c;721  out[10] = a02 * s + a22 * c;722  out[11] = a03 * s + a23 * c;723  return out;724}725/**726 * Rotates a matrix by the given angle around the Z axis727 *728 * @param {mat4} out the receiving matrix729 * @param {ReadonlyMat4} a the matrix to rotate730 * @param {Number} rad the angle to rotate the matrix by731 * @returns {mat4} out732 */733export function rotateZ(out, a, rad) {734  let s = Math.sin(rad);735  let c = Math.cos(rad);736  let a00 = a[0];737  let a01 = a[1];738  let a02 = a[2];739  let a03 = a[3];740  let a10 = a[4];741  let a11 = a[5];742  let a12 = a[6];743  let a13 = a[7];744  if (a !== out) {745    // If the source and destination differ, copy the unchanged last row746    out[8] = a[8];747    out[9] = a[9];748    out[10] = a[10];749    out[11] = a[11];750    out[12] = a[12];751    out[13] = a[13];752    out[14] = a[14];753    out[15] = a[15];754  }755  // Perform axis-specific matrix multiplication756  out[0] = a00 * c + a10 * s;757  out[1] = a01 * c + a11 * s;758  out[2] = a02 * c + a12 * s;759  out[3] = a03 * c + a13 * s;760  out[4] = a10 * c - a00 * s;761  out[5] = a11 * c - a01 * s;762  out[6] = a12 * c - a02 * s;763  out[7] = a13 * c - a03 * s;764  return out;765}766/**767 * Creates a matrix from a vector translation768 * This is equivalent to (but much faster than):769 *770 *     mat4.identity(dest);771 *     mat4.translate(dest, dest, vec);772 *773 * @param {mat4} out mat4 receiving operation result774 * @param {ReadonlyVec3} v Translation vector775 * @returns {mat4} out776 */777export function fromTranslation(out, v) {778  out[0] = 1;779  out[1] = 0;780  out[2] = 0;781  out[3] = 0;782  out[4] = 0;783  out[5] = 1;784  out[6] = 0;785  out[7] = 0;786  out[8] = 0;787  out[9] = 0;788  out[10] = 1;789  out[11] = 0;790  out[12] = v[0];791  out[13] = v[1];792  out[14] = v[2];793  out[15] = 1;794  return out;795}796/**797 * Creates a matrix from a vector scaling798 * This is equivalent to (but much faster than):799 *800 *     mat4.identity(dest);801 *     mat4.scale(dest, dest, vec);802 *803 * @param {mat4} out mat4 receiving operation result804 * @param {ReadonlyVec3} v Scaling vector805 * @returns {mat4} out806 */807export function fromScaling(out, v) {808  out[0] = v[0];809  out[1] = 0;810  out[2] = 0;811  out[3] = 0;812  out[4] = 0;813  out[5] = v[1];814  out[6] = 0;815  out[7] = 0;816  out[8] = 0;817  out[9] = 0;818  out[10] = v[2];819  out[11] = 0;820  out[12] = 0;821  out[13] = 0;822  out[14] = 0;823  out[15] = 1;824  return out;825}826/**827 * Creates a matrix from a given angle around a given axis828 * This is equivalent to (but much faster than):829 *830 *     mat4.identity(dest);831 *     mat4.rotate(dest, dest, rad, axis);832 *833 * @param {mat4} out mat4 receiving operation result834 * @param {Number} rad the angle to rotate the matrix by835 * @param {ReadonlyVec3} axis the axis to rotate around836 * @returns {mat4} out837 */838export function fromRotation(out, rad, axis) {839  let x = axis[0],840    y = axis[1],841    z = axis[2];842  let len = Math.hypot(x, y, z);843  let s, c, t;844  if (len < glMatrix.EPSILON) {845    return null;846  }847  len = 1 / len;848  x *= len;849  y *= len;850  z *= len;851  s = Math.sin(rad);852  c = Math.cos(rad);853  t = 1 - c;854  // Perform rotation-specific matrix multiplication855  out[0] = x * x * t + c;856  out[1] = y * x * t + z * s;857  out[2] = z * x * t - y * s;858  out[3] = 0;859  out[4] = x * y * t - z * s;860  out[5] = y * y * t + c;861  out[6] = z * y * t + x * s;862  out[7] = 0;863  out[8] = x * z * t + y * s;864  out[9] = y * z * t - x * s;865  out[10] = z * z * t + c;866  out[11] = 0;867  out[12] = 0;868  out[13] = 0;869  out[14] = 0;870  out[15] = 1;871  return out;872}873/**874 * Creates a matrix from the given angle around the X axis875 * This is equivalent to (but much faster than):876 *877 *     mat4.identity(dest);878 *     mat4.rotateX(dest, dest, rad);879 *880 * @param {mat4} out mat4 receiving operation result881 * @param {Number} rad the angle to rotate the matrix by882 * @returns {mat4} out883 */884export function fromXRotation(out, rad) {885  let s = Math.sin(rad);886  let c = Math.cos(rad);887  // Perform axis-specific matrix multiplication888  out[0] = 1;889  out[1] = 0;890  out[2] = 0;891  out[3] = 0;892  out[4] = 0;893  out[5] = c;894  out[6] = s;895  out[7] = 0;896  out[8] = 0;897  out[9] = -s;898  out[10] = c;899  out[11] = 0;900  out[12] = 0;901  out[13] = 0;902  out[14] = 0;903  out[15] = 1;904  return out;905}906/**907 * Creates a matrix from the given angle around the Y axis908 * This is equivalent to (but much faster than):909 *910 *     mat4.identity(dest);911 *     mat4.rotateY(dest, dest, rad);912 *913 * @param {mat4} out mat4 receiving operation result914 * @param {Number} rad the angle to rotate the matrix by915 * @returns {mat4} out916 */917export function fromYRotation(out, rad) {918  let s = Math.sin(rad);919  let c = Math.cos(rad);920  // Perform axis-specific matrix multiplication921  out[0] = c;922  out[1] = 0;923  out[2] = -s;924  out[3] = 0;925  out[4] = 0;926  out[5] = 1;927  out[6] = 0;928  out[7] = 0;929  out[8] = s;930  out[9] = 0;931  out[10] = c;932  out[11] = 0;933  out[12] = 0;934  out[13] = 0;935  out[14] = 0;936  out[15] = 1;937  return out;938}939/**940 * Creates a matrix from the given angle around the Z axis941 * This is equivalent to (but much faster than):942 *943 *     mat4.identity(dest);944 *     mat4.rotateZ(dest, dest, rad);945 *946 * @param {mat4} out mat4 receiving operation result947 * @param {Number} rad the angle to rotate the matrix by948 * @returns {mat4} out949 */950export function fromZRotation(out, rad) {951  let s = Math.sin(rad);952  let c = Math.cos(rad);953  // Perform axis-specific matrix multiplication954  out[0] = c;955  out[1] = s;956  out[2] = 0;957  out[3] = 0;958  out[4] = -s;959  out[5] = c;960  out[6] = 0;961  out[7] = 0;962  out[8] = 0;963  out[9] = 0;964  out[10] = 1;965  out[11] = 0;966  out[12] = 0;967  out[13] = 0;968  out[14] = 0;969  out[15] = 1;970  return out;971}972/**973 * Creates a matrix from a quaternion rotation and vector translation974 * This is equivalent to (but much faster than):975 *976 *     mat4.identity(dest);977 *     mat4.translate(dest, vec);978 *     let quatMat = mat4.create();979 *     quat4.toMat4(quat, quatMat);980 *     mat4.multiply(dest, quatMat);981 *982 * @param {mat4} out mat4 receiving operation result983 * @param {quat4} q Rotation quaternion984 * @param {ReadonlyVec3} v Translation vector985 * @returns {mat4} out986 */987export function fromRotationTranslation(out, q, v) {988  // Quaternion math989  let x = q[0],990    y = q[1],991    z = q[2],992    w = q[3];993  let x2 = x + x;994  let y2 = y + y;995  let z2 = z + z;996  let xx = x * x2;997  let xy = x * y2;998  let xz = x * z2;999  let yy = y * y2;1000  let yz = y * z2;1001  let zz = z * z2;1002  let wx = w * x2;1003  let wy = w * y2;1004  let wz = w * z2;1005  out[0] = 1 - (yy + zz);1006  out[1] = xy + wz;1007  out[2] = xz - wy;1008  out[3] = 0;1009  out[4] = xy - wz;1010  out[5] = 1 - (xx + zz);1011  out[6] = yz + wx;1012  out[7] = 0;1013  out[8] = xz + wy;1014  out[9] = yz - wx;1015  out[10] = 1 - (xx + yy);1016  out[11] = 0;1017  out[12] = v[0];1018  out[13] = v[1];1019  out[14] = v[2];1020  out[15] = 1;1021  return out;1022}1023/**1024 * Creates a new mat4 from a dual quat.1025 *1026 * @param {mat4} out Matrix1027 * @param {ReadonlyQuat2} a Dual Quaternion1028 * @returns {mat4} mat4 receiving operation result1029 */1030export function fromQuat2(out, a) {1031  let translation = new glMatrix.ARRAY_TYPE(3);1032  let bx = -a[0],1033    by = -a[1],1034    bz = -a[2],1035    bw = a[3],1036    ax = a[4],1037    ay = a[5],1038    az = a[6],1039    aw = a[7];1040  let magnitude = bx * bx + by * by + bz * bz + bw * bw;1041  //Only scale if it makes sense1042  if (magnitude > 0) {1043    translation[0] = ((ax * bw + aw * bx + ay * bz - az * by) * 2) / magnitude;1044    translation[1] = ((ay * bw + aw * by + az * bx - ax * bz) * 2) / magnitude;1045    translation[2] = ((az * bw + aw * bz + ax * by - ay * bx) * 2) / magnitude;1046  } else {1047    translation[0] = (ax * bw + aw * bx + ay * bz - az * by) * 2;1048    translation[1] = (ay * bw + aw * by + az * bx - ax * bz) * 2;1049    translation[2] = (az * bw + aw * bz + ax * by - ay * bx) * 2;1050  }1051  fromRotationTranslation(out, a, translation);1052  return out;1053}1054/**1055 * Returns the translation vector component of a transformation1056 *  matrix. If a matrix is built with fromRotationTranslation,1057 *  the returned vector will be the same as the translation vector1058 *  originally supplied.1059 * @param  {vec3} out Vector to receive translation component1060 * @param  {ReadonlyMat4} mat Matrix to be decomposed (input)1061 * @return {vec3} out1062 */1063export function getTranslation(out, mat) {1064  out[0] = mat[12];1065  out[1] = mat[13];1066  out[2] = mat[14];1067  return out;1068}1069/**1070 * Returns the scaling factor component of a transformation1071 *  matrix. If a matrix is built with fromRotationTranslationScale1072 *  with a normalized Quaternion paramter, the returned vector will be1073 *  the same as the scaling vector1074 *  originally supplied.1075 * @param  {vec3} out Vector to receive scaling factor component1076 * @param  {ReadonlyMat4} mat Matrix to be decomposed (input)1077 * @return {vec3} out1078 */1079export function getScaling(out, mat) {1080  let m11 = mat[0];1081  let m12 = mat[1];1082  let m13 = mat[2];1083  let m21 = mat[4];1084  let m22 = mat[5];1085  let m23 = mat[6];1086  let m31 = mat[8];1087  let m32 = mat[9];1088  let m33 = mat[10];1089  out[0] = Math.hypot(m11, m12, m13);1090  out[1] = Math.hypot(m21, m22, m23);1091  out[2] = Math.hypot(m31, m32, m33);1092  return out;1093}1094/**1095 * Returns a quaternion representing the rotational component1096 *  of a transformation matrix. If a matrix is built with1097 *  fromRotationTranslation, the returned quaternion will be the1098 *  same as the quaternion originally supplied.1099 * @param {quat} out Quaternion to receive the rotation component1100 * @param {ReadonlyMat4} mat Matrix to be decomposed (input)1101 * @return {quat} out1102 */1103export function getRotation(out, mat) {1104  let scaling = new glMatrix.ARRAY_TYPE(3);1105  getScaling(scaling, mat);1106  let is1 = 1 / scaling[0];1107  let is2 = 1 / scaling[1];1108  let is3 = 1 / scaling[2];1109  let sm11 = mat[0] * is1;1110  let sm12 = mat[1] * is2;1111  let sm13 = mat[2] * is3;1112  let sm21 = mat[4] * is1;1113  let sm22 = mat[5] * is2;1114  let sm23 = mat[6] * is3;1115  let sm31 = mat[8] * is1;1116  let sm32 = mat[9] * is2;1117  let sm33 = mat[10] * is3;1118  let trace = sm11 + sm22 + sm33;1119  let S = 0;1120  if (trace > 0) {1121    S = Math.sqrt(trace + 1.0) * 2;1122    out[3] = 0.25 * S;1123    out[0] = (sm23 - sm32) / S;1124    out[1] = (sm31 - sm13) / S;1125    out[2] = (sm12 - sm21) / S;1126  } else if (sm11 > sm22 && sm11 > sm33) {1127    S = Math.sqrt(1.0 + sm11 - sm22 - sm33) * 2;1128    out[3] = (sm23 - sm32) / S;1129    out[0] = 0.25 * S;1130    out[1] = (sm12 + sm21) / S;1131    out[2] = (sm31 + sm13) / S;1132  } else if (sm22 > sm33) {1133    S = Math.sqrt(1.0 + sm22 - sm11 - sm33) * 2;1134    out[3] = (sm31 - sm13) / S;1135    out[0] = (sm12 + sm21) / S;1136    out[1] = 0.25 * S;1137    out[2] = (sm23 + sm32) / S;1138  } else {1139    S = Math.sqrt(1.0 + sm33 - sm11 - sm22) * 2;1140    out[3] = (sm12 - sm21) / S;1141    out[0] = (sm31 + sm13) / S;1142    out[1] = (sm23 + sm32) / S;1143    out[2] = 0.25 * S;1144  }1145  return out;1146}1147/**1148 * Decomposes a transformation matrix into its rotation, translation1149 * and scale components. Returns only the rotation component1150 * @param  {quat} out_r Quaternion to receive the rotation component1151 * @param  {vec3} out_t Vector to receive the translation vector1152 * @param  {vec3} out_s Vector to receive the scaling factor1153 * @param  {ReadonlyMat4} mat Matrix to be decomposed (input)1154 * @returns {quat} out_r1155 */1156export function decompose(out_r, out_t, out_s, mat) {1157  out_t[0] = mat[12];1158  out_t[1] = mat[13];1159  out_t[2] = mat[14];1160  let m11 = mat[0];1161  let m12 = mat[1];1162  let m13 = mat[2];1163  let m21 = mat[4];1164  let m22 = mat[5];1165  let m23 = mat[6];1166  let m31 = mat[8];1167  let m32 = mat[9];1168  let m33 = mat[10];1169  out_s[0] = Math.hypot(m11, m12, m13);1170  out_s[1] = Math.hypot(m21, m22, m23);1171  out_s[2] = Math.hypot(m31, m32, m33);1172  let is1 = 1 / out_s[0];1173  let is2 = 1 / out_s[1];1174  let is3 = 1 / out_s[2];1175  let sm11 = m11 * is1;1176  let sm12 = m12 * is2;1177  let sm13 = m13 * is3;1178  let sm21 = m21 * is1;1179  let sm22 = m22 * is2;1180  let sm23 = m23 * is3;1181  let sm31 = m31 * is1;1182  let sm32 = m32 * is2;1183  let sm33 = m33 * is3;1184  let trace = sm11 + sm22 + sm33;1185  let S = 0;1186  if (trace > 0) {1187    S = Math.sqrt(trace + 1.0) * 2;1188    out_r[3] = 0.25 * S;1189    out_r[0] = (sm23 - sm32) / S;1190    out_r[1] = (sm31 - sm13) / S;1191    out_r[2] = (sm12 - sm21) / S;1192  } else if (sm11 > sm22 && sm11 > sm33) {1193    S = Math.sqrt(1.0 + sm11 - sm22 - sm33) * 2;1194    out_r[3] = (sm23 - sm32) / S;1195    out_r[0] = 0.25 * S;1196    out_r[1] = (sm12 + sm21) / S;1197    out_r[2] = (sm31 + sm13) / S;1198  } else if (sm22 > sm33) {1199    S = Math.sqrt(1.0 + sm22 - sm11 - sm33) * 2;1200    out_r[3] = (sm31 - sm13) / S;1201    out_r[0] = (sm12 + sm21) / S;1202    out_r[1] = 0.25 * S;1203    out_r[2] = (sm23 + sm32) / S;1204  } else {1205    S = Math.sqrt(1.0 + sm33 - sm11 - sm22) * 2;1206    out_r[3] = (sm12 - sm21) / S;1207    out_r[0] = (sm31 + sm13) / S;1208    out_r[1] = (sm23 + sm32) / S;1209    out_r[2] = 0.25 * S;1210  }1211  return out_r;1212}1213/**1214 * Creates a matrix from a quaternion rotation, vector translation and vector scale1215 * This is equivalent to (but much faster than):1216 *1217 *     mat4.identity(dest);1218 *     mat4.translate(dest, vec);1219 *     let quatMat = mat4.create();1220 *     quat4.toMat4(quat, quatMat);1221 *     mat4.multiply(dest, quatMat);1222 *     mat4.scale(dest, scale)1223 *1224 * @param {mat4} out mat4 receiving operation result1225 * @param {quat4} q Rotation quaternion1226 * @param {ReadonlyVec3} v Translation vector1227 * @param {ReadonlyVec3} s Scaling vector1228 * @returns {mat4} out1229 */1230export function fromRotationTranslationScale(out, q, v, s) {1231  // Quaternion math1232  let x = q[0],1233    y = q[1],1234    z = q[2],1235    w = q[3];1236  let x2 = x + x;1237  let y2 = y + y;1238  let z2 = z + z;1239  let xx = x * x2;1240  let xy = x * y2;1241  let xz = x * z2;1242  let yy = y * y2;1243  let yz = y * z2;1244  let zz = z * z2;1245  let wx = w * x2;1246  let wy = w * y2;1247  let wz = w * z2;1248  let sx = s[0];1249  let sy = s[1];1250  let sz = s[2];1251  out[0] = (1 - (yy + zz)) * sx;1252  out[1] = (xy + wz) * sx;1253  out[2] = (xz - wy) * sx;1254  out[3] = 0;1255  out[4] = (xy - wz) * sy;1256  out[5] = (1 - (xx + zz)) * sy;1257  out[6] = (yz + wx) * sy;1258  out[7] = 0;1259  out[8] = (xz + wy) * sz;1260  out[9] = (yz - wx) * sz;1261  out[10] = (1 - (xx + yy)) * sz;1262  out[11] = 0;1263  out[12] = v[0];1264  out[13] = v[1];1265  out[14] = v[2];1266  out[15] = 1;1267  return out;1268}1269/**1270 * Creates a matrix from a quaternion rotation, vector translation and vector scale, rotating and scaling around the given origin1271 * This is equivalent to (but much faster than):1272 *1273 *     mat4.identity(dest);1274 *     mat4.translate(dest, vec);1275 *     mat4.translate(dest, origin);1276 *     let quatMat = mat4.create();1277 *     quat4.toMat4(quat, quatMat);1278 *     mat4.multiply(dest, quatMat);1279 *     mat4.scale(dest, scale)1280 *     mat4.translate(dest, negativeOrigin);1281 *1282 * @param {mat4} out mat4 receiving operation result1283 * @param {quat4} q Rotation quaternion1284 * @param {ReadonlyVec3} v Translation vector1285 * @param {ReadonlyVec3} s Scaling vector1286 * @param {ReadonlyVec3} o The origin vector around which to scale and rotate1287 * @returns {mat4} out1288 */1289export function fromRotationTranslationScaleOrigin(out, q, v, s, o) {1290  // Quaternion math1291  let x = q[0],1292    y = q[1],1293    z = q[2],1294    w = q[3];1295  let x2 = x + x;1296  let y2 = y + y;1297  let z2 = z + z;1298  let xx = x * x2;1299  let xy = x * y2;1300  let xz = x * z2;1301  let yy = y * y2;1302  let yz = y * z2;1303  let zz = z * z2;1304  let wx = w * x2;1305  let wy = w * y2;1306  let wz = w * z2;1307  let sx = s[0];1308  let sy = s[1];1309  let sz = s[2];1310  let ox = o[0];1311  let oy = o[1];1312  let oz = o[2];1313  let out0 = (1 - (yy + zz)) * sx;1314  let out1 = (xy + wz) * sx;1315  let out2 = (xz - wy) * sx;1316  let out4 = (xy - wz) * sy;1317  let out5 = (1 - (xx + zz)) * sy;1318  let out6 = (yz + wx) * sy;1319  let out8 = (xz + wy) * sz;1320  let out9 = (yz - wx) * sz;1321  let out10 = (1 - (xx + yy)) * sz;1322  out[0] = out0;1323  out[1] = out1;1324  out[2] = out2;1325  out[3] = 0;1326  out[4] = out4;1327  out[5] = out5;1328  out[6] = out6;1329  out[7] = 0;1330  out[8] = out8;1331  out[9] = out9;1332  out[10] = out10;1333  out[11] = 0;1334  out[12] = v[0] + ox - (out0 * ox + out4 * oy + out8 * oz);1335  out[13] = v[1] + oy - (out1 * ox + out5 * oy + out9 * oz);1336  out[14] = v[2] + oz - (out2 * ox + out6 * oy + out10 * oz);1337  out[15] = 1;1338  return out;1339}1340/**1341 * Calculates a 4x4 matrix from the given quaternion1342 *1343 * @param {mat4} out mat4 receiving operation result1344 * @param {ReadonlyQuat} q Quaternion to create matrix from1345 *1346 * @returns {mat4} out1347 */1348export function fromQuat(out, q) {1349  let x = q[0],1350    y = q[1],1351    z = q[2],1352    w = q[3];1353  let x2 = x + x;1354  let y2 = y + y;1355  let z2 = z + z;1356  let xx = x * x2;1357  let yx = y * x2;1358  let yy = y * y2;1359  let zx = z * x2;1360  let zy = z * y2;1361  let zz = z * z2;1362  let wx = w * x2;1363  let wy = w * y2;1364  let wz = w * z2;1365  out[0] = 1 - yy - zz;1366  out[1] = yx + wz;1367  out[2] = zx - wy;1368  out[3] = 0;1369  out[4] = yx - wz;1370  out[5] = 1 - xx - zz;1371  out[6] = zy + wx;1372  out[7] = 0;1373  out[8] = zx + wy;1374  out[9] = zy - wx;1375  out[10] = 1 - xx - yy;1376  out[11] = 0;1377  out[12] = 0;1378  out[13] = 0;1379  out[14] = 0;1380  out[15] = 1;1381  return out;1382}1383/**1384 * Generates a frustum matrix with the given bounds1385 *1386 * @param {mat4} out mat4 frustum matrix will be written into1387 * @param {Number} left Left bound of the frustum1388 * @param {Number} right Right bound of the frustum1389 * @param {Number} bottom Bottom bound of the frustum1390 * @param {Number} top Top bound of the frustum1391 * @param {Number} near Near bound of the frustum1392 * @param {Number} far Far bound of the frustum1393 * @returns {mat4} out1394 */1395export function frustum(out, left, right, bottom, top, near, far) {1396  let rl = 1 / (right - left);1397  let tb = 1 / (top - bottom);1398  let nf = 1 / (near - far);1399  out[0] = near * 2 * rl;1400  out[1] = 0;1401  out[2] = 0;1402  out[3] = 0;1403  out[4] = 0;1404  out[5] = near * 2 * tb;1405  out[6] = 0;1406  out[7] = 0;1407  out[8] = (right + left) * rl;1408  out[9] = (top + bottom) * tb;1409  out[10] = (far + near) * nf;1410  out[11] = -1;1411  out[12] = 0;1412  out[13] = 0;1413  out[14] = far * near * 2 * nf;1414  out[15] = 0;1415  return out;1416}1417/**1418 * Generates a perspective projection matrix with the given bounds.1419 * Passing null/undefined/no value for far will generate infinite projection matrix.1420 *1421 * @param {mat4} out mat4 frustum matrix will be written into1422 * @param {number} fovy Vertical field of view in radians1423 * @param {number} aspect Aspect ratio. typically viewport width/height1424 * @param {number} near Near bound of the frustum1425 * @param {number} far Far bound of the frustum, can be null or Infinity1426 * @returns {mat4} out1427 */1428export function perspective(out, fovy, aspect, near, far) {1429  let f = 1.0 / Math.tan(fovy / 2),1430    nf;1431  out[0] = f / aspect;1432  out[1] = 0;1433  out[2] = 0;1434  out[3] = 0;1435  out[4] = 0;1436  out[5] = f;1437  out[6] = 0;1438  out[7] = 0;1439  out[8] = 0;1440  out[9] = 0;1441  out[11] = -1;1442  out[12] = 0;1443  out[13] = 0;1444  out[15] = 0;1445  if (far != null && far !== Infinity) {1446    nf = 1 / (near - far);1447    out[10] = (far + near) * nf;1448    out[14] = 2 * far * near * nf;1449  } else {1450    out[10] = -1;1451    out[14] = -2 * near;1452  }1453  return out;1454}1455/**1456 * Generates a perspective projection matrix with the given field of view.1457 * This is primarily useful for generating projection matrices to be used1458 * with the still experiemental WebVR API.1459 *1460 * @param {mat4} out mat4 frustum matrix will be written into1461 * @param {Object} fov Object containing the following values: upDegrees, downDegrees, leftDegrees, rightDegrees1462 * @param {number} near Near bound of the frustum1463 * @param {number} far Far bound of the frustum1464 * @returns {mat4} out1465 */1466export function perspectiveFromFieldOfView(out, fov, near, far) {1467  let upTan = Math.tan((fov.upDegrees * Math.PI) / 180.0);1468  let downTan = Math.tan((fov.downDegrees * Math.PI) / 180.0);1469  let leftTan = Math.tan((fov.leftDegrees * Math.PI) / 180.0);1470  let rightTan = Math.tan((fov.rightDegrees * Math.PI) / 180.0);1471  let xScale = 2.0 / (leftTan + rightTan);1472  let yScale = 2.0 / (upTan + downTan);1473  out[0] = xScale;1474  out[1] = 0.0;1475  out[2] = 0.0;1476  out[3] = 0.0;1477  out[4] = 0.0;1478  out[5] = yScale;1479  out[6] = 0.0;1480  out[7] = 0.0;1481  out[8] = -((leftTan - rightTan) * xScale * 0.5);1482  out[9] = (upTan - downTan) * yScale * 0.5;1483  out[10] = far / (near - far);1484  out[11] = -1.0;1485  out[12] = 0.0;1486  out[13] = 0.0;1487  out[14] = (far * near) / (near - far);1488  out[15] = 0.0;1489  return out;1490}1491/**1492 * Generates a orthogonal projection matrix with the given bounds1493 *1494 * @param {mat4} out mat4 frustum matrix will be written into1495 * @param {number} left Left bound of the frustum1496 * @param {number} right Right bound of the frustum1497 * @param {number} bottom Bottom bound of the frustum1498 * @param {number} top Top bound of the frustum1499 * @param {number} near Near bound of the frustum1500 * @param {number} far Far bound of the frustum1501 * @returns {mat4} out1502 */1503export function ortho(out, left, right, bottom, top, near, far) {1504  let lr = 1 / (left - right);1505  let bt = 1 / (bottom - top);1506  let nf = 1 / (near - far);1507  out[0] = -2 * lr;1508  out[1] = 0;1509  out[2] = 0;1510  out[3] = 0;1511  out[4] = 0;1512  out[5] = -2 * bt;1513  out[6] = 0;1514  out[7] = 0;1515  out[8] = 0;1516  out[9] = 0;1517  out[10] = 2 * nf;1518  out[11] = 0;1519  out[12] = (left + right) * lr;1520  out[13] = (top + bottom) * bt;1521  out[14] = (far + near) * nf;1522  out[15] = 1;1523  return out;1524}1525/**1526 * Generates a look-at matrix with the given eye position, focal point, and up axis.1527 * If you want a matrix that actually makes an object look at another object, you should use targetTo instead.1528 *1529 * @param {mat4} out mat4 frustum matrix will be written into1530 * @param {ReadonlyVec3} eye Position of the viewer1531 * @param {ReadonlyVec3} center Point the viewer is looking at1532 * @param {ReadonlyVec3} up vec3 pointing up1533 * @returns {mat4} out1534 */1535export function lookAt(out, eye, center, up) {1536  let x0, x1, x2, y0, y1, y2, z0, z1, z2, len;1537  let eyex = eye[0];1538  let eyey = eye[1];1539  let eyez = eye[2];1540  let upx = up[0];1541  let upy = up[1];1542  let upz = up[2];1543  let centerx = center[0];1544  let centery = center[1];1545  let centerz = center[2];1546  if (1547    Math.abs(eyex - centerx) < glMatrix.EPSILON &&1548    Math.abs(eyey - centery) < glMatrix.EPSILON &&1549    Math.abs(eyez - centerz) < glMatrix.EPSILON1550  ) {1551    return identity(out);1552  }1553  z0 = eyex - centerx;1554  z1 = eyey - centery;1555  z2 = eyez - centerz;1556  len = 1 / Math.hypot(z0, z1, z2);1557  z0 *= len;1558  z1 *= len;1559  z2 *= len;1560  x0 = upy * z2 - upz * z1;1561  x1 = upz * z0 - upx * z2;1562  x2 = upx * z1 - upy * z0;1563  len = Math.hypot(x0, x1, x2);1564  if (!len) {1565    x0 = 0;1566    x1 = 0;1567    x2 = 0;1568  } else {1569    len = 1 / len;1570    x0 *= len;1571    x1 *= len;1572    x2 *= len;1573  }1574  y0 = z1 * x2 - z2 * x1;1575  y1 = z2 * x0 - z0 * x2;1576  y2 = z0 * x1 - z1 * x0;1577  len = Math.hypot(y0, y1, y2);1578  if (!len) {1579    y0 = 0;1580    y1 = 0;1581    y2 = 0;1582  } else {1583    len = 1 / len;1584    y0 *= len;1585    y1 *= len;1586    y2 *= len;1587  }1588  out[0] = x0;1589  out[1] = y0;1590  out[2] = z0;1591  out[3] = 0;1592  out[4] = x1;1593  out[5] = y1;1594  out[6] = z1;1595  out[7] = 0;1596  out[8] = x2;1597  out[9] = y2;1598  out[10] = z2;1599  out[11] = 0;1600  out[12] = -(x0 * eyex + x1 * eyey + x2 * eyez);1601  out[13] = -(y0 * eyex + y1 * eyey + y2 * eyez);1602  out[14] = -(z0 * eyex + z1 * eyey + z2 * eyez);1603  out[15] = 1;1604  return out;1605}1606/**1607 * Generates a matrix that makes something look at something else.1608 *1609 * @param {mat4} out mat4 frustum matrix will be written into1610 * @param {ReadonlyVec3} eye Position of the viewer1611 * @param {ReadonlyVec3} center Point the viewer is looking at1612 * @param {ReadonlyVec3} up vec3 pointing up1613 * @returns {mat4} out1614 */1615export function targetTo(out, eye, target, up) {1616  let eyex = eye[0],1617    eyey = eye[1],1618    eyez = eye[2],1619    upx = up[0],1620    upy = up[1],1621    upz = up[2];1622  let z0 = eyex - target[0],1623    z1 = eyey - target[1],1624    z2 = eyez - target[2];1625  let len = z0 * z0 + z1 * z1 + z2 * z2;1626  if (len > 0) {1627    len = 1 / Math.sqrt(len);1628    z0 *= len;1629    z1 *= len;1630    z2 *= len;1631  }1632  let x0 = upy * z2 - upz * z1,1633    x1 = upz * z0 - upx * z2,1634    x2 = upx * z1 - upy * z0;1635  len = x0 * x0 + x1 * x1 + x2 * x2;1636  if (len > 0) {1637    len = 1 / Math.sqrt(len);1638    x0 *= len;1639    x1 *= len;1640    x2 *= len;1641  }1642  out[0] = x0;1643  out[1] = x1;1644  out[2] = x2;1645  out[3] = 0;1646  out[4] = z1 * x2 - z2 * x1;1647  out[5] = z2 * x0 - z0 * x2;1648  out[6] = z0 * x1 - z1 * x0;1649  out[7] = 0;1650  out[8] = z0;1651  out[9] = z1;1652  out[10] = z2;1653  out[11] = 0;1654  out[12] = eyex;1655  out[13] = eyey;1656  out[14] = eyez;1657  out[15] = 1;1658  return out;1659}1660/**1661 * Returns a string representation of a mat41662 *1663 * @param {ReadonlyMat4} a matrix to represent as a string1664 * @returns {String} string representation of the matrix1665 */1666export function str(a) {1667  return (1668    "mat4(" +1669    a[0] +1670    ", " +1671    a[1] +1672    ", " +1673    a[2] +1674    ", " +1675    a[3] +1676    ", " +1677    a[4] +1678    ", " +1679    a[5] +1680    ", " +1681    a[6] +1682    ", " +1683    a[7] +1684    ", " +1685    a[8] +1686    ", " +1687    a[9] +1688    ", " +1689    a[10] +1690    ", " +1691    a[11] +1692    ", " +1693    a[12] +1694    ", " +1695    a[13] +1696    ", " +1697    a[14] +1698    ", " +1699    a[15] +1700    ")"1701  );1702}1703/**1704 * Returns Frobenius norm of a mat41705 *1706 * @param {ReadonlyMat4} a the matrix to calculate Frobenius norm of1707 * @returns {Number} Frobenius norm1708 */1709export function frob(a) {1710  return Math.hypot(1711    a[0],1712    a[1],1713    a[2],1714    a[3],1715    a[4],1716    a[5],1717    a[6],1718    a[7],1719    a[8],1720    a[9],1721    a[10],1722    a[11],1723    a[12],1724    a[13],1725    a[14],1726    a[15]1727  );1728}1729/**1730 * Adds two mat4's1731 *1732 * @param {mat4} out the receiving matrix1733 * @param {ReadonlyMat4} a the first operand1734 * @param {ReadonlyMat4} b the second operand1735 * @returns {mat4} out1736 */1737export function add(out, a, b) {1738  out[0] = a[0] + b[0];1739  out[1] = a[1] + b[1];1740  out[2] = a[2] + b[2];1741  out[3] = a[3] + b[3];1742  out[4] = a[4] + b[4];1743  out[5] = a[5] + b[5];1744  out[6] = a[6] + b[6];1745  out[7] = a[7] + b[7];1746  out[8] = a[8] + b[8];1747  out[9] = a[9] + b[9];1748  out[10] = a[10] + b[10];1749  out[11] = a[11] + b[11];1750  out[12] = a[12] + b[12];1751  out[13] = a[13] + b[13];1752  out[14] = a[14] + b[14];1753  out[15] = a[15] + b[15];1754  return out;1755}1756/**1757 * Subtracts matrix b from matrix a1758 *1759 * @param {mat4} out the receiving matrix1760 * @param {ReadonlyMat4} a the first operand1761 * @param {ReadonlyMat4} b the second operand1762 * @returns {mat4} out1763 */1764export function subtract(out, a, b) {1765  out[0] = a[0] - b[0];1766  out[1] = a[1] - b[1];1767  out[2] = a[2] - b[2];1768  out[3] = a[3] - b[3];1769  out[4] = a[4] - b[4];1770  out[5] = a[5] - b[5];1771  out[6] = a[6] - b[6];1772  out[7] = a[7] - b[7];1773  out[8] = a[8] - b[8];1774  out[9] = a[9] - b[9];1775  out[10] = a[10] - b[10];1776  out[11] = a[11] - b[11];1777  out[12] = a[12] - b[12];1778  out[13] = a[13] - b[13];1779  out[14] = a[14] - b[14];1780  out[15] = a[15] - b[15];1781  return out;1782}1783/**1784 * Multiply each element of the matrix by a scalar.1785 *1786 * @param {mat4} out the receiving matrix1787 * @param {ReadonlyMat4} a the matrix to scale1788 * @param {Number} b amount to scale the matrix's elements by1789 * @returns {mat4} out1790 */1791export function multiplyScalar(out, a, b) {1792  out[0] = a[0] * b;1793  out[1] = a[1] * b;1794  out[2] = a[2] * b;1795  out[3] = a[3] * b;1796  out[4] = a[4] * b;1797  out[5] = a[5] * b;1798  out[6] = a[6] * b;1799  out[7] = a[7] * b;1800  out[8] = a[8] * b;1801  out[9] = a[9] * b;1802  out[10] = a[10] * b;1803  out[11] = a[11] * b;1804  out[12] = a[12] * b;1805  out[13] = a[13] * b;1806  out[14] = a[14] * b;1807  out[15] = a[15] * b;1808  return out;1809}1810/**1811 * Adds two mat4's after multiplying each element of the second operand by a scalar value.1812 *1813 * @param {mat4} out the receiving vector1814 * @param {ReadonlyMat4} a the first operand1815 * @param {ReadonlyMat4} b the second operand1816 * @param {Number} scale the amount to scale b's elements by before adding1817 * @returns {mat4} out1818 */1819export function multiplyScalarAndAdd(out, a, b, scale) {1820  out[0] = a[0] + b[0] * scale;1821  out[1] = a[1] + b[1] * scale;1822  out[2] = a[2] + b[2] * scale;1823  out[3] = a[3] + b[3] * scale;1824  out[4] = a[4] + b[4] * scale;1825  out[5] = a[5] + b[5] * scale;1826  out[6] = a[6] + b[6] * scale;1827  out[7] = a[7] + b[7] * scale;1828  out[8] = a[8] + b[8] * scale;1829  out[9] = a[9] + b[9] * scale;1830  out[10] = a[10] + b[10] * scale;1831  out[11] = a[11] + b[11] * scale;1832  out[12] = a[12] + b[12] * scale;1833  out[13] = a[13] + b[13] * scale;1834  out[14] = a[14] + b[14] * scale;1835  out[15] = a[15] + b[15] * scale;1836  return out;1837}1838/**1839 * Returns whether or not the matrices have exactly the same elements in the same position (when compared with ===)1840 *1841 * @param {ReadonlyMat4} a The first matrix.1842 * @param {ReadonlyMat4} b The second matrix.1843 * @returns {Boolean} True if the matrices are equal, false otherwise.1844 */1845export function exactEquals(a, b) {1846  return (1847    a[0] === b[0] &&1848    a[1] === b[1] &&1849    a[2] === b[2] &&1850    a[3] === b[3] &&1851    a[4] === b[4] &&1852    a[5] === b[5] &&1853    a[6] === b[6] &&1854    a[7] === b[7] &&1855    a[8] === b[8] &&1856    a[9] === b[9] &&1857    a[10] === b[10] &&1858    a[11] === b[11] &&1859    a[12] === b[12] &&1860    a[13] === b[13] &&1861    a[14] === b[14] &&1862    a[15] === b[15]1863  );1864}1865/**1866 * Returns whether or not the matrices have approximately the same elements in the same position.1867 *1868 * @param {ReadonlyMat4} a The first matrix.1869 * @param {ReadonlyMat4} b The second matrix.1870 * @returns {Boolean} True if the matrices are equal, false otherwise.1871 */1872export function equals(a, b) {1873  let a0 = a[0],1874    a1 = a[1],1875    a2 = a[2],1876    a3 = a[3];1877  let a4 = a[4],1878    a5 = a[5],1879    a6 = a[6],1880    a7 = a[7];1881  let a8 = a[8],1882    a9 = a[9],1883    a10 = a[10],1884    a11 = a[11];1885  let a12 = a[12],1886    a13 = a[13],1887    a14 = a[14],1888    a15 = a[15];1889  let b0 = b[0],1890    b1 = b[1],1891    b2 = b[2],1892    b3 = b[3];1893  let b4 = b[4],1894    b5 = b[5],1895    b6 = b[6],1896    b7 = b[7];1897  let b8 = b[8],1898    b9 = b[9],1899    b10 = b[10],1900    b11 = b[11];1901  let b12 = b[12],1902    b13 = b[13],1903    b14 = b[14],1904    b15 = b[15];1905  return (1906    Math.abs(a0 - b0) <=1907      glMatrix.EPSILON * Math.max(1.0, Math.abs(a0), Math.abs(b0)) &&1908    Math.abs(a1 - b1) <=1909      glMatrix.EPSILON * Math.max(1.0, Math.abs(a1), Math.abs(b1)) &&1910    Math.abs(a2 - b2) <=1911      glMatrix.EPSILON * Math.max(1.0, Math.abs(a2), Math.abs(b2)) &&1912    Math.abs(a3 - b3) <=1913      glMatrix.EPSILON * Math.max(1.0, Math.abs(a3), Math.abs(b3)) &&1914    Math.abs(a4 - b4) <=1915      glMatrix.EPSILON * Math.max(1.0, Math.abs(a4), Math.abs(b4)) &&1916    Math.abs(a5 - b5) <=1917      glMatrix.EPSILON * Math.max(1.0, Math.abs(a5), Math.abs(b5)) &&1918    Math.abs(a6 - b6) <=1919      glMatrix.EPSILON * Math.max(1.0, Math.abs(a6), Math.abs(b6)) &&1920    Math.abs(a7 - b7) <=1921      glMatrix.EPSILON * Math.max(1.0, Math.abs(a7), Math.abs(b7)) &&1922    Math.abs(a8 - b8) <=1923      glMatrix.EPSILON * Math.max(1.0, Math.abs(a8), Math.abs(b8)) &&1924    Math.abs(a9 - b9) <=1925      glMatrix.EPSILON * Math.max(1.0, Math.abs(a9), Math.abs(b9)) &&1926    Math.abs(a10 - b10) <=1927      glMatrix.EPSILON * Math.max(1.0, Math.abs(a10), Math.abs(b10)) &&1928    Math.abs(a11 - b11) <=1929      glMatrix.EPSILON * Math.max(1.0, Math.abs(a11), Math.abs(b11)) &&1930    Math.abs(a12 - b12) <=1931      glMatrix.EPSILON * Math.max(1.0, Math.abs(a12), Math.abs(b12)) &&1932    Math.abs(a13 - b13) <=1933      glMatrix.EPSILON * Math.max(1.0, Math.abs(a13), Math.abs(b13)) &&1934    Math.abs(a14 - b14) <=1935      glMatrix.EPSILON * Math.max(1.0, Math.abs(a14), Math.abs(b14)) &&1936    Math.abs(a15 - b15) <=1937      glMatrix.EPSILON * Math.max(1.0, Math.abs(a15), Math.abs(b15))1938  );1939}1940/**1941 * Alias for {@link mat4.multiply}1942 * @function1943 */1944export const mul = multiply;1945/**1946 * Alias for {@link mat4.subtract}1947 * @function1948 */...

mat3.js

Source:mat3.js

1import * as glMatrix from "./common.js";2/**3 * 3x3 Matrix4 * @module mat35 */6/**7 * Creates a new identity mat38 *9 * @returns {mat3} a new 3x3 matrix10 */11export function create() {12  let out = new glMatrix.ARRAY_TYPE(9);13  if (glMatrix.ARRAY_TYPE != Float32Array) {14    out[1] = 0;15    out[2] = 0;16    out[3] = 0;17    out[5] = 0;18    out[6] = 0;19    out[7] = 0;20  }21  out[0] = 1;22  out[4] = 1;23  out[8] = 1;24  return out;25}26/**27 * Copies the upper-left 3x3 values into the given mat3.28 *29 * @param {mat3} out the receiving 3x3 matrix30 * @param {ReadonlyMat4} a   the source 4x4 matrix31 * @returns {mat3} out32 */33export function fromMat4(out, a) {34  out[0] = a[0];35  out[1] = a[1];36  out[2] = a[2];37  out[3] = a[4];38  out[4] = a[5];39  out[5] = a[6];40  out[6] = a[8];41  out[7] = a[9];42  out[8] = a[10];43  return out;44}45/**46 * Creates a new mat3 initialized with values from an existing matrix47 *48 * @param {ReadonlyMat3} a matrix to clone49 * @returns {mat3} a new 3x3 matrix50 */51export function clone(a) {52  let out = new glMatrix.ARRAY_TYPE(9);53  out[0] = a[0];54  out[1] = a[1];55  out[2] = a[2];56  out[3] = a[3];57  out[4] = a[4];58  out[5] = a[5];59  out[6] = a[6];60  out[7] = a[7];61  out[8] = a[8];62  return out;63}64/**65 * Copy the values from one mat3 to another66 *67 * @param {mat3} out the receiving matrix68 * @param {ReadonlyMat3} a the source matrix69 * @returns {mat3} out70 */71export function copy(out, a) {72  out[0] = a[0];73  out[1] = a[1];74  out[2] = a[2];75  out[3] = a[3];76  out[4] = a[4];77  out[5] = a[5];78  out[6] = a[6];79  out[7] = a[7];80  out[8] = a[8];81  return out;82}83/**84 * Create a new mat3 with the given values85 *86 * @param {Number} m00 Component in column 0, row 0 position (index 0)87 * @param {Number} m01 Component in column 0, row 1 position (index 1)88 * @param {Number} m02 Component in column 0, row 2 position (index 2)89 * @param {Number} m10 Component in column 1, row 0 position (index 3)90 * @param {Number} m11 Component in column 1, row 1 position (index 4)91 * @param {Number} m12 Component in column 1, row 2 position (index 5)92 * @param {Number} m20 Component in column 2, row 0 position (index 6)93 * @param {Number} m21 Component in column 2, row 1 position (index 7)94 * @param {Number} m22 Component in column 2, row 2 position (index 8)95 * @returns {mat3} A new mat396 */97export function fromValues(m00, m01, m02, m10, m11, m12, m20, m21, m22) {98  let out = new glMatrix.ARRAY_TYPE(9);99  out[0] = m00;100  out[1] = m01;101  out[2] = m02;102  out[3] = m10;103  out[4] = m11;104  out[5] = m12;105  out[6] = m20;106  out[7] = m21;107  out[8] = m22;108  return out;109}110/**111 * Set the components of a mat3 to the given values112 *113 * @param {mat3} out the receiving matrix114 * @param {Number} m00 Component in column 0, row 0 position (index 0)115 * @param {Number} m01 Component in column 0, row 1 position (index 1)116 * @param {Number} m02 Component in column 0, row 2 position (index 2)117 * @param {Number} m10 Component in column 1, row 0 position (index 3)118 * @param {Number} m11 Component in column 1, row 1 position (index 4)119 * @param {Number} m12 Component in column 1, row 2 position (index 5)120 * @param {Number} m20 Component in column 2, row 0 position (index 6)121 * @param {Number} m21 Component in column 2, row 1 position (index 7)122 * @param {Number} m22 Component in column 2, row 2 position (index 8)123 * @returns {mat3} out124 */125export function set(out, m00, m01, m02, m10, m11, m12, m20, m21, m22) {126  out[0] = m00;127  out[1] = m01;128  out[2] = m02;129  out[3] = m10;130  out[4] = m11;131  out[5] = m12;132  out[6] = m20;133  out[7] = m21;134  out[8] = m22;135  return out;136}137/**138 * Set a mat3 to the identity matrix139 *140 * @param {mat3} out the receiving matrix141 * @returns {mat3} out142 */143export function identity(out) {144  out[0] = 1;145  out[1] = 0;146  out[2] = 0;147  out[3] = 0;148  out[4] = 1;149  out[5] = 0;150  out[6] = 0;151  out[7] = 0;152  out[8] = 1;153  return out;154}155/**156 * Transpose the values of a mat3157 *158 * @param {mat3} out the receiving matrix159 * @param {ReadonlyMat3} a the source matrix160 * @returns {mat3} out161 */162export function transpose(out, a) {163  // If we are transposing ourselves we can skip a few steps but have to cache some values164  if (out === a) {165    let a01 = a[1],166      a02 = a[2],167      a12 = a[5];168    out[1] = a[3];169    out[2] = a[6];170    out[3] = a01;171    out[5] = a[7];172    out[6] = a02;173    out[7] = a12;174  } else {175    out[0] = a[0];176    out[1] = a[3];177    out[2] = a[6];178    out[3] = a[1];179    out[4] = a[4];180    out[5] = a[7];181    out[6] = a[2];182    out[7] = a[5];183    out[8] = a[8];184  }185  return out;186}187/**188 * Inverts a mat3189 *190 * @param {mat3} out the receiving matrix191 * @param {ReadonlyMat3} a the source matrix192 * @returns {mat3} out193 */194export function invert(out, a) {195  let a00 = a[0],196    a01 = a[1],197    a02 = a[2];198  let a10 = a[3],199    a11 = a[4],200    a12 = a[5];201  let a20 = a[6],202    a21 = a[7],203    a22 = a[8];204  let b01 = a22 * a11 - a12 * a21;205  let b11 = -a22 * a10 + a12 * a20;206  let b21 = a21 * a10 - a11 * a20;207  // Calculate the determinant208  let det = a00 * b01 + a01 * b11 + a02 * b21;209  if (!det) {210    return null;211  }212  det = 1.0 / det;213  out[0] = b01 * det;214  out[1] = (-a22 * a01 + a02 * a21) * det;215  out[2] = (a12 * a01 - a02 * a11) * det;216  out[3] = b11 * det;217  out[4] = (a22 * a00 - a02 * a20) * det;218  out[5] = (-a12 * a00 + a02 * a10) * det;219  out[6] = b21 * det;220  out[7] = (-a21 * a00 + a01 * a20) * det;221  out[8] = (a11 * a00 - a01 * a10) * det;222  return out;223}224/**225 * Calculates the adjugate of a mat3226 *227 * @param {mat3} out the receiving matrix228 * @param {ReadonlyMat3} a the source matrix229 * @returns {mat3} out230 */231export function adjoint(out, a) {232  let a00 = a[0],233    a01 = a[1],234    a02 = a[2];235  let a10 = a[3],236    a11 = a[4],237    a12 = a[5];238  let a20 = a[6],239    a21 = a[7],240    a22 = a[8];241  out[0] = a11 * a22 - a12 * a21;242  out[1] = a02 * a21 - a01 * a22;243  out[2] = a01 * a12 - a02 * a11;244  out[3] = a12 * a20 - a10 * a22;245  out[4] = a00 * a22 - a02 * a20;246  out[5] = a02 * a10 - a00 * a12;247  out[6] = a10 * a21 - a11 * a20;248  out[7] = a01 * a20 - a00 * a21;249  out[8] = a00 * a11 - a01 * a10;250  return out;251}252/**253 * Calculates the determinant of a mat3254 *255 * @param {ReadonlyMat3} a the source matrix256 * @returns {Number} determinant of a257 */258export function determinant(a) {259  let a00 = a[0],260    a01 = a[1],261    a02 = a[2];262  let a10 = a[3],263    a11 = a[4],264    a12 = a[5];265  let a20 = a[6],266    a21 = a[7],267    a22 = a[8];268  return (269    a00 * (a22 * a11 - a12 * a21) +270    a01 * (-a22 * a10 + a12 * a20) +271    a02 * (a21 * a10 - a11 * a20)272  );273}274/**275 * Multiplies two mat3's276 *277 * @param {mat3} out the receiving matrix278 * @param {ReadonlyMat3} a the first operand279 * @param {ReadonlyMat3} b the second operand280 * @returns {mat3} out281 */282export function multiply(out, a, b) {283  let a00 = a[0],284    a01 = a[1],285    a02 = a[2];286  let a10 = a[3],287    a11 = a[4],288    a12 = a[5];289  let a20 = a[6],290    a21 = a[7],291    a22 = a[8];292  let b00 = b[0],293    b01 = b[1],294    b02 = b[2];295  let b10 = b[3],296    b11 = b[4],297    b12 = b[5];298  let b20 = b[6],299    b21 = b[7],300    b22 = b[8];301  out[0] = b00 * a00 + b01 * a10 + b02 * a20;302  out[1] = b00 * a01 + b01 * a11 + b02 * a21;303  out[2] = b00 * a02 + b01 * a12 + b02 * a22;304  out[3] = b10 * a00 + b11 * a10 + b12 * a20;305  out[4] = b10 * a01 + b11 * a11 + b12 * a21;306  out[5] = b10 * a02 + b11 * a12 + b12 * a22;307  out[6] = b20 * a00 + b21 * a10 + b22 * a20;308  out[7] = b20 * a01 + b21 * a11 + b22 * a21;309  out[8] = b20 * a02 + b21 * a12 + b22 * a22;310  return out;311}312/**313 * Translate a mat3 by the given vector314 *315 * @param {mat3} out the receiving matrix316 * @param {ReadonlyMat3} a the matrix to translate317 * @param {ReadonlyVec2} v vector to translate by318 * @returns {mat3} out319 */320export function translate(out, a, v) {321  let a00 = a[0],322    a01 = a[1],323    a02 = a[2],324    a10 = a[3],325    a11 = a[4],326    a12 = a[5],327    a20 = a[6],328    a21 = a[7],329    a22 = a[8],330    x = v[0],331    y = v[1];332  out[0] = a00;333  out[1] = a01;334  out[2] = a02;335  out[3] = a10;336  out[4] = a11;337  out[5] = a12;338  out[6] = x * a00 + y * a10 + a20;339  out[7] = x * a01 + y * a11 + a21;340  out[8] = x * a02 + y * a12 + a22;341  return out;342}343/**344 * Rotates a mat3 by the given angle345 *346 * @param {mat3} out the receiving matrix347 * @param {ReadonlyMat3} a the matrix to rotate348 * @param {Number} rad the angle to rotate the matrix by349 * @returns {mat3} out350 */351export function rotate(out, a, rad) {352  let a00 = a[0],353    a01 = a[1],354    a02 = a[2],355    a10 = a[3],356    a11 = a[4],357    a12 = a[5],358    a20 = a[6],359    a21 = a[7],360    a22 = a[8],361    s = Math.sin(rad),362    c = Math.cos(rad);363  out[0] = c * a00 + s * a10;364  out[1] = c * a01 + s * a11;365  out[2] = c * a02 + s * a12;366  out[3] = c * a10 - s * a00;367  out[4] = c * a11 - s * a01;368  out[5] = c * a12 - s * a02;369  out[6] = a20;370  out[7] = a21;371  out[8] = a22;372  return out;373}374/**375 * Scales the mat3 by the dimensions in the given vec2376 *377 * @param {mat3} out the receiving matrix378 * @param {ReadonlyMat3} a the matrix to rotate379 * @param {ReadonlyVec2} v the vec2 to scale the matrix by380 * @returns {mat3} out381 **/382export function scale(out, a, v) {383  let x = v[0],384    y = v[1];385  out[0] = x * a[0];386  out[1] = x * a[1];387  out[2] = x * a[2];388  out[3] = y * a[3];389  out[4] = y * a[4];390  out[5] = y * a[5];391  out[6] = a[6];392  out[7] = a[7];393  out[8] = a[8];394  return out;395}396/**397 * Creates a matrix from a vector translation398 * This is equivalent to (but much faster than):399 *400 *     mat3.identity(dest);401 *     mat3.translate(dest, dest, vec);402 *403 * @param {mat3} out mat3 receiving operation result404 * @param {ReadonlyVec2} v Translation vector405 * @returns {mat3} out406 */407export function fromTranslation(out, v) {408  out[0] = 1;409  out[1] = 0;410  out[2] = 0;411  out[3] = 0;412  out[4] = 1;413  out[5] = 0;414  out[6] = v[0];415  out[7] = v[1];416  out[8] = 1;417  return out;418}419/**420 * Creates a matrix from a given angle421 * This is equivalent to (but much faster than):422 *423 *     mat3.identity(dest);424 *     mat3.rotate(dest, dest, rad);425 *426 * @param {mat3} out mat3 receiving operation result427 * @param {Number} rad the angle to rotate the matrix by428 * @returns {mat3} out429 */430export function fromRotation(out, rad) {431  let s = Math.sin(rad),432    c = Math.cos(rad);433  out[0] = c;434  out[1] = s;435  out[2] = 0;436  out[3] = -s;437  out[4] = c;438  out[5] = 0;439  out[6] = 0;440  out[7] = 0;441  out[8] = 1;442  return out;443}444/**445 * Creates a matrix from a vector scaling446 * This is equivalent to (but much faster than):447 *448 *     mat3.identity(dest);449 *     mat3.scale(dest, dest, vec);450 *451 * @param {mat3} out mat3 receiving operation result452 * @param {ReadonlyVec2} v Scaling vector453 * @returns {mat3} out454 */455export function fromScaling(out, v) {456  out[0] = v[0];457  out[1] = 0;458  out[2] = 0;459  out[3] = 0;460  out[4] = v[1];461  out[5] = 0;462  out[6] = 0;463  out[7] = 0;464  out[8] = 1;465  return out;466}467/**468 * Copies the values from a mat2d into a mat3469 *470 * @param {mat3} out the receiving matrix471 * @param {ReadonlyMat2d} a the matrix to copy472 * @returns {mat3} out473 **/474export function fromMat2d(out, a) {475  out[0] = a[0];476  out[1] = a[1];477  out[2] = 0;478  out[3] = a[2];479  out[4] = a[3];480  out[5] = 0;481  out[6] = a[4];482  out[7] = a[5];483  out[8] = 1;484  return out;485}486/**487 * Calculates a 3x3 matrix from the given quaternion488 *489 * @param {mat3} out mat3 receiving operation result490 * @param {ReadonlyQuat} q Quaternion to create matrix from491 *492 * @returns {mat3} out493 */494export function fromQuat(out, q) {495  let x = q[0],496    y = q[1],497    z = q[2],498    w = q[3];499  let x2 = x + x;500  let y2 = y + y;501  let z2 = z + z;502  let xx = x * x2;503  let yx = y * x2;504  let yy = y * y2;505  let zx = z * x2;506  let zy = z * y2;507  let zz = z * z2;508  let wx = w * x2;509  let wy = w * y2;510  let wz = w * z2;511  out[0] = 1 - yy - zz;512  out[3] = yx - wz;513  out[6] = zx + wy;514  out[1] = yx + wz;515  out[4] = 1 - xx - zz;516  out[7] = zy - wx;517  out[2] = zx - wy;518  out[5] = zy + wx;519  out[8] = 1 - xx - yy;520  return out;521}522/**523 * Calculates a 3x3 normal matrix (transpose inverse) from the 4x4 matrix524 *525 * @param {mat3} out mat3 receiving operation result526 * @param {ReadonlyMat4} a Mat4 to derive the normal matrix from527 *528 * @returns {mat3} out529 */530export function normalFromMat4(out, a) {531  let a00 = a[0],532    a01 = a[1],533    a02 = a[2],534    a03 = a[3];535  let a10 = a[4],536    a11 = a[5],537    a12 = a[6],538    a13 = a[7];539  let a20 = a[8],540    a21 = a[9],541    a22 = a[10],542    a23 = a[11];543  let a30 = a[12],544    a31 = a[13],545    a32 = a[14],546    a33 = a[15];547  let b00 = a00 * a11 - a01 * a10;548  let b01 = a00 * a12 - a02 * a10;549  let b02 = a00 * a13 - a03 * a10;550  let b03 = a01 * a12 - a02 * a11;551  let b04 = a01 * a13 - a03 * a11;552  let b05 = a02 * a13 - a03 * a12;553  let b06 = a20 * a31 - a21 * a30;554  let b07 = a20 * a32 - a22 * a30;555  let b08 = a20 * a33 - a23 * a30;556  let b09 = a21 * a32 - a22 * a31;557  let b10 = a21 * a33 - a23 * a31;558  let b11 = a22 * a33 - a23 * a32;559  // Calculate the determinant560  let det =561    b00 * b11 - b01 * b10 + b02 * b09 + b03 * b08 - b04 * b07 + b05 * b06;562  if (!det) {563    return null;564  }565  det = 1.0 / det;566  out[0] = (a11 * b11 - a12 * b10 + a13 * b09) * det;567  out[1] = (a12 * b08 - a10 * b11 - a13 * b07) * det;568  out[2] = (a10 * b10 - a11 * b08 + a13 * b06) * det;569  out[3] = (a02 * b10 - a01 * b11 - a03 * b09) * det;570  out[4] = (a00 * b11 - a02 * b08 + a03 * b07) * det;571  out[5] = (a01 * b08 - a00 * b10 - a03 * b06) * det;572  out[6] = (a31 * b05 - a32 * b04 + a33 * b03) * det;573  out[7] = (a32 * b02 - a30 * b05 - a33 * b01) * det;574  out[8] = (a30 * b04 - a31 * b02 + a33 * b00) * det;575  return out;576}577/**578 * Generates a 2D projection matrix with the given bounds579 *580 * @param {mat3} out mat3 frustum matrix will be written into581 * @param {number} width Width of your gl context582 * @param {number} height Height of gl context583 * @returns {mat3} out584 */585export function projection(out, width, height) {586  out[0] = 2 / width;587  out[1] = 0;588  out[2] = 0;589  out[3] = 0;590  out[4] = -2 / height;591  out[5] = 0;592  out[6] = -1;593  out[7] = 1;594  out[8] = 1;595  return out;596}597/**598 * Returns a string representation of a mat3599 *600 * @param {ReadonlyMat3} a matrix to represent as a string601 * @returns {String} string representation of the matrix602 */603export function str(a) {604  return (605    "mat3(" +606    a[0] +607    ", " +608    a[1] +609    ", " +610    a[2] +611    ", " +612    a[3] +613    ", " +614    a[4] +615    ", " +616    a[5] +617    ", " +618    a[6] +619    ", " +620    a[7] +621    ", " +622    a[8] +623    ")"624  );625}626/**627 * Returns Frobenius norm of a mat3628 *629 * @param {ReadonlyMat3} a the matrix to calculate Frobenius norm of630 * @returns {Number} Frobenius norm631 */632export function frob(a) {633  return Math.hypot(a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7], a[8]);634}635/**636 * Adds two mat3's637 *638 * @param {mat3} out the receiving matrix639 * @param {ReadonlyMat3} a the first operand640 * @param {ReadonlyMat3} b the second operand641 * @returns {mat3} out642 */643export function add(out, a, b) {644  out[0] = a[0] + b[0];645  out[1] = a[1] + b[1];646  out[2] = a[2] + b[2];647  out[3] = a[3] + b[3];648  out[4] = a[4] + b[4];649  out[5] = a[5] + b[5];650  out[6] = a[6] + b[6];651  out[7] = a[7] + b[7];652  out[8] = a[8] + b[8];653  return out;654}655/**656 * Subtracts matrix b from matrix a657 *658 * @param {mat3} out the receiving matrix659 * @param {ReadonlyMat3} a the first operand660 * @param {ReadonlyMat3} b the second operand661 * @returns {mat3} out662 */663export function subtract(out, a, b) {664  out[0] = a[0] - b[0];665  out[1] = a[1] - b[1];666  out[2] = a[2] - b[2];667  out[3] = a[3] - b[3];668  out[4] = a[4] - b[4];669  out[5] = a[5] - b[5];670  out[6] = a[6] - b[6];671  out[7] = a[7] - b[7];672  out[8] = a[8] - b[8];673  return out;674}675/**676 * Multiply each element of the matrix by a scalar.677 *678 * @param {mat3} out the receiving matrix679 * @param {ReadonlyMat3} a the matrix to scale680 * @param {Number} b amount to scale the matrix's elements by681 * @returns {mat3} out682 */683export function multiplyScalar(out, a, b) {684  out[0] = a[0] * b;685  out[1] = a[1] * b;686  out[2] = a[2] * b;687  out[3] = a[3] * b;688  out[4] = a[4] * b;689  out[5] = a[5] * b;690  out[6] = a[6] * b;691  out[7] = a[7] * b;692  out[8] = a[8] * b;693  return out;694}695/**696 * Adds two mat3's after multiplying each element of the second operand by a scalar value.697 *698 * @param {mat3} out the receiving vector699 * @param {ReadonlyMat3} a the first operand700 * @param {ReadonlyMat3} b the second operand701 * @param {Number} scale the amount to scale b's elements by before adding702 * @returns {mat3} out703 */704export function multiplyScalarAndAdd(out, a, b, scale) {705  out[0] = a[0] + b[0] * scale;706  out[1] = a[1] + b[1] * scale;707  out[2] = a[2] + b[2] * scale;708  out[3] = a[3] + b[3] * scale;709  out[4] = a[4] + b[4] * scale;710  out[5] = a[5] + b[5] * scale;711  out[6] = a[6] + b[6] * scale;712  out[7] = a[7] + b[7] * scale;713  out[8] = a[8] + b[8] * scale;714  return out;715}716/**717 * Returns whether or not the matrices have exactly the same elements in the same position (when compared with ===)718 *719 * @param {ReadonlyMat3} a The first matrix.720 * @param {ReadonlyMat3} b The second matrix.721 * @returns {Boolean} True if the matrices are equal, false otherwise.722 */723export function exactEquals(a, b) {724  return (725    a[0] === b[0] &&726    a[1] === b[1] &&727    a[2] === b[2] &&728    a[3] === b[3] &&729    a[4] === b[4] &&730    a[5] === b[5] &&731    a[6] === b[6] &&732    a[7] === b[7] &&733    a[8] === b[8]734  );735}736/**737 * Returns whether or not the matrices have approximately the same elements in the same position.738 *739 * @param {ReadonlyMat3} a The first matrix.740 * @param {ReadonlyMat3} b The second matrix.741 * @returns {Boolean} True if the matrices are equal, false otherwise.742 */743export function equals(a, b) {744  let a0 = a[0],745    a1 = a[1],746    a2 = a[2],747    a3 = a[3],748    a4 = a[4],749    a5 = a[5],750    a6 = a[6],751    a7 = a[7],752    a8 = a[8];753  let b0 = b[0],754    b1 = b[1],755    b2 = b[2],756    b3 = b[3],757    b4 = b[4],758    b5 = b[5],759    b6 = b[6],760    b7 = b[7],761    b8 = b[8];762  return (763    Math.abs(a0 - b0) <=764      glMatrix.EPSILON * Math.max(1.0, Math.abs(a0), Math.abs(b0)) &&765    Math.abs(a1 - b1) <=766      glMatrix.EPSILON * Math.max(1.0, Math.abs(a1), Math.abs(b1)) &&767    Math.abs(a2 - b2) <=768      glMatrix.EPSILON * Math.max(1.0, Math.abs(a2), Math.abs(b2)) &&769    Math.abs(a3 - b3) <=770      glMatrix.EPSILON * Math.max(1.0, Math.abs(a3), Math.abs(b3)) &&771    Math.abs(a4 - b4) <=772      glMatrix.EPSILON * Math.max(1.0, Math.abs(a4), Math.abs(b4)) &&773    Math.abs(a5 - b5) <=774      glMatrix.EPSILON * Math.max(1.0, Math.abs(a5), Math.abs(b5)) &&775    Math.abs(a6 - b6) <=776      glMatrix.EPSILON * Math.max(1.0, Math.abs(a6), Math.abs(b6)) &&777    Math.abs(a7 - b7) <=778      glMatrix.EPSILON * Math.max(1.0, Math.abs(a7), Math.abs(b7)) &&779    Math.abs(a8 - b8) <=780      glMatrix.EPSILON * Math.max(1.0, Math.abs(a8), Math.abs(b8))781  );782}783/**784 * Alias for {@link mat3.multiply}785 * @function786 */787export const mul = multiply;788/**789 * Alias for {@link mat3.subtract}790 * @function791 */...

index.js

Source:index.js

1function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }2function _sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }3function _slicedToArray(arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return _sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }4import { isAnonymous, isInstruction } from "@webassemblyjs/ast";5import Long from "@xtuc/long";6var compact = false;7var space = " ";8var quote = function quote(str) {9  return "\"".concat(str, "\"");10};11function indent(nb) {12  return Array(nb).fill(space + space).join("");13} // TODO(sven): allow arbitrary ast nodes14export function print(n) {15  if (n.type === "Program") {16    return printProgram(n, 0);17  } else {18    throw new Error("Unsupported node in print of type: " + String(n.type));19  }20}21function printProgram(n, depth) {22  return n.body.reduce(function (acc, child) {23    if (child.type === "Module") {24      acc += printModule(child, depth + 1);25    }26    if (child.type === "Func") {27      acc += printFunc(child, depth + 1);28    }29    if (child.type === "BlockComment") {30      acc += printBlockComment(child);31    }32    if (child.type === "LeadingComment") {33      acc += printLeadingComment(child);34    }35    if (compact === false) {36      acc += "\n";37    }38    return acc;39  }, "");40}41function printTypeInstruction(n) {42  var out = "";43  out += "(";44  out += "type";45  out += space;46  if (n.id != null) {47    out += printIndex(n.id);48    out += space;49  }50  out += "(";51  out += "func";52  n.functype.params.forEach(function (param) {53    out += space;54    out += "(";55    out += "param";56    out += space;57    out += printFuncParam(param);58    out += ")";59  });60  n.functype.results.forEach(function (result) {61    out += space;62    out += "(";63    out += "result";64    out += space;65    out += result;66    out += ")";67  });68  out += ")"; // func69  out += ")";70  return out;71}72function printModule(n, depth) {73  var out = "(";74  out += "module";75  if (typeof n.id === "string") {76    out += space;77    out += n.id;78  }79  if (compact === false) {80    out += "\n";81  } else {82    out += space;83  }84  n.fields.forEach(function (field) {85    if (compact === false) {86      out += indent(depth);87    }88    switch (field.type) {89      case "Func":90        {91          out += printFunc(field, depth + 1);92          break;93        }94      case "TypeInstruction":95        {96          out += printTypeInstruction(field);97          break;98        }99      case "Table":100        {101          out += printTable(field);102          break;103        }104      case "Global":105        {106          out += printGlobal(field, depth + 1);107          break;108        }109      case "ModuleExport":110        {111          out += printModuleExport(field);112          break;113        }114      case "ModuleImport":115        {116          out += printModuleImport(field);117          break;118        }119      case "Memory":120        {121          out += printMemory(field);122          break;123        }124      case "BlockComment":125        {126          out += printBlockComment(field);127          break;128        }129      case "LeadingComment":130        {131          out += printLeadingComment(field);132          break;133        }134      case "Start":135        {136          out += printStart(field);137          break;138        }139      case "Elem":140        {141          out += printElem(field, depth);142          break;143        }144      case "Data":145        {146          out += printData(field, depth);147          break;148        }149      default:150        throw new Error("Unsupported node in printModule: " + String(field.type));151    }152    if (compact === false) {153      out += "\n";154    }155  });156  out += ")";157  return out;158}159function printData(n, depth) {160  var out = "";161  out += "(";162  out += "data";163  out += space;164  out += printIndex(n.memoryIndex);165  out += space;166  out += printInstruction(n.offset, depth);167  out += space;168  var value = "";169  n.init.values.forEach(function (byte) {170    value += String.fromCharCode(byte);171  }); // Avoid non-displayable characters172  out += JSON.stringify(value);173  out += ")";174  return out;175}176function printElem(n, depth) {177  var out = "";178  out += "(";179  out += "elem";180  out += space;181  out += printIndex(n.table);182  var _n$offset = _slicedToArray(n.offset, 1),183      firstOffset = _n$offset[0];184  out += space;185  out += "(";186  out += "offset";187  out += space;188  out += printInstruction(firstOffset, depth);189  out += ")";190  n.funcs.forEach(function (func) {191    out += space;192    out += printIndex(func);193  });194  out += ")";195  return out;196}197function printStart(n) {198  var out = "";199  out += "(";200  out += "start";201  out += space;202  out += printIndex(n.index);203  out += ")";204  return out;205}206function printLeadingComment(n) {207  // Don't print leading comments in compact mode208  if (compact === true) {209    return "";210  }211  var out = "";212  out += ";;";213  out += n.value;214  out += "\n";215  return out;216}217function printBlockComment(n) {218  // Don't print block comments in compact mode219  if (compact === true) {220    return "";221  }222  var out = "";223  out += "(;";224  out += n.value;225  out += ";)";226  out += "\n";227  return out;228}229function printSignature(n) {230  var out = "";231  n.params.forEach(function (param) {232    out += space;233    out += "(";234    out += "param";235    out += space;236    out += printFuncParam(param);237    out += ")";238  });239  n.results.forEach(function (result) {240    out += space;241    out += "(";242    out += "result";243    out += space;244    out += result;245    out += ")";246  });247  return out;248}249function printModuleImportDescr(n) {250  var out = "";251  if (n.type === "FuncImportDescr") {252    out += "(";253    out += "func";254    if (isAnonymous(n.id) === false) {255      out += space;256      out += printIdentifier(n.id);257    }258    out += printSignature(n.signature);259    out += ")";260  }261  if (n.type === "GlobalType") {262    out += "(";263    out += "global";264    out += space;265    out += printGlobalType(n);266    out += ")";267  }268  if (n.type === "Table") {269    out += printTable(n);270  }271  return out;272}273function printModuleImport(n) {274  var out = "";275  out += "(";276  out += "import";277  out += space;278  out += quote(n.module);279  out += space;280  out += quote(n.name);281  out += space;282  out += printModuleImportDescr(n.descr);283  out += ")";284  return out;285}286function printGlobalType(n) {287  var out = "";288  if (n.mutability === "var") {289    out += "(";290    out += "mut";291    out += space;292    out += n.valtype;293    out += ")";294  } else {295    out += n.valtype;296  }297  return out;298}299function printGlobal(n, depth) {300  var out = "";301  out += "(";302  out += "global";303  out += space;304  if (n.name != null && isAnonymous(n.name) === false) {305    out += printIdentifier(n.name);306    out += space;307  }308  out += printGlobalType(n.globalType);309  out += space;310  n.init.forEach(function (i) {311    out += printInstruction(i, depth + 1);312  });313  out += ")";314  return out;315}316function printTable(n) {317  var out = "";318  out += "(";319  out += "table";320  out += space;321  if (n.name != null && isAnonymous(n.name) === false) {322    out += printIdentifier(n.name);323    out += space;324  }325  out += printLimit(n.limits);326  out += space;327  out += n.elementType;328  out += ")";329  return out;330}331function printFuncParam(n) {332  var out = "";333  if (typeof n.id === "string") {334    out += "$" + n.id;335    out += space;336  }337  out += n.valtype;338  return out;339}340function printFunc(n, depth) {341  var out = "";342  out += "(";343  out += "func";344  if (n.name != null) {345    if (n.name.type === "Identifier" && isAnonymous(n.name) === false) {346      out += space;347      out += printIdentifier(n.name);348    }349  }350  if (n.signature.type === "Signature") {351    out += printSignature(n.signature);352  } else {353    var index = n.signature;354    out += space;355    out += "(";356    out += "type";357    out += space;358    out += printIndex(index);359    out += ")";360  }361  if (n.body.length > 0) {362    if (compact === false) {363      out += "\n";364    }365    n.body.forEach(function (i) {366      out += indent(depth);367      out += printInstruction(i, depth);368      if (compact === false) {369        out += "\n";370      }371    });372    out += indent(depth - 1) + ")";373  } else {374    out += ")";375  }376  return out;377}378function printInstruction(n, depth) {379  switch (n.type) {380    case "Instr":381      // $FlowIgnore382      return printGenericInstruction(n, depth + 1);383    case "BlockInstruction":384      // $FlowIgnore385      return printBlockInstruction(n, depth + 1);386    case "IfInstruction":387      // $FlowIgnore388      return printIfInstruction(n, depth + 1);389    case "CallInstruction":390      // $FlowIgnore391      return printCallInstruction(n, depth + 1);392    case "CallIndirectInstruction":393      // $FlowIgnore394      return printCallIndirectIntruction(n, depth + 1);395    case "LoopInstruction":396      // $FlowIgnore397      return printLoopInstruction(n, depth + 1);398    default:399      throw new Error("Unsupported instruction: " + JSON.stringify(n.type));400  }401}402function printCallIndirectIntruction(n, depth) {403  var out = "";404  out += "(";405  out += "call_indirect";406  if (n.signature.type === "Signature") {407    out += printSignature(n.signature);408  } else if (n.signature.type === "Identifier") {409    out += space;410    out += "(";411    out += "type";412    out += space;413    out += printIdentifier(n.signature);414    out += ")";415  } else {416    throw new Error("CallIndirectInstruction: unsupported signature " + JSON.stringify(n.signature.type));417  }418  out += space;419  if (n.intrs != null) {420    // $FlowIgnore421    n.intrs.forEach(function (i, index) {422      // $FlowIgnore423      out += printInstruction(i, depth + 1); // $FlowIgnore424      if (index !== n.intrs.length - 1) {425        out += space;426      }427    });428  }429  out += ")";430  return out;431}432function printLoopInstruction(n, depth) {433  var out = "";434  out += "(";435  out += "loop";436  if (n.label != null && isAnonymous(n.label) === false) {437    out += space;438    out += printIdentifier(n.label);439  }440  if (typeof n.resulttype === "string") {441    out += space;442    out += "(";443    out += "result";444    out += space;445    out += n.resulttype;446    out += ")";447  }448  if (n.instr.length > 0) {449    n.instr.forEach(function (e) {450      if (compact === false) {451        out += "\n";452      }453      out += indent(depth);454      out += printInstruction(e, depth + 1);455    });456    if (compact === false) {457      out += "\n";458      out += indent(depth - 1);459    }460  }461  out += ")";462  return out;463}464function printCallInstruction(n, depth) {465  var out = "";466  out += "(";467  out += "call";468  out += space;469  out += printIndex(n.index);470  if (_typeof(n.instrArgs) === "object") {471    // $FlowIgnore472    n.instrArgs.forEach(function (arg) {473      out += space;474      out += printFuncInstructionArg(arg, depth + 1);475    });476  }477  out += ")";478  return out;479}480function printIfInstruction(n, depth) {481  var out = "";482  out += "(";483  out += "if";484  if (n.testLabel != null && isAnonymous(n.testLabel) === false) {485    out += space;486    out += printIdentifier(n.testLabel);487  }488  if (typeof n.result === "string") {489    out += space;490    out += "(";491    out += "result";492    out += space;493    out += n.result;494    out += ")";495  }496  if (n.test.length > 0) {497    out += space;498    n.test.forEach(function (i) {499      out += printInstruction(i, depth + 1);500    });501  }502  if (n.consequent.length > 0) {503    if (compact === false) {504      out += "\n";505    }506    out += indent(depth);507    out += "(";508    out += "then";509    depth++;510    n.consequent.forEach(function (i) {511      if (compact === false) {512        out += "\n";513      }514      out += indent(depth);515      out += printInstruction(i, depth + 1);516    });517    depth--;518    if (compact === false) {519      out += "\n";520      out += indent(depth);521    }522    out += ")";523  } else {524    if (compact === false) {525      out += "\n";526      out += indent(depth);527    }528    out += "(";529    out += "then";530    out += ")";531  }532  if (n.alternate.length > 0) {533    if (compact === false) {534      out += "\n";535    }536    out += indent(depth);537    out += "(";538    out += "else";539    depth++;540    n.alternate.forEach(function (i) {541      if (compact === false) {542        out += "\n";543      }544      out += indent(depth);545      out += printInstruction(i, depth + 1);546    });547    depth--;548    if (compact === false) {549      out += "\n";550      out += indent(depth);551    }552    out += ")";553  } else {554    if (compact === false) {555      out += "\n";556      out += indent(depth);557    }558    out += "(";559    out += "else";560    out += ")";561  }562  if (compact === false) {563    out += "\n";564    out += indent(depth - 1);565  }566  out += ")";567  return out;568}569function printBlockInstruction(n, depth) {570  var out = "";571  out += "(";572  out += "block";573  if (n.label != null && isAnonymous(n.label) === false) {574    out += space;575    out += printIdentifier(n.label);576  }577  if (typeof n.result === "string") {578    out += space;579    out += "(";580    out += "result";581    out += space;582    out += n.result;583    out += ")";584  }585  if (n.instr.length > 0) {586    n.instr.forEach(function (i) {587      if (compact === false) {588        out += "\n";589      }590      out += indent(depth);591      out += printInstruction(i, depth + 1);592    });593    if (compact === false) {594      out += "\n";595    }596    out += indent(depth - 1);597    out += ")";598  } else {599    out += ")";600  }601  return out;602}603function printGenericInstruction(n, depth) {604  var out = "";605  out += "(";606  if (typeof n.object === "string") {607    out += n.object;608    out += ".";609  }610  out += n.id;611  n.args.forEach(function (arg) {612    out += space;613    out += printFuncInstructionArg(arg, depth + 1);614  });615  out += ")";616  return out;617}618function printLongNumberLiteral(n) {619  if (typeof n.raw === "string") {620    return n.raw;621  }622  var _n$value = n.value,623      low = _n$value.low,624      high = _n$value.high;625  var v = new Long(low, high);626  return v.toString();627}628function printFloatLiteral(n) {629  if (typeof n.raw === "string") {630    return n.raw;631  }632  return String(n.value);633}634function printFuncInstructionArg(n, depth) {635  var out = "";636  if (n.type === "NumberLiteral") {637    out += printNumberLiteral(n);638  }639  if (n.type === "LongNumberLiteral") {640    out += printLongNumberLiteral(n);641  }642  if (n.type === "Identifier" && isAnonymous(n) === false) {643    out += printIdentifier(n);644  }645  if (n.type === "ValtypeLiteral") {646    out += n.name;647  }648  if (n.type === "FloatLiteral") {649    out += printFloatLiteral(n);650  }651  if (isInstruction(n)) {652    out += printInstruction(n, depth + 1);653  }654  return out;655}656function printNumberLiteral(n) {657  if (typeof n.raw === "string") {658    return n.raw;659  }660  return String(n.value);661}662function printModuleExport(n) {663  var out = "";664  out += "(";665  out += "export";666  out += space;667  out += quote(n.name);668  if (n.descr.exportType === "Func") {669    out += space;670    out += "(";671    out += "func";672    out += space;673    out += printIndex(n.descr.id);674    out += ")";675  } else if (n.descr.exportType === "Global") {676    out += space;677    out += "(";678    out += "global";679    out += space;680    out += printIndex(n.descr.id);681    out += ")";682  } else if (n.descr.exportType === "Memory" || n.descr.exportType === "Mem") {683    out += space;684    out += "(";685    out += "memory";686    out += space;687    out += printIndex(n.descr.id);688    out += ")";689  } else if (n.descr.exportType === "Table") {690    out += space;691    out += "(";692    out += "table";693    out += space;694    out += printIndex(n.descr.id);695    out += ")";696  } else {697    throw new Error("printModuleExport: unknown type: " + n.descr.exportType);698  }699  out += ")";700  return out;701}702function printIdentifier(n) {703  return "$" + n.value;704}705function printIndex(n) {706  if (n.type === "Identifier") {707    return printIdentifier(n);708  } else if (n.type === "NumberLiteral") {709    return printNumberLiteral(n);710  } else {711    throw new Error("Unsupported index: " + n.type);712  }713}714function printMemory(n) {715  var out = "";716  out += "(";717  out += "memory";718  if (n.id != null) {719    out += space;720    out += printIndex(n.id);721    out += space;722  }723  out += printLimit(n.limits);724  out += ")";725  return out;726}727function printLimit(n) {728  var out = "";729  out += n.min + "";730  if (n.max != null) {731    out += space;732    out += String(n.max);733  }734  return out;...

vector.js

Source:vector.js

1define(function () {2    var ArrayCtor = typeof Float32Array === 'undefined'3        ? Array4        : Float32Array;5    /**6     * @typedef {Float32Array|Array.<number>} Vector27     */8    /**9     * äºç»´åéç±»10     * @exports zrender/tool/vector11     */12    var vector = {13        /**14         * åå»ºä¸ä¸ªåé15         * @param {number} [x=0]16         * @param {number} [y=0]17         * @return {Vector2}18         */19        create: function (x, y) {20            var out = new ArrayCtor(2);21            out[0] = x || 0;22            out[1] = y || 0;23            return out;24        },25        /**26         * å¤å¶åéæ°æ®27         * @param {Vector2} out28         * @param {Vector2} v29         * @return {Vector2}30         */31        copy: function (out, v) {32            out[0] = v[0];33            out[1] = v[1];34            return out;35        },36        /**37         * åéä¸ä¸ªåé38         * @param {Vector2} v39         * @return {Vector2}40         */41        clone: function (v) {42            var out = new ArrayCtor(2);43            out[0] = v[0];44            out[1] = v[1];45            return out;46        },47        /**48         * è®¾ç½®åéçä¸¤ä¸ªé¡¹49         * @param {Vector2} out50         * @param {number} a51         * @param {number} b52         * @return {Vector2} ç»æ53         */54        set: function (out, a, b) {55            out[0] = a;56            out[1] = b;57            return out;58        },59        /**60         * åéç¸å 61         * @param {Vector2} out62         * @param {Vector2} v163         * @param {Vector2} v264         */65        add: function (out, v1, v2) {66            out[0] = v1[0] + v2[0];67            out[1] = v1[1] + v2[1];68            return out;69        },70        /**71         * åéç¼©æ¾åç¸å 72         * @param {Vector2} out73         * @param {Vector2} v174         * @param {Vector2} v275         * @param {number} a76         */77        scaleAndAdd: function (out, v1, v2, a) {78            out[0] = v1[0] + v2[0] * a;79            out[1] = v1[1] + v2[1] * a;80            return out;81        },82        /**83         * åéç¸å84         * @param {Vector2} out85         * @param {Vector2} v186         * @param {Vector2} v287         */88        sub: function (out, v1, v2) {89            out[0] = v1[0] - v2[0];90            out[1] = v1[1] - v2[1];91            return out;92        },93        /**94         * åéé¿åº¦95         * @param {Vector2} v96         * @return {number}97         */98        len: function (v) {99            return Math.sqrt(this.lenSquare(v));100        },101        /**102         * åéé¿åº¦å¹³æ¹103         * @param {Vector2} v104         * @return {number}105         */106        lenSquare: function (v) {107            return v[0] * v[0] + v[1] * v[1];108        },109        /**110         * åéä¹æ³111         * @param {Vector2} out112         * @param {Vector2} v1113         * @param {Vector2} v2114         */115        mul: function (out, v1, v2) {116            out[0] = v1[0] * v2[0];117            out[1] = v1[1] * v2[1];118            return out;119        },120        /**121         * åéé¤æ³122         * @param {Vector2} out123         * @param {Vector2} v1124         * @param {Vector2} v2125         */126        div: function (out, v1, v2) {127            out[0] = v1[0] / v2[0];128            out[1] = v1[1] / v2[1];129            return out;130        },131        /**132         * åéç¹ä¹133         * @param {Vector2} v1134         * @param {Vector2} v2135         * @return {number}136         */137        dot: function (v1, v2) {138            return v1[0] * v2[0] + v1[1] * v2[1];139        },140        /**141         * åéç¼©æ¾142         * @param {Vector2} out143         * @param {Vector2} v144         * @param {number} s145         */146        scale: function (out, v, s) {147            out[0] = v[0] * s;148            out[1] = v[1] * s;149            return out;150        },151        /**152         * åéå½ä¸å153         * @param {Vector2} out154         * @param {Vector2} v155         */156        normalize: function (out, v) {157            var d = vector.len(v);158            if (d === 0) {159                out[0] = 0;160                out[1] = 0;161            }162            else {163                out[0] = v[0] / d;164                out[1] = v[1] / d;165            }166            return out;167        },168        /**169         * è®¡ç®åéé´è·ç¦»170         * @param {Vector2} v1171         * @param {Vector2} v2172         * @return {number}173         */174        distance: function (v1, v2) {175            return Math.sqrt(176                (v1[0] - v2[0]) * (v1[0] - v2[0])177                + (v1[1] - v2[1]) * (v1[1] - v2[1])178            );179        },180        /**181         * åéè·ç¦»å¹³æ¹182         * @param {Vector2} v1183         * @param {Vector2} v2184         * @return {number}185         */186        distanceSquare: function (v1, v2) {187            return (v1[0] - v2[0]) * (v1[0] - v2[0])188                + (v1[1] - v2[1]) * (v1[1] - v2[1]);189        },190        /**191         * æ±è´åé192         * @param {Vector2} out193         * @param {Vector2} v194         */195        negate: function (out, v) {196            out[0] = -v[0];197            out[1] = -v[1];198            return out;199        },200        /**201         * æå¼ä¸¤ä¸ªç¹202         * @param {Vector2} out203         * @param {Vector2} v1204         * @param {Vector2} v2205         * @param {number} t206         */207        lerp: function (out, v1, v2, t) {208            out[0] = v1[0] + t * (v2[0] - v1[0]);209            out[1] = v1[1] + t * (v2[1] - v1[1]);210            return out;211        },212        /**213         * ç©éµå·¦ä¹åé214         * @param {Vector2} out215         * @param {Vector2} v216         * @param {Vector2} m217         */218        applyTransform: function (out, v, m) {219            var x = v[0];220            var y = v[1];221            out[0] = m[0] * x + m[2] * y + m[4];222            out[1] = m[1] * x + m[3] * y + m[5];223            return out;224        },225        /**226         * æ±ä¸¤ä¸ªåéæå°å¼227         * @param  {Vector2} out228         * @param  {Vector2} v1229         * @param  {Vector2} v2230         */231        min: function (out, v1, v2) {232            out[0] = Math.min(v1[0], v2[0]);233            out[1] = Math.min(v1[1], v2[1]);234            return out;235        },236        /**237         * æ±ä¸¤ä¸ªåéæå¤§å¼238         * @param  {Vector2} out239         * @param  {Vector2} v1240         * @param  {Vector2} v2241         */242        max: function (out, v1, v2) {243            out[0] = Math.max(v1[0], v2[0]);244            out[1] = Math.max(v1[1], v2[1]);245            return out;246        }247    };248    vector.length = vector.len;249    vector.lengthSquare = vector.lenSquare;250    vector.dist = vector.distance;251    vector.distSquare = vector.distanceSquare;252    return vector;...

matrix.js

Source:matrix.js

1define(function () {2    var ArrayCtor = typeof Float32Array === 'undefined'3        ? Array4        : Float32Array;5    /**6     * 3x2ç©éµæä½ç±»7     * @exports zrender/tool/matrix8     */9    var matrix = {10        /**11         * åå»ºä¸ä¸ªåä½ç©éµ12         * @return {Float32Array|Array.<number>}13         */14        create : function() {15            var out = new ArrayCtor(6);16            matrix.identity(out);17            return out;18        },19        /**20         * è®¾ç½®ç©éµä¸ºåä½ç©éµ21         * @param {Float32Array|Array.<number>} out22         */23        identity : function(out) {24            out[0] = 1;25            out[1] = 0;26            out[2] = 0;27            out[3] = 1;28            out[4] = 0;29            out[5] = 0;30            return out;31        },32        /**33         * å¤å¶ç©éµ34         * @param {Float32Array|Array.<number>} out35         * @param {Float32Array|Array.<number>} m36         */37        copy: function(out, m) {38            out[0] = m[0];39            out[1] = m[1];40            out[2] = m[2];41            out[3] = m[3];42            out[4] = m[4];43            out[5] = m[5];44            return out;45        },46        /**47         * ç©éµç¸ä¹48         * @param {Float32Array|Array.<number>} out49         * @param {Float32Array|Array.<number>} m150         * @param {Float32Array|Array.<number>} m251         */52        mul : function (out, m1, m2) {53            // Consider matrix.mul(m, m2, m);54            // where out is the same as m2.55            // So use temp variable to escape error.56            var out0 = m1[0] * m2[0] + m1[2] * m2[1];57            var out1 = m1[1] * m2[0] + m1[3] * m2[1];58            var out2 = m1[0] * m2[2] + m1[2] * m2[3];59            var out3 = m1[1] * m2[2] + m1[3] * m2[3];60            var out4 = m1[0] * m2[4] + m1[2] * m2[5] + m1[4];61            var out5 = m1[1] * m2[4] + m1[3] * m2[5] + m1[5];62            out[0] = out0;63            out[1] = out1;64            out[2] = out2;65            out[3] = out3;66            out[4] = out4;67            out[5] = out5;68            return out;69        },70        /**71         * å¹³ç§»åæ¢72         * @param {Float32Array|Array.<number>} out73         * @param {Float32Array|Array.<number>} a74         * @param {Float32Array|Array.<number>} v75         */76        translate : function(out, a, v) {77            out[0] = a[0];78            out[1] = a[1];79            out[2] = a[2];80            out[3] = a[3];81            out[4] = a[4] + v[0];82            out[5] = a[5] + v[1];83            return out;84        },85        /**86         * æè½¬åæ¢87         * @param {Float32Array|Array.<number>} out88         * @param {Float32Array|Array.<number>} a89         * @param {number} rad90         */91        rotate : function(out, a, rad) {92            var aa = a[0];93            var ac = a[2];94            var atx = a[4];95            var ab = a[1];96            var ad = a[3];97            var aty = a[5];98            var st = Math.sin(rad);99            var ct = Math.cos(rad);100            out[0] = aa * ct + ab * st;101            out[1] = -aa * st + ab * ct;102            out[2] = ac * ct + ad * st;103            out[3] = -ac * st + ct * ad;104            out[4] = ct * atx + st * aty;105            out[5] = ct * aty - st * atx;106            return out;107        },108        /**109         * ç¼©æ¾åæ¢110         * @param {Float32Array|Array.<number>} out111         * @param {Float32Array|Array.<number>} a112         * @param {Float32Array|Array.<number>} v113         */114        scale : function(out, a, v) {115            var vx = v[0];116            var vy = v[1];117            out[0] = a[0] * vx;118            out[1] = a[1] * vy;119            out[2] = a[2] * vx;120            out[3] = a[3] * vy;121            out[4] = a[4] * vx;122            out[5] = a[5] * vy;123            return out;124        },125        /**126         * æ±éç©éµ127         * @param {Float32Array|Array.<number>} out128         * @param {Float32Array|Array.<number>} a129         */130        invert : function(out, a) {131            var aa = a[0];132            var ac = a[2];133            var atx = a[4];134            var ab = a[1];135            var ad = a[3];136            var aty = a[5];137            var det = aa * ad - ab * ac;138            if (!det) {139                return null;140            }141            det = 1.0 / det;142            out[0] = ad * det;143            out[1] = -ab * det;144            out[2] = -ac * det;145            out[3] = aa * det;146            out[4] = (ac * aty - ad * atx) * det;147            out[5] = (ab * atx - aa * aty) * det;148            return out;149        }150    };151    return matrix;...

Using AI Code Generation

1const { out } = require('fast-check-monorepo');2out('hello world');3const { out } = require('fast-check-monorepo');4out('hello world');5const { out } = require('fast-check-monorepo');6out('hello world');7const { out } = require('fast-check-monorepo');8out('hello world');9const { out } = require('fast-check-monorepo');10out('hello world');11const { out } = require('fast-check-monorepo');12out('hello world');13const { out } = require('fast-check-monorepo');14out('hello world');15const { out } = require('fast-check-monorepo');16out('hello world');17const { out } = require('fast-check-monorepo');18out('hello world');19const { out } = require('fast-check-monorepo');20out('hello world');21const { out } = require('fast-check-monorepo');22out('hello world');23const { out } = require('fast-check-monorepo');24out('hello world');25const { out } = require('fast-check-monorepo');26out('hello world');27const { out }

Using AI Code Generation

1const out = require('fast-check-monorepo/out');2console.log(out);3{4 "dependencies": {5 }6}

Using AI Code Generation

1const fc = require('fast-check');2console.log(fc.out([1, 2, 3]));3const fc = require('fast-check');4console.log(fc.out([1, 2, 3]));5const fc = require('fast-check');6console.log(fc.out([1, 2, 3]));7const fc = require('fast-check');8console.log(fc.out([1, 2, 3]));9const fc = require('fast-check');10console.log(fc.out([1, 2, 3]));11const fc = require('fast-check');12console.log(fc.out([1, 2, 3]));13const fc = require('fast-check');14console.log(fc.out([1, 2, 3]));15const fc = require('fast-check');16console.log(fc.out([1, 2, 3]));17const fc = require('fast-check');18console.log(fc.out([1, 2, 3]));19const fc = require('fast-check');20console.log(fc.out([1, 2, 3]));21const fc = require('fast-check');22console.log(fc.out([1, 2, 3]));23const fc = require('fast-check');24console.log(fc.out([1, 2, 3]));25const fc = require('fast

Using AI Code Generation

1const fc = require('fast-check');2const { out } = require('fast-check-monorepo');3const { out2 } = require('fast-check-monorepo');4const { out3 } = require('fast-check-monorepo');5const { out4 } = require('fast-check-monorepo');6const arb = fc.array(fc.integer(), 1, 10);7fc.assert(fc.property(arb, (a) => {8console.log(out(a));9console.log(out2(a));10console.log(out3(a));11console.log(out4(a));12return true;13}));

Using AI Code Generation

1const {out, out2} = require('fast-check-monorepo');2out("hello");3out2("hello");4const {out, out2} = require('fast-check-monorepo');5out("hello");6out2("hello");7const {out, out2} = require('fast-check-monorepo');8out("hello");9out2("hello");10const {out, out2} = require('fast-check-monorepo');11out("hello");12out2("hello");13const {out, out2} = require('fast-check-monorepo');14out("hello");15out2("hello");16const {out, out2} = require('fast-check-monorepo');17out("hello");18out2("hello");19const {out, out2} = require('fast-check-monorepo');20out("hello");21out2("hello");22const {out, out2} = require('fast-check-monorepo');23out("hello");24out2("hello");25const {out, out2} = require('fast-check-monorepo');26out("hello");27out2("hello");28const {out, out2} = require('fast-check-monorepo');29out("hello");30out2("hello");31const {out, out2} = require('fast-check-monorepo');32out("hello");33out2("hello");34const {out

Using AI Code Generation

1const { out } = require('./out');2const fc = require('fast-check');3const { out } = require('fast-check-monorepo');4const fc = require('fast-check');5const { out } = require('./out');6const fc = require('fast-check');7const { out } = require('fast-check-monorepo');8const fc = require('fast-check');9const { out } = require('./out');10const fc = require('fast-check');11const { out } = require('fast-check-monorepo');12const fc = require('fast-check');13const { out } = require('./out');14const fc = require('fast-check');15const { out } = require('fast-check-monorepo');16const fc = require('fast-check');17const { out } = require('./out');18const fc = require('fast-check');19const { out } = require('fast-check-monorepo');20const fc = require('fast-check');21const { out } = require('./out');22const fc = require('fast-check');23const { out } = require('fast-check-monorepo');24const fc = require('fast-check');25const { out } = require('./out');26const fc = require('fast-check');27const { out } = require('fast-check-monorepo');

Using AI Code Generation

1const fc = require('fast-check');2fc.configureGlobal({ numRuns: 100 });3const out = require('fast-check-monorepo/out');4const { int32 } = require('fast-check-monorepo/out/integer');5const { arbitraryString } = require('fast-check-monorepo/out/string');6const { arbitraryDate } = require('fast-check-monorepo/out/date');7const { arbitraryArray } = require('fast-check-monorepo/out/array');8const { arbitraryObject } = require('fast-check-monorepo/out/object');9const { arbitraryTuple } = require('fast-check-monorepo/out/tuple');10const { arbitraryRecord } = require('fast-check-monorepo/out/record');11const { arbitrarySet } = require('fast-check-monorepo/out/set');12const { arbitraryMap } = require('fast-check-monorepo/out/map');13const { arbitraryOneof } = require('fast-check-monorepo/out/oneof');14const { arbitraryConstant } = require('fast-check-monorepo/out/constant');15const { arbitraryOption } = require('fast-check-monorepo/out/option');16const { arbitraryEither } = require('fast-check-monorepo/out/either');17const { arbitraryDictionary } = require('fast-check-monorepo/out/dictionary');18const { arbitraryJson } = require('fast-check-monorepo/out/json');19const { arbitraryUnicode } = require('fast-check-monorepo/out/unicode');20const { arbitraryAscii } = require('fast-check-monorepo/out/ascii');21const { arbitraryFullUnicode } = require('fast-check-monorepo/out/fullUnicode');22const { arbitraryFullAscii } = require('fast-check-monorepo/out/fullAscii');23const { arbitraryChar } = require('fast-check-monorepo/out/char');24const { arbitraryString16bits } = require('fast-check-monorepo/out/string16bits');25const { arbitraryStringFull } = require('fast-check-monorepo/out/stringFull');26const { arbitraryStringMinMaxLength } = require('fast-check-monorepo/out/stringMinMaxLength');27const { arbitraryStringOf } = require('fast-check-monorepo/out/stringOf');28const { arbitraryStringAscii } = require('fast-check-monorepo/out/stringAscii');29const { arbitraryStringFullAscii } = require('fast-check-monorepo/out/stringFullAscii');30const { arbitraryStringUnicode } = require('fast-check-monorepo/out/stringUnicode

Using AI Code Generation

1const fc = require("fast-check");2const { out } = require("fast-check-monorepo");3const myArb = fc.integer();4const myOut = out(myArb);5console.log(myOut);6const fc = require("fast-check");7const { out } = require("fast-check-monorepo");8const myArb = fc.integer();9const myOut = out(myArb);10console.log(myOut);11const fc = require("fast-check");12const { out } = require("fast-check-monorepo");13const myArb = fc.integer();14const myOut = out(myArb);15console.log(myOut);16const fc = require("fast-check");17const { out } = require("fast-check-monorepo");18const myArb = fc.integer();19const myOut = out(myArb);20console.log(myOut);21const fc = require("fast-check");22const { out } = require("fast-check-monorepo");23const myArb = fc.integer();24const myOut = out(myArb);25console.log(myOut);26const fc = require("fast-check");27const { out } = require("fast-check-monorepo");28const myArb = fc.integer();29const myOut = out(myArb);30console.log(myOut);

Using AI Code Generation

1fc.out('Hello world');2fc.out('Hello world');3fc.out('Hello world');4fc.out('Hello world');5fc.out('Hello world');6fc.out('Hello world');7fc.out('Hello world');8fc.out('Hello world');

Automation Testing Tutorials

Learn to execute automation testing from scratch with LambdaTest Learning Hub. Right from setting up the prerequisites to run your first automation test, to following best practices and diving deeper into advanced test scenarios. LambdaTest Learning Hubs compile a list of step-by-step guides to help you be proficient with different test automation frameworks i.e. Selenium, Cypress, TestNG etc.