add glMatrix.js

1 files changed, 1957 insertions, 0 deletions

diff --git a/src/gl-matrix.js b/src/gl-matrix.js
new file mode 100644
index 00000000..c3ba8335
--- /dev/null
+++ b/src/gl-matrix.js
@@ -0,0 +1,1957 @@
+/**
+ * @fileoverview gl-matrix - High performance matrix and vector operations for WebGL
+ * @author Brandon Jones
+ * @version 1.2.4
+ */
+
+/*
+ * Copyright (c) 2011 Brandon Jones
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty. In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ *    1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ *
+ *    2. Altered source versions must be plainly marked as such, and must not
+ *    be misrepresented as being the original software.
+ *
+ *    3. This notice may not be removed or altered from any source
+ *    distribution.
+ */
+
+"use strict";
+
+// Type declarations
+(function(_global) {
+    // account for CommonJS environments
+    _global.glMatrixArrayType = _global.MatrixArray = null;
+
+    /**
+     * @class 3 Dimensional Vector
+     * @name vec3
+     */
+    _global.vec3 = {};
+
+    /**
+     * @class 3x3 Matrix
+     * @name mat3
+     */
+    _global.mat3 = {};
+
+    /**
+     * @class 4x4 Matrix
+     * @name mat4
+     */
+    _global.mat4 = {};
+
+    /**
+     * @class Quaternion
+     * @name quat4
+     */
+    _global.quat4 = {};
+
+    // explicitly sets and returns the type of array to use within glMatrix
+    _global.setMatrixArrayType = function(type) {
+        return glMatrixArrayType = MatrixArray = type;
+    };
+
+    // auto-detects and returns the best type of array to use within glMatrix, falling
+    // back to Array if typed arrays are unsupported
+    _global.determineMatrixArrayType = function() {
+        return setMatrixArrayType((typeof Float32Array !== 'undefined') ? Float32Array : Array);
+    };
+
+    determineMatrixArrayType();
+})((typeof(exports) != 'undefined') ? global : this);
+
+/*
+ * vec3
+ */
+ 
+/**
+ * Creates a new instance of a vec3 using the default array type
+ * Any javascript array-like objects containing at least 3 numeric elements can serve as a vec3
+ *
+ * @param {vec3} [vec] vec3 containing values to initialize with
+ *
+ * @returns {vec3} New vec3
+ */
+vec3.create = function (vec) {
+    var dest = new MatrixArray(3);
+
+    if (vec) {
+        dest[0] = vec[0];
+        dest[1] = vec[1];
+        dest[2] = vec[2];
+    } else {
+        dest[0] = dest[1] = dest[2] = 0;
+    }
+
+    return dest;
+};
+
+/**
+ * Copies the values of one vec3 to another
+ *
+ * @param {vec3} vec vec3 containing values to copy
+ * @param {vec3} dest vec3 receiving copied values
+ *
+ * @returns {vec3} dest
+ */
+vec3.set = function (vec, dest) {
+    dest[0] = vec[0];
+    dest[1] = vec[1];
+    dest[2] = vec[2];
+
+    return dest;
+};
+
+/**
+ * Performs a vector addition
+ *
+ * @param {vec3} vec First operand
+ * @param {vec3} vec2 Second operand
+ * @param {vec3} [dest] vec3 receiving operation result. If not specified result is written to vec
+ *
+ * @returns {vec3} dest if specified, vec otherwise
+ */
+vec3.add = function (vec, vec2, dest) {
+    if (!dest || vec === dest) {
+        vec[0] += vec2[0];
+        vec[1] += vec2[1];
+        vec[2] += vec2[2];
+        return vec;
+    }
+
+    dest[0] = vec[0] + vec2[0];
+    dest[1] = vec[1] + vec2[1];
+    dest[2] = vec[2] + vec2[2];
+    return dest;
+};
+
+/**
+ * Performs a vector subtraction
+ *
+ * @param {vec3} vec First operand
+ * @param {vec3} vec2 Second operand
+ * @param {vec3} [dest] vec3 receiving operation result. If not specified result is written to vec
+ *
+ * @returns {vec3} dest if specified, vec otherwise
+ */
+vec3.subtract = function (vec, vec2, dest) {
+    if (!dest || vec === dest) {
+        vec[0] -= vec2[0];
+        vec[1] -= vec2[1];
+        vec[2] -= vec2[2];
+        return vec;
+    }
+
+    dest[0] = vec[0] - vec2[0];
+    dest[1] = vec[1] - vec2[1];
+    dest[2] = vec[2] - vec2[2];
+    return dest;
+};
+
+/**
+ * Performs a vector multiplication
+ *
+ * @param {vec3} vec First operand
+ * @param {vec3} vec2 Second operand
+ * @param {vec3} [dest] vec3 receiving operation result. If not specified result is written to vec
+ *
+ * @returns {vec3} dest if specified, vec otherwise
+ */
+vec3.multiply = function (vec, vec2, dest) {
+    if (!dest || vec === dest) {
+        vec[0] *= vec2[0];
+        vec[1] *= vec2[1];
+        vec[2] *= vec2[2];
+        return vec;
+    }
+
+    dest[0] = vec[0] * vec2[0];
+    dest[1] = vec[1] * vec2[1];
+    dest[2] = vec[2] * vec2[2];
+    return dest;
+};
+
+/**
+ * Negates the components of a vec3
+ *
+ * @param {vec3} vec vec3 to negate
+ * @param {vec3} [dest] vec3 receiving operation result. If not specified result is written to vec
+ *
+ * @returns {vec3} dest if specified, vec otherwise
+ */
+vec3.negate = function (vec, dest) {
+    if (!dest) { dest = vec; }
+
+    dest[0] = -vec[0];
+    dest[1] = -vec[1];
+    dest[2] = -vec[2];
+    return dest;
+};
+
+/**
+ * Multiplies the components of a vec3 by a scalar value
+ *
+ * @param {vec3} vec vec3 to scale
+ * @param {number} val Value to scale by
+ * @param {vec3} [dest] vec3 receiving operation result. If not specified result is written to vec
+ *
+ * @returns {vec3} dest if specified, vec otherwise
+ */
+vec3.scale = function (vec, val, dest) {
+    if (!dest || vec === dest) {
+        vec[0] *= val;
+        vec[1] *= val;
+        vec[2] *= val;
+        return vec;
+    }
+
+    dest[0] = vec[0] * val;
+    dest[1] = vec[1] * val;
+    dest[2] = vec[2] * val;
+    return dest;
+};
+
+/**
+ * Generates a unit vector of the same direction as the provided vec3
+ * If vector length is 0, returns [0, 0, 0]
+ *
+ * @param {vec3} vec vec3 to normalize
+ * @param {vec3} [dest] vec3 receiving operation result. If not specified result is written to vec
+ *
+ * @returns {vec3} dest if specified, vec otherwise
+ */
+vec3.normalize = function (vec, dest) {
+    if (!dest) { dest = vec; }
+
+    var x = vec[0], y = vec[1], z = vec[2],
+        len = Math.sqrt(x * x + y * y + z * z);
+
+    if (!len) {
+        dest[0] = 0;
+        dest[1] = 0;
+        dest[2] = 0;
+        return dest;
+    } else if (len === 1) {
+        dest[0] = x;
+        dest[1] = y;
+        dest[2] = z;
+        return dest;
+    }
+
+    len = 1 / len;
+    dest[0] = x * len;
+    dest[1] = y * len;
+    dest[2] = z * len;
+    return dest;
+};
+
+/**
+ * Generates the cross product of two vec3s
+ *
+ * @param {vec3} vec First operand
+ * @param {vec3} vec2 Second operand
+ * @param {vec3} [dest] vec3 receiving operation result. If not specified result is written to vec
+ *
+ * @returns {vec3} dest if specified, vec otherwise
+ */
+vec3.cross = function (vec, vec2, dest) {
+    if (!dest) { dest = vec; }
+
+    var x = vec[0], y = vec[1], z = vec[2],
+        x2 = vec2[0], y2 = vec2[1], z2 = vec2[2];
+
+    dest[0] = y * z2 - z * y2;
+    dest[1] = z * x2 - x * z2;
+    dest[2] = x * y2 - y * x2;
+    return dest;
+};
+
+/**
+ * Caclulates the length of a vec3
+ *
+ * @param {vec3} vec vec3 to calculate length of
+ *
+ * @returns {number} Length of vec
+ */
+vec3.length = function (vec) {
+    var x = vec[0], y = vec[1], z = vec[2];
+    return Math.sqrt(x * x + y * y + z * z);
+};
+
+/**
+ * Caclulates the dot product of two vec3s
+ *
+ * @param {vec3} vec First operand
+ * @param {vec3} vec2 Second operand
+ *
+ * @returns {number} Dot product of vec and vec2
+ */
+vec3.dot = function (vec, vec2) {
+    return vec[0] * vec2[0] + vec[1] * vec2[1] + vec[2] * vec2[2];
+};
+
+/**
+ * Generates a unit vector pointing from one vector to another
+ *
+ * @param {vec3} vec Origin vec3
+ * @param {vec3} vec2 vec3 to point to
+ * @param {vec3} [dest] vec3 receiving operation result. If not specified result is written to vec
+ *
+ * @returns {vec3} dest if specified, vec otherwise
+ */
+vec3.direction = function (vec, vec2, dest) {
+    if (!dest) { dest = vec; }
+
+    var x = vec[0] - vec2[0],
+        y = vec[1] - vec2[1],
+        z = vec[2] - vec2[2],
+        len = Math.sqrt(x * x + y * y + z * z);
+
+    if (!len) {
+        dest[0] = 0;
+        dest[1] = 0;
+        dest[2] = 0;
+        return dest;
+    }
+
+    len = 1 / len;
+    dest[0] = x * len;
+    dest[1] = y * len;
+    dest[2] = z * len;
+    return dest;
+};
+
+/**
+ * Performs a linear interpolation between two vec3
+ *
+ * @param {vec3} vec First vector
+ * @param {vec3} vec2 Second vector
+ * @param {number} lerp Interpolation amount between the two inputs
+ * @param {vec3} [dest] vec3 receiving operation result. If not specified result is written to vec
+ *
+ * @returns {vec3} dest if specified, vec otherwise
+ */
+vec3.lerp = function (vec, vec2, lerp, dest) {
+    if (!dest) { dest = vec; }
+
+    dest[0] = vec[0] + lerp * (vec2[0] - vec[0]);
+    dest[1] = vec[1] + lerp * (vec2[1] - vec[1]);
+    dest[2] = vec[2] + lerp * (vec2[2] - vec[2]);
+
+    return dest;
+};
+
+/**
+ * Calculates the euclidian distance between two vec3
+ *
+ * Params:
+ * @param {vec3} vec First vector
+ * @param {vec3} vec2 Second vector
+ *
+ * @returns {number} Distance between vec and vec2
+ */
+vec3.dist = function (vec, vec2) {
+    var x = vec2[0] - vec[0],
+        y = vec2[1] - vec[1],
+        z = vec2[2] - vec[2];
+        
+    return Math.sqrt(x*x + y*y + z*z);
+};
+
+/**
+ * Projects the specified vec3 from screen space into object space
+ * Based on the <a href="http://webcvs.freedesktop.org/mesa/Mesa/src/glu/mesa/project.c?revision=1.4&view=markup">Mesa gluUnProject implementation</a>
+ *
+ * @param {vec3} vec Screen-space vector to project
+ * @param {mat4} view View matrix
+ * @param {mat4} proj Projection matrix
+ * @param {vec4} viewport Viewport as given to gl.viewport [x, y, width, height]
+ * @param {vec3} [dest] vec3 receiving unprojected result. If not specified result is written to vec
+ *
+ * @returns {vec3} dest if specified, vec otherwise
+ */
+vec3.unproject = function (vec, view, proj, viewport, dest) {
+    if (!dest) { dest = vec; }
+
+    var m = mat4.create();
+    var v = new MatrixArray(4);
+    
+    v[0] = (vec[0] - viewport[0]) * 2.0 / viewport[2] - 1.0;
+    v[1] = (vec[1] - viewport[1]) * 2.0 / viewport[3] - 1.0;
+    v[2] = 2.0 * vec[2] - 1.0;
+    v[3] = 1.0;
+    
+    mat4.multiply(proj, view, m);
+    if(!mat4.inverse(m)) { return null; }
+    
+    mat4.multiplyVec4(m, v);
+    if(v[3] === 0.0) { return null; }
+
+    dest[0] = v[0] / v[3];
+    dest[1] = v[1] / v[3];
+    dest[2] = v[2] / v[3];
+    
+    return dest;
+};
+
+/**
+ * Returns a string representation of a vector
+ *
+ * @param {vec3} vec Vector to represent as a string
+ *
+ * @returns {string} String representation of vec
+ */
+vec3.str = function (vec) {
+    return '[' + vec[0] + ', ' + vec[1] + ', ' + vec[2] + ']';
+};
+
+/*
+ * mat3
+ */
+
+/**
+ * Creates a new instance of a mat3 using the default array type
+ * Any javascript array-like object containing at least 9 numeric elements can serve as a mat3
+ *
+ * @param {mat3} [mat] mat3 containing values to initialize with
+ *
+ * @returns {mat3} New mat3
+ */
+mat3.create = function (mat) {
+    var dest = new MatrixArray(9);
+
+    if (mat) {
+        dest[0] = mat[0];
+        dest[1] = mat[1];
+        dest[2] = mat[2];
+        dest[3] = mat[3];
+        dest[4] = mat[4];
+        dest[5] = mat[5];
+        dest[6] = mat[6];
+        dest[7] = mat[7];
+        dest[8] = mat[8];
+    }
+
+    return dest;
+};
+
+/**
+ * Copies the values of one mat3 to another
+ *
+ * @param {mat3} mat mat3 containing values to copy
+ * @param {mat3} dest mat3 receiving copied values
+ *
+ * @returns {mat3} dest
+ */
+mat3.set = function (mat, dest) {
+    dest[0] = mat[0];
+    dest[1] = mat[1];
+    dest[2] = mat[2];
+    dest[3] = mat[3];
+    dest[4] = mat[4];
+    dest[5] = mat[5];
+    dest[6] = mat[6];
+    dest[7] = mat[7];
+    dest[8] = mat[8];
+    return dest;
+};
+
+/**
+ * Sets a mat3 to an identity matrix
+ *
+ * @param {mat3} dest mat3 to set
+ *
+ * @returns dest if specified, otherwise a new mat3
+ */
+mat3.identity = function (dest) {
+    if (!dest) { dest = mat3.create(); }
+    dest[0] = 1;
+    dest[1] = 0;
+    dest[2] = 0;
+    dest[3] = 0;
+    dest[4] = 1;
+    dest[5] = 0;
+    dest[6] = 0;
+    dest[7] = 0;
+    dest[8] = 1;
+    return dest;
+};
+
+/**
+ * Transposes a mat3 (flips the values over the diagonal)
+ *
+ * Params:
+ * @param {mat3} mat mat3 to transpose
+ * @param {mat3} [dest] mat3 receiving transposed values. If not specified result is written to mat
+ *
+ * @returns {mat3} dest is specified, mat otherwise
+ */
+mat3.transpose = function (mat, dest) {
+    // If we are transposing ourselves we can skip a few steps but have to cache some values
+    if (!dest || mat === dest) {
+        var a01 = mat[1], a02 = mat[2],
+            a12 = mat[5];
+
+        mat[1] = mat[3];
+        mat[2] = mat[6];
+        mat[3] = a01;
+        mat[5] = mat[7];
+        mat[6] = a02;
+        mat[7] = a12;
+        return mat;
+    }
+
+    dest[0] = mat[0];
+    dest[1] = mat[3];
+    dest[2] = mat[6];
+    dest[3] = mat[1];
+    dest[4] = mat[4];
+    dest[5] = mat[7];
+    dest[6] = mat[2];
+    dest[7] = mat[5];
+    dest[8] = mat[8];
+    return dest;
+};
+
+/**
+ * Copies the elements of a mat3 into the upper 3x3 elements of a mat4
+ *
+ * @param {mat3} mat mat3 containing values to copy
+ * @param {mat4} [dest] mat4 receiving copied values
+ *
+ * @returns {mat4} dest if specified, a new mat4 otherwise
+ */
+mat3.toMat4 = function (mat, dest) {
+    if (!dest) { dest = mat4.create(); }
+
+    dest[15] = 1;
+    dest[14] = 0;
+    dest[13] = 0;
+    dest[12] = 0;
+
+    dest[11] = 0;
+    dest[10] = mat[8];
+    dest[9] = mat[7];
+    dest[8] = mat[6];
+
+    dest[7] = 0;
+    dest[6] = mat[5];
+    dest[5] = mat[4];
+    dest[4] = mat[3];
+
+    dest[3] = 0;
+    dest[2] = mat[2];
+    dest[1] = mat[1];
+    dest[0] = mat[0];
+
+    return dest;
+};
+
+/**
+ * Returns a string representation of a mat3
+ *
+ * @param {mat3} mat mat3 to represent as a string
+ *
+ * @param {string} String representation of mat
+ */
+mat3.str = function (mat) {
+    return '[' + mat[0] + ', ' + mat[1] + ', ' + mat[2] +
+        ', ' + mat[3] + ', ' + mat[4] + ', ' + mat[5] +
+        ', ' + mat[6] + ', ' + mat[7] + ', ' + mat[8] + ']';
+};
+
+/*
+ * mat4
+ */
+
+/**
+ * Creates a new instance of a mat4 using the default array type
+ * Any javascript array-like object containing at least 16 numeric elements can serve as a mat4
+ *
+ * @param {mat4} [mat] mat4 containing values to initialize with
+ *
+ * @returns {mat4} New mat4
+ */
+mat4.create = function (mat) {
+    var dest = new MatrixArray(16);
+
+    if (mat) {
+        dest[0] = mat[0];
+        dest[1] = mat[1];
+        dest[2] = mat[2];
+        dest[3] = mat[3];
+        dest[4] = mat[4];
+        dest[5] = mat[5];
+        dest[6] = mat[6];
+        dest[7] = mat[7];
+        dest[8] = mat[8];
+        dest[9] = mat[9];
+        dest[10] = mat[10];
+        dest[11] = mat[11];
+        dest[12] = mat[12];
+        dest[13] = mat[13];
+        dest[14] = mat[14];
+        dest[15] = mat[15];
+    }
+
+    return dest;
+};
+
+/**
+ * Copies the values of one mat4 to another
+ *
+ * @param {mat4} mat mat4 containing values to copy
+ * @param {mat4} dest mat4 receiving copied values
+ *
+ * @returns {mat4} dest
+ */
+mat4.set = function (mat, dest) {
+    dest[0] = mat[0];
+    dest[1] = mat[1];
+    dest[2] = mat[2];
+    dest[3] = mat[3];
+    dest[4] = mat[4];
+    dest[5] = mat[5];
+    dest[6] = mat[6];
+    dest[7] = mat[7];
+    dest[8] = mat[8];
+    dest[9] = mat[9];
+    dest[10] = mat[10];
+    dest[11] = mat[11];
+    dest[12] = mat[12];
+    dest[13] = mat[13];
+    dest[14] = mat[14];
+    dest[15] = mat[15];
+    return dest;
+};
+
+/**
+ * Sets a mat4 to an identity matrix
+ *
+ * @param {mat4} dest mat4 to set
+ *
+ * @returns {mat4} dest
+ */
+mat4.identity = function (dest) {
+    if (!dest) { dest = mat4.create(); }
+    dest[0] = 1;
+    dest[1] = 0;
+    dest[2] = 0;
+    dest[3] = 0;
+    dest[4] = 0;
+    dest[5] = 1;
+    dest[6] = 0;
+    dest[7] = 0;
+    dest[8] = 0;
+    dest[9] = 0;
+    dest[10] = 1;
+    dest[11] = 0;
+    dest[12] = 0;
+    dest[13] = 0;
+    dest[14] = 0;
+    dest[15] = 1;
+    return dest;
+};
+
+/**
+ * Transposes a mat4 (flips the values over the diagonal)
+ *
+ * @param {mat4} mat mat4 to transpose
+ * @param {mat4} [dest] mat4 receiving transposed values. If not specified result is written to mat
+ *
+ * @param {mat4} dest is specified, mat otherwise
+ */
+mat4.transpose = function (mat, dest) {
+    // If we are transposing ourselves we can skip a few steps but have to cache some values
+    if (!dest || mat === dest) {
+        var a01 = mat[1], a02 = mat[2], a03 = mat[3],
+            a12 = mat[6], a13 = mat[7],
+            a23 = mat[11];
+
+        mat[1] = mat[4];
+        mat[2] = mat[8];
+        mat[3] = mat[12];
+        mat[4] = a01;
+        mat[6] = mat[9];
+        mat[7] = mat[13];
+        mat[8] = a02;
+        mat[9] = a12;
+        mat[11] = mat[14];
+        mat[12] = a03;
+        mat[13] = a13;
+        mat[14] = a23;
+        return mat;
+    }
+
+    dest[0] = mat[0];
+    dest[1] = mat[4];
+    dest[2] = mat[8];
+    dest[3] = mat[12];
+    dest[4] = mat[1];
+    dest[5] = mat[5];
+    dest[6] = mat[9];
+    dest[7] = mat[13];
+    dest[8] = mat[2];
+    dest[9] = mat[6];
+    dest[10] = mat[10];
+    dest[11] = mat[14];
+    dest[12] = mat[3];
+    dest[13] = mat[7];
+    dest[14] = mat[11];
+    dest[15] = mat[15];
+    return dest;
+};
+
+/**
+ * Calculates the determinant of a mat4
+ *
+ * @param {mat4} mat mat4 to calculate determinant of
+ *
+ * @returns {number} determinant of mat
+ */
+mat4.determinant = function (mat) {
+    // Cache the matrix values (makes for huge speed increases!)
+    var a00 = mat[0], a01 = mat[1], a02 = mat[2], a03 = mat[3],
+        a10 = mat[4], a11 = mat[5], a12 = mat[6], a13 = mat[7],
+        a20 = mat[8], a21 = mat[9], a22 = mat[10], a23 = mat[11],
+        a30 = mat[12], a31 = mat[13], a32 = mat[14], a33 = mat[15];
+
+    return (a30 * a21 * a12 * a03 - a20 * a31 * a12 * a03 - a30 * a11 * a22 * a03 + a10 * a31 * a22 * a03 +
+            a20 * a11 * a32 * a03 - a10 * a21 * a32 * a03 - a30 * a21 * a02 * a13 + a20 * a31 * a02 * a13 +
+            a30 * a01 * a22 * a13 - a00 * a31 * a22 * a13 - a20 * a01 * a32 * a13 + a00 * a21 * a32 * a13 +
+            a30 * a11 * a02 * a23 - a10 * a31 * a02 * a23 - a30 * a01 * a12 * a23 + a00 * a31 * a12 * a23 +
+            a10 * a01 * a32 * a23 - a00 * a11 * a32 * a23 - a20 * a11 * a02 * a33 + a10 * a21 * a02 * a33 +
+            a20 * a01 * a12 * a33 - a00 * a21 * a12 * a33 - a10 * a01 * a22 * a33 + a00 * a11 * a22 * a33);
+};
+
+/**
+ * Calculates the inverse matrix of a mat4
+ *
+ * @param {mat4} mat mat4 to calculate inverse of
+ * @param {mat4} [dest] mat4 receiving inverse matrix. If not specified result is written to mat
+ *
+ * @param {mat4} dest is specified, mat otherwise, null if matrix cannot be inverted
+ */
+mat4.inverse = function (mat, dest) {
+    if (!dest) { dest = mat; }
+
+    // Cache the matrix values (makes for huge speed increases!)
+    var a00 = mat[0], a01 = mat[1], a02 = mat[2], a03 = mat[3],
+        a10 = mat[4], a11 = mat[5], a12 = mat[6], a13 = mat[7],
+        a20 = mat[8], a21 = mat[9], a22 = mat[10], a23 = mat[11],
+        a30 = mat[12], a31 = mat[13], a32 = mat[14], a33 = mat[15],
+
+        b00 = a00 * a11 - a01 * a10,
+        b01 = a00 * a12 - a02 * a10,
+        b02 = a00 * a13 - a03 * a10,
+        b03 = a01 * a12 - a02 * a11,
+        b04 = a01 * a13 - a03 * a11,
+        b05 = a02 * a13 - a03 * a12,
+        b06 = a20 * a31 - a21 * a30,
+        b07 = a20 * a32 - a22 * a30,
+        b08 = a20 * a33 - a23 * a30,
+        b09 = a21 * a32 - a22 * a31,
+        b10 = a21 * a33 - a23 * a31,
+        b11 = a22 * a33 - a23 * a32,
+
+        d = (b00 * b11 - b01 * b10 + b02 * b09 + b03 * b08 - b04 * b07 + b05 * b06),
+        invDet;
+
+        // Calculate the determinant
+        if (!d) { return null; }
+        invDet = 1 / d;
+
+    dest[0] = (a11 * b11 - a12 * b10 + a13 * b09) * invDet;
+    dest[1] = (-a01 * b11 + a02 * b10 - a03 * b09) * invDet;
+    dest[2] = (a31 * b05 - a32 * b04 + a33 * b03) * invDet;
+    dest[3] = (-a21 * b05 + a22 * b04 - a23 * b03) * invDet;
+    dest[4] = (-a10 * b11 + a12 * b08 - a13 * b07) * invDet;
+    dest[5] = (a00 * b11 - a02 * b08 + a03 * b07) * invDet;
+    dest[6] = (-a30 * b05 + a32 * b02 - a33 * b01) * invDet;
+    dest[7] = (a20 * b05 - a22 * b02 + a23 * b01) * invDet;
+    dest[8] = (a10 * b10 - a11 * b08 + a13 * b06) * invDet;
+    dest[9] = (-a00 * b10 + a01 * b08 - a03 * b06) * invDet;
+    dest[10] = (a30 * b04 - a31 * b02 + a33 * b00) * invDet;
+    dest[11] = (-a20 * b04 + a21 * b02 - a23 * b00) * invDet;
+    dest[12] = (-a10 * b09 + a11 * b07 - a12 * b06) * invDet;
+    dest[13] = (a00 * b09 - a01 * b07 + a02 * b06) * invDet;
+    dest[14] = (-a30 * b03 + a31 * b01 - a32 * b00) * invDet;
+    dest[15] = (a20 * b03 - a21 * b01 + a22 * b00) * invDet;
+
+    return dest;
+};
+
+/**
+ * Copies the upper 3x3 elements of a mat4 into another mat4
+ *
+ * @param {mat4} mat mat4 containing values to copy
+ * @param {mat4} [dest] mat4 receiving copied values
+ *
+ * @returns {mat4} dest is specified, a new mat4 otherwise
+ */
+mat4.toRotationMat = function (mat, dest) {
+    if (!dest) { dest = mat4.create(); }
+
+    dest[0] = mat[0];
+    dest[1] = mat[1];
+    dest[2] = mat[2];
+    dest[3] = mat[3];
+    dest[4] = mat[4];
+    dest[5] = mat[5];
+    dest[6] = mat[6];
+    dest[7] = mat[7];
+    dest[8] = mat[8];
+    dest[9] = mat[9];
+    dest[10] = mat[10];
+    dest[11] = mat[11];
+    dest[12] = 0;
+    dest[13] = 0;
+    dest[14] = 0;
+    dest[15] = 1;
+
+    return dest;
+};
+
+/**
+ * Copies the upper 3x3 elements of a mat4 into a mat3
+ *
+ * @param {mat4} mat mat4 containing values to copy
+ * @param {mat3} [dest] mat3 receiving copied values
+ *
+ * @returns {mat3} dest is specified, a new mat3 otherwise
+ */
+mat4.toMat3 = function (mat, dest) {
+    if (!dest) { dest = mat3.create(); }
+
+    dest[0] = mat[0];
+    dest[1] = mat[1];
+    dest[2] = mat[2];
+    dest[3] = mat[4];
+    dest[4] = mat[5];
+    dest[5] = mat[6];
+    dest[6] = mat[8];
+    dest[7] = mat[9];
+    dest[8] = mat[10];
+
+    return dest;
+};
+
+/**
+ * Calculates the inverse of the upper 3x3 elements of a mat4 and copies the result into a mat3
+ * The resulting matrix is useful for calculating transformed normals
+ *
+ * Params:
+ * @param {mat4} mat mat4 containing values to invert and copy
+ * @param {mat3} [dest] mat3 receiving values
+ *
+ * @returns {mat3} dest is specified, a new mat3 otherwise, null if the matrix cannot be inverted
+ */
+mat4.toInverseMat3 = function (mat, dest) {
+    // Cache the matrix values (makes for huge speed increases!)
+    var a00 = mat[0], a01 = mat[1], a02 = mat[2],
+        a10 = mat[4], a11 = mat[5], a12 = mat[6],
+        a20 = mat[8], a21 = mat[9], a22 = mat[10],
+
+        b01 = a22 * a11 - a12 * a21,
+        b11 = -a22 * a10 + a12 * a20,
+        b21 = a21 * a10 - a11 * a20,
+
+        d = a00 * b01 + a01 * b11 + a02 * b21,
+        id;
+
+    if (!d) { return null; }
+    id = 1 / d;
+
+    if (!dest) { dest = mat3.create(); }
+
+    dest[0] = b01 * id;
+    dest[1] = (-a22 * a01 + a02 * a21) * id;
+    dest[2] = (a12 * a01 - a02 * a11) * id;
+    dest[3] = b11 * id;
+    dest[4] = (a22 * a00 - a02 * a20) * id;
+    dest[5] = (-a12 * a00 + a02 * a10) * id;
+    dest[6] = b21 * id;
+    dest[7] = (-a21 * a00 + a01 * a20) * id;
+    dest[8] = (a11 * a00 - a01 * a10) * id;
+
+    return dest;
+};
+
+/**
+ * Performs a matrix multiplication
+ *
+ * @param {mat4} mat First operand
+ * @param {mat4} mat2 Second operand
+ * @param {mat4} [dest] mat4 receiving operation result. If not specified result is written to mat
+ *
+ * @returns {mat4} dest if specified, mat otherwise
+ */
+mat4.multiply = function (mat, mat2, dest) {
+    if (!dest) { dest = mat; }
+
+    // Cache the matrix values (makes for huge speed increases!)
+    var a00 = mat[0], a01 = mat[1], a02 = mat[2], a03 = mat[3],
+        a10 = mat[4], a11 = mat[5], a12 = mat[6], a13 = mat[7],
+        a20 = mat[8], a21 = mat[9], a22 = mat[10], a23 = mat[11],
+        a30 = mat[12], a31 = mat[13], a32 = mat[14], a33 = mat[15],
+
+        b00 = mat2[0], b01 = mat2[1], b02 = mat2[2], b03 = mat2[3],
+        b10 = mat2[4], b11 = mat2[5], b12 = mat2[6], b13 = mat2[7],
+        b20 = mat2[8], b21 = mat2[9], b22 = mat2[10], b23 = mat2[11],
+        b30 = mat2[12], b31 = mat2[13], b32 = mat2[14], b33 = mat2[15];
+
+    dest[0] = b00 * a00 + b01 * a10 + b02 * a20 + b03 * a30;
+    dest[1] = b00 * a01 + b01 * a11 + b02 * a21 + b03 * a31;
+    dest[2] = b00 * a02 + b01 * a12 + b02 * a22 + b03 * a32;
+    dest[3] = b00 * a03 + b01 * a13 + b02 * a23 + b03 * a33;
+    dest[4] = b10 * a00 + b11 * a10 + b12 * a20 + b13 * a30;
+    dest[5] = b10 * a01 + b11 * a11 + b12 * a21 + b13 * a31;
+    dest[6] = b10 * a02 + b11 * a12 + b12 * a22 + b13 * a32;
+    dest[7] = b10 * a03 + b11 * a13 + b12 * a23 + b13 * a33;
+    dest[8] = b20 * a00 + b21 * a10 + b22 * a20 + b23 * a30;
+    dest[9] = b20 * a01 + b21 * a11 + b22 * a21 + b23 * a31;
+    dest[10] = b20 * a02 + b21 * a12 + b22 * a22 + b23 * a32;
+    dest[11] = b20 * a03 + b21 * a13 + b22 * a23 + b23 * a33;
+    dest[12] = b30 * a00 + b31 * a10 + b32 * a20 + b33 * a30;
+    dest[13] = b30 * a01 + b31 * a11 + b32 * a21 + b33 * a31;
+    dest[14] = b30 * a02 + b31 * a12 + b32 * a22 + b33 * a32;
+    dest[15] = b30 * a03 + b31 * a13 + b32 * a23 + b33 * a33;
+
+    return dest;
+};
+
+/**
+ * Transforms a vec3 with the given matrix
+ * 4th vector component is implicitly '1'
+ *
+ * @param {mat4} mat mat4 to transform the vector with
+ * @param {vec3} vec vec3 to transform
+ * @param {vec3} [dest] vec3 receiving operation result. If not specified result is written to vec
+ *
+ * @returns {vec3} dest if specified, vec otherwise
+ */
+mat4.multiplyVec3 = function (mat, vec, dest) {
+    if (!dest) { dest = vec; }
+
+    var x = vec[0], y = vec[1], z = vec[2];
+
+    dest[0] = mat[0] * x + mat[4] * y + mat[8] * z + mat[12];
+    dest[1] = mat[1] * x + mat[5] * y + mat[9] * z + mat[13];
+    dest[2] = mat[2] * x + mat[6] * y + mat[10] * z + mat[14];
+
+    return dest;
+};
+
+/**
+ * Transforms a vec4 with the given matrix
+ *
+ * @param {mat4} mat mat4 to transform the vector with
+ * @param {vec4} vec vec4 to transform
+ * @param {vec4} [dest] vec4 receiving operation result. If not specified result is written to vec
+ *
+ * @returns {vec4} dest if specified, vec otherwise
+ */
+mat4.multiplyVec4 = function (mat, vec, dest) {
+    if (!dest) { dest = vec; }
+
+    var x = vec[0], y = vec[1], z = vec[2], w = vec[3];
+
+    dest[0] = mat[0] * x + mat[4] * y + mat[8] * z + mat[12] * w;
+    dest[1] = mat[1] * x + mat[5] * y + mat[9] * z + mat[13] * w;
+    dest[2] = mat[2] * x + mat[6] * y + mat[10] * z + mat[14] * w;
+    dest[3] = mat[3] * x + mat[7] * y + mat[11] * z + mat[15] * w;
+
+    return dest;
+};
+
+/**
+ * Translates a matrix by the given vector
+ *
+ * @param {mat4} mat mat4 to translate
+ * @param {vec3} vec vec3 specifying the translation
+ * @param {mat4} [dest] mat4 receiving operation result. If not specified result is written to mat
+ *
+ * @returns {mat4} dest if specified, mat otherwise
+ */
+mat4.translate = function (mat, vec, dest) {
+    var x = vec[0], y = vec[1], z = vec[2],
+        a00, a01, a02, a03,
+        a10, a11, a12, a13,
+        a20, a21, a22, a23;
+
+    if (!dest || mat === dest) {
+        mat[12] = mat[0] * x + mat[4] * y + mat[8] * z + mat[12];
+        mat[13] = mat[1] * x + mat[5] * y + mat[9] * z + mat[13];
+        mat[14] = mat[2] * x + mat[6] * y + mat[10] * z + mat[14];
+        mat[15] = mat[3] * x + mat[7] * y + mat[11] * z + mat[15];
+        return mat;
+    }
+
+    a00 = mat[0]; a01 = mat[1]; a02 = mat[2]; a03 = mat[3];
+    a10 = mat[4]; a11 = mat[5]; a12 = mat[6]; a13 = mat[7];
+    a20 = mat[8]; a21 = mat[9]; a22 = mat[10]; a23 = mat[11];
+
+    dest[0] = a00; dest[1] = a01; dest[2] = a02; dest[3] = a03;
+    dest[4] = a10; dest[5] = a11; dest[6] = a12; dest[7] = a13;
+    dest[8] = a20; dest[9] = a21; dest[10] = a22; dest[11] = a23;
+
+    dest[12] = a00 * x + a10 * y + a20 * z + mat[12];
+    dest[13] = a01 * x + a11 * y + a21 * z + mat[13];
+    dest[14] = a02 * x + a12 * y + a22 * z + mat[14];
+    dest[15] = a03 * x + a13 * y + a23 * z + mat[15];
+    return dest;
+};
+
+/**
+ * Scales a matrix by the given vector
+ *
+ * @param {mat4} mat mat4 to scale
+ * @param {vec3} vec vec3 specifying the scale for each axis
+ * @param {mat4} [dest] mat4 receiving operation result. If not specified result is written to mat
+ *
+ * @param {mat4} dest if specified, mat otherwise
+ */
+mat4.scale = function (mat, vec, dest) {
+    var x = vec[0], y = vec[1], z = vec[2];
+
+    if (!dest || mat === dest) {
+        mat[0] *= x;
+        mat[1] *= x;
+        mat[2] *= x;
+        mat[3] *= x;
+        mat[4] *= y;
+        mat[5] *= y;
+        mat[6] *= y;
+        mat[7] *= y;
+        mat[8] *= z;
+        mat[9] *= z;
+        mat[10] *= z;
+        mat[11] *= z;
+        return mat;
+    }
+
+    dest[0] = mat[0] * x;
+    dest[1] = mat[1] * x;
+    dest[2] = mat[2] * x;
+    dest[3] = mat[3] * x;
+    dest[4] = mat[4] * y;
+    dest[5] = mat[5] * y;
+    dest[6] = mat[6] * y;
+    dest[7] = mat[7] * y;
+    dest[8] = mat[8] * z;
+    dest[9] = mat[9] * z;
+    dest[10] = mat[10] * z;
+    dest[11] = mat[11] * z;
+    dest[12] = mat[12];
+    dest[13] = mat[13];
+    dest[14] = mat[14];
+    dest[15] = mat[15];
+    return dest;
+};
+
+/**
+ * Rotates a matrix by the given angle around the specified axis
+ * If rotating around a primary axis (X,Y,Z) one of the specialized rotation functions should be used instead for performance
+ *
+ * @param {mat4} mat mat4 to rotate
+ * @param {number} angle Angle (in radians) to rotate
+ * @param {vec3} axis vec3 representing the axis to rotate around 
+ * @param {mat4} [dest] mat4 receiving operation result. If not specified result is written to mat
+ *
+ * @returns {mat4} dest if specified, mat otherwise
+ */
+mat4.rotate = function (mat, angle, axis, dest) {
+    var x = axis[0], y = axis[1], z = axis[2],
+        len = Math.sqrt(x * x + y * y + z * z),
+        s, c, t,
+        a00, a01, a02, a03,
+        a10, a11, a12, a13,
+        a20, a21, a22, a23,
+        b00, b01, b02,
+        b10, b11, b12,
+        b20, b21, b22;
+
+    if (!len) { return null; }
+    if (len !== 1) {
+        len = 1 / len;
+        x *= len;
+        y *= len;
+        z *= len;
+    }
+
+    s = Math.sin(angle);
+    c = Math.cos(angle);
+    t = 1 - c;
+
+    a00 = mat[0]; a01 = mat[1]; a02 = mat[2]; a03 = mat[3];
+    a10 = mat[4]; a11 = mat[5]; a12 = mat[6]; a13 = mat[7];
+    a20 = mat[8]; a21 = mat[9]; a22 = mat[10]; a23 = mat[11];
+
+    // Construct the elements of the rotation matrix
+    b00 = x * x * t + c; b01 = y * x * t + z * s; b02 = z * x * t - y * s;
+    b10 = x * y * t - z * s; b11 = y * y * t + c; b12 = z * y * t + x * s;
+    b20 = x * z * t + y * s; b21 = y * z * t - x * s; b22 = z * z * t + c;
+
+    if (!dest) {
+        dest = mat;
+    } else if (mat !== dest) { // If the source and destination differ, copy the unchanged last row
+        dest[12] = mat[12];
+        dest[13] = mat[13];
+        dest[14] = mat[14];
+        dest[15] = mat[15];
+    }
+
+    // Perform rotation-specific matrix multiplication
+    dest[0] = a00 * b00 + a10 * b01 + a20 * b02;
+    dest[1] = a01 * b00 + a11 * b01 + a21 * b02;
+    dest[2] = a02 * b00 + a12 * b01 + a22 * b02;
+    dest[3] = a03 * b00 + a13 * b01 + a23 * b02;
+
+    dest[4] = a00 * b10 + a10 * b11 + a20 * b12;
+    dest[5] = a01 * b10 + a11 * b11 + a21 * b12;
+    dest[6] = a02 * b10 + a12 * b11 + a22 * b12;
+    dest[7] = a03 * b10 + a13 * b11 + a23 * b12;
+
+    dest[8] = a00 * b20 + a10 * b21 + a20 * b22;
+    dest[9] = a01 * b20 + a11 * b21 + a21 * b22;
+    dest[10] = a02 * b20 + a12 * b21 + a22 * b22;
+    dest[11] = a03 * b20 + a13 * b21 + a23 * b22;
+    return dest;
+};
+
+/**
+ * Rotates a matrix by the given angle around the X axis
+ *
+ * @param {mat4} mat mat4 to rotate
+ * @param {number} angle Angle (in radians) to rotate
+ * @param {mat4} [dest] mat4 receiving operation result. If not specified result is written to mat
+ *
+ * @returns {mat4} dest if specified, mat otherwise
+ */
+mat4.rotateX = function (mat, angle, dest) {
+    var s = Math.sin(angle),
+        c = Math.cos(angle),
+        a10 = mat[4],
+        a11 = mat[5],
+        a12 = mat[6],
+        a13 = mat[7],
+        a20 = mat[8],
+        a21 = mat[9],
+        a22 = mat[10],
+        a23 = mat[11];
+
+    if (!dest) {
+        dest = mat;
+    } else if (mat !== dest) { // If the source and destination differ, copy the unchanged rows
+        dest[0] = mat[0];
+        dest[1] = mat[1];
+        dest[2] = mat[2];
+        dest[3] = mat[3];
+
+        dest[12] = mat[12];
+        dest[13] = mat[13];
+        dest[14] = mat[14];