math.js

(function () {

    /*
     * Optimizations made based on glMatrix by Brandon Jones
     */

    /*
     * Copyright (c) 2010 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.
     */


    // Some temporary vars to help avoid garbage collection

    var tempMat1 = new Float32Array(16);
    var tempMat2 = new Float32Array(16);
    var tempVec3 = new Float32Array(3);
    var tempVec3b = new Float32Array(3);
    var tempVec3c = new Float32Array(3);
    var tempVec3d = new Float32Array(3);
    var tempVec3e = new Float32Array(3);
    var tempVec3f = new Float32Array(3);
    var tempVec3g = new Float32Array(3);
    var tempVec3h = new Float32Array(3);
    var tempVec4 = new Float32Array(4);

    /**
     * Returns a new, uninitialized two-element vector.
     * @method vec2
     * @static
     * @returns {Float32Array}
     */
    window.SceneJS_math_vec2 = function () {
        return new Float32Array(2);
    };

    /**
     * Returns a new, uninitialized three-element vector.
     * @method vec3
     * @static
     * @returns {Float32Array}
     */
    window.SceneJS_math_vec3 = function () {
        return new Float32Array(3);
    };

    /**
     * Returns a new, uninitialized four-element vector.
     * @method vec4
     * @static
     * @returns {Float32Array}
     */
    window.SceneJS_math_vec4 = function () {
        return new Float32Array(4);
    };

    /**
     * Returns a new, uninitialized 3x3 matrix.
     * @method mat3
     * @static
     * @returns {Float32Array}
     */
    window.SceneJS_math_mat3 = function () {
        return new Float32Array(9);
    };

    /**
     * Returns a new, uninitialized 4x4 matrix.
     * @method mat4
     * @static
     * @returns {Float32Array}
     */
    window.SceneJS_math_mat4 = function () {
        return new Float32Array(16);
    };

    /**
     * @param u vec3
     * @param v vec3
     * @param dest vec3 - optional destination
     * @return {vec3} dest if specified, u otherwise
     * @private
     */
    window.SceneJS_math_divVec3 = function (u, v, dest) {
        if (!dest) {
            dest = u;
        }

        dest[0] = u[0] / v[0];
        dest[1] = u[1] / v[1];
        dest[2] = u[2] / v[2];

        return dest;
    };

    /**
     * @param v vec4
     * @param dest vec4 - optional destination
     * @return {vec4} dest if specified, v otherwise
     * @private
     */
    window.SceneJS_math_negateVector4 = function (v, dest) {
        if (!dest) {
            dest = v;
        }
        dest[0] = -v[0];
        dest[1] = -v[1];
        dest[2] = -v[2];
        dest[3] = -v[3];

        return dest;
    };

    /**
     * @param u vec4
     * @param v vec4
     * @param dest vec4 - optional destination
     * @return {vec4} dest if specified, u otherwise
     * @private
     */
    window.SceneJS_math_addVec4 = function (u, v, dest) {
        if (!dest) {
            dest = u;
        }

        dest[0] = u[0] + v[0];
        dest[1] = u[1] + v[1];
        dest[2] = u[2] + v[2];
        dest[3] = u[3] + v[3];

        return dest;
    };


    /**
     * @param v vec4
     * @param s scalar
     * @param dest vec4 - optional destination
     * @return {vec4} dest if specified, v otherwise
     * @private
     */
    window.SceneJS_math_addVec4s = function (v, s, dest) {
        if (!dest) {
            dest = v;
        }

        dest[0] = v[0] + s;
        dest[1] = v[1] + s;
        dest[2] = v[2] + s;
        dest[3] = v[3] + s;

        return dest;
    };

    /**
     * @param u vec3
     * @param v vec3
     * @param dest vec3 - optional destination
     * @return {vec3} dest if specified, u otherwise
     * @private
     */
    window.SceneJS_math_addVec3 = function (u, v, dest) {
        if (!dest) {
            dest = u;
        }

        dest[0] = u[0] + v[0];
        dest[1] = u[1] + v[1];
        dest[2] = u[2] + v[2];

        return dest;
    };

    /**
     * @param v vec3
     * @param s scalar
     * @param dest vec3 - optional destination
     * @return {vec3} dest if specified, v otherwise
     * @private
     */
    window.SceneJS_math_addVec3s = function (v, s, dest) {
        if (!dest) {
            dest = v;
        }

        dest[0] = v[0] + s;
        dest[1] = v[1] + s;
        dest[2] = v[2] + s;

        return dest;
    };

    /** @private */
    window.SceneJS_math_addScalarVec4 = function (s, v, dest) {
        return SceneJS_math_addVec4s(v, s, dest);
    };

    /**
     * @param u vec4
     * @param v vec4
     * @param dest vec4 - optional destination
     * @return {vec4} dest if specified, u otherwise
     * @private
     */
    window.SceneJS_math_subVec4 = function (u, v, dest) {
        if (!dest) {
            dest = u;
        }

        dest[0] = u[0] - v[0];
        dest[1] = u[1] - v[1];
        dest[2] = u[2] - v[2];
        dest[3] = u[3] - v[3];

        return dest;
    };

    /**
     * @param u vec3
     * @param v vec3
     * @param dest vec3 - optional destination
     * @return {vec3} dest if specified, v otherwise
     * @private
     */
    window.SceneJS_math_subVec3 = function (u, v, dest) {
        if (!dest) {
            dest = u;
        }

        dest[0] = u[0] - v[0];
        dest[1] = u[1] - v[1];
        dest[2] = u[2] - v[2];

        return dest;
    };

    window.SceneJS_math_lerpVec3 = function (t, t1, t2, p1, p2, dest) {
        dest = dest || SceneJS_math_vec3();
        var f2 = (t - t1) / (t2 - t1);
        var f1 = 1.0 - f2;
        dest[0] = p1[0] * f1 + p2[0] * f2;
        dest[1] = p1[1] * f1 + p2[1] * f2;
        dest[2] = p1[2] * f1 + p2[2] * f2;
        return dest;
    };

    /**
     * @param u vec2
     * @param v vec2
     * @param dest vec2 - optional destination
     * @return {vec2} dest if specified, u otherwise
     * @private
     */
    window.SceneJS_math_subVec2 = function (u, v, dest) {
        if (!dest) {
            dest = u;
        }

        dest[0] = u[0] - v[0];
        dest[1] = u[1] - v[1];

        return dest;
    };

    /**
     * @param u vec2
     * @param v vec2
     * @param dest vec2 - optional destination
     * @return {vec2} dest if specified, u otherwise
     * @private
     */
    window.SceneJS_math_addVec2 = function (u, v, dest) {
        if (!dest) {
            dest = u;
        }

        dest[0] = u[0] + v[0];
        dest[1] = u[1] + v[1];

        return dest;
    };

    /**
     * @param v vec4
     * @param s scalar
     * @param dest vec4 - optional destination
     * @return {vec4} dest if specified, v otherwise
     * @private
     */
    window.SceneJS_math_subVec4Scalar = function (v, s, dest) {
        if (!dest) {
            dest = v;
        }

        dest[0] = v[0] - s;
        dest[1] = v[1] - s;
        dest[2] = v[2] - s;
        dest[3] = v[3] - s;

        return dest;
    };

    /**
     * @param v vec4
     * @param s scalar
     * @param dest vec4 - optional destination
     * @return {vec4} dest if specified, v otherwise
     * @private
     */
    window.SceneJS_math_subScalarVec4 = function (v, s, dest) {
        if (!dest) {
            dest = v;
        }

        dest[0] = s - v[0];
        dest[1] = s - v[1];
        dest[2] = s - v[2];
        dest[3] = s - v[3];

        return dest;
    };

    /**
     * @param u vec4
     * @param v vec4
     * @param dest vec4 - optional destination
     * @return {vec4} dest if specified, u otherwise
     * @private
     */
    window.SceneJS_math_mulVec4 = function (u, v, dest) {
        if (!dest) {
            dest = u;
        }

        dest[0] = u[0] * v[0];
        dest[1] = u[1] * v[1];
        dest[2] = u[2] * v[2];
        dest[3] = u[3] * v[3];

        return dest;
    };

    /**
     * @param v vec4
     * @param s scalar
     * @param dest vec4 - optional destination
     * @return {vec4} dest if specified, v otherwise
     * @private
     */
    window.SceneJS_math_mulVec4Scalar = function (v, s, dest) {
        if (!dest) {
            dest = v;
        }

        dest[0] = v[0] * s;
        dest[1] = v[1] * s;
        dest[2] = v[2] * s;
        dest[3] = v[3] * s;

        return dest;
    };


    /**
     * @param v vec3
     * @param s scalar
     * @param dest vec3 - optional destination
     * @return {vec3} dest if specified, v otherwise
     * @private
     */
    window.SceneJS_math_mulVec3Scalar = function (v, s, dest) {
        if (!dest) {
            dest = v;
        }

        dest[0] = v[0] * s;
        dest[1] = v[1] * s;
        dest[2] = v[2] * s;

        return dest;
    };

    /**
     * @param v vec2
     * @param s scalar
     * @param dest vec2 - optional destination
     * @return {vec2} dest if specified, v otherwise
     * @private
     */
    window.SceneJS_math_mulVec2Scalar = function (v, s, dest) {
        if (!dest) {
            dest = v;
        }

        dest[0] = v[0] * s;
        dest[1] = v[1] * s;

        return dest;
    };


    /**
     * @param u vec4
     * @param v vec4
     * @param dest vec4 - optional destination
     * @return {vec4} dest if specified, u otherwise
     * @private
     */
    window.SceneJS_math_divVec4 = function (u, v, dest) {
        if (!dest) {
            dest = u;
        }

        dest[0] = u[0] / v[0];
        dest[1] = u[1] / v[1];
        dest[2] = u[2] / v[2];
        dest[3] = u[3] / v[3];

        return dest;
    };

    /**
     * @param v vec3
     * @param s scalar
     * @param dest vec3 - optional destination
     * @return {vec3} dest if specified, v otherwise
     * @private
     */
    window.SceneJS_math_divScalarVec3 = function (s, v, dest) {
        if (!dest) {
            dest = v;
        }

        dest[0] = s / v[0];
        dest[1] = s / v[1];
        dest[2] = s / v[2];

        return dest;
    };

    /**
     * @param v vec3
     * @param s scalar
     * @param dest vec3 - optional destination
     * @return {vec3} dest if specified, v otherwise
     * @private
     */
    window.SceneJS_math_divVec3s = function (v, s, dest) {
        if (!dest) {
            dest = v;
        }

        dest[0] = v[0] / s;
        dest[1] = v[1] / s;
        dest[2] = v[2] / s;

        return dest;
    };

    /**
     * @param v vec4
     * @param s scalar
     * @param dest vec4 - optional destination
     * @return {vec4} dest if specified, v otherwise
     * @private
     */
    window.SceneJS_math_divVec4s = function (v, s, dest) {
        if (!dest) {
            dest = v;
        }

        dest[0] = v[0] / s;
        dest[1] = v[1] / s;
        dest[2] = v[2] / s;
        dest[3] = v[3] / s;

        return dest;
    };


    /**
     * @param s scalar
     * @param v vec4
     * @param dest vec4 - optional destination
     * @return {vec4} dest if specified, v otherwise
     * @private
     */
    window.SceneJS_math_divScalarVec4 = function (s, v, dest) {
        if (!dest) {
            dest = v;
        }

        dest[0] = s / v[0];
        dest[1] = s / v[1];
        dest[2] = s / v[2];
        dest[3] = s / v[3];

        return dest;
    };


    /** @private */
    window.SceneJS_math_dotVector4 = function (u, v) {
        return (u[0] * v[0] + u[1] * v[1] + u[2] * v[2] + u[3] * v[3]);
    };

    /** @private */
    window.SceneJS_math_cross3Vec4 = function (u, v) {
        var u0 = u[0], u1 = u[1], u2 = u[2];
        var v0 = v[0], v1 = v[1], v2 = v[2];
        return [
            u1 * v2 - u2 * v1,
            u2 * v0 - u0 * v2,
            u0 * v1 - u1 * v0,
            0.0];
    };

    /**
     * @param u vec3
     * @param v vec3
     * @param dest vec3 - optional destination
     * @return {vec3} dest if specified, u otherwise
     * @private
     */
    window.SceneJS_math_cross3Vec3 = function (u, v, dest) {
        if (!dest) {
            dest = u;
        }

        var x = u[0], y = u[1], z = u[2];
        var x2 = v[0], y2 = v[1], z2 = v[2];

        dest[0] = y * z2 - z * y2;
        dest[1] = z * x2 - x * z2;
        dest[2] = x * y2 - y * x2;

        return dest;
    };

    /**
     * Returns the dot product of two three-element vectors.
     * @method dotVec4
     * @static
     * @param {Array(Number)} u First vector
     * @param {Array(Number)} v Second vector
     * @return The dot product
     */
    window.SceneJS_math_dotVec3 = function (u, v) {
        return (u[0] * v[0] + u[1] * v[1] + u[2] * v[2]);
    };

    /** @private */
    window.SceneJS_math_sqLenVec4 = function (v) {
        return SceneJS_math_dotVector4(v, v);
    };

    /** @private */
    window.SceneJS_math_lenVec4 = function (v) {
        return Math.sqrt(SceneJS_math_sqLenVec4(v));
    };

    /** @private */
    window.SceneJS_math_dotVector3 = function (u, v) {
        return (u[0] * v[0] + u[1] * v[1] + u[2] * v[2]);
    };

    /** @private */
    window.SceneJS_math_dotVector2 = function (u, v) {
        return (u[0] * v[0] + u[1] * v[1]);
    };

    /** @private */
    window.SceneJS_math_sqLenVec3 = function (v) {
        return SceneJS_math_dotVector3(v, v);
    };

    /** @private */
    window.SceneJS_math_sqLenVec2 = function (v) {
        return SceneJS_math_dotVector2(v, v);
    };

    /** @private */
    window.SceneJS_math_lenVec3 = function (v) {
        return Math.sqrt(SceneJS_math_sqLenVec3(v));
    };

    /** @private */
    window.SceneJS_math_lenVec2 = function (v) {
        return Math.sqrt(SceneJS_math_sqLenVec2(v));
    };

    /**
     * @param v vec3
     * @param dest vec3 - optional destination
     * @return {vec3} dest if specified, v otherwise
     * @private
     */
    window.SceneJS_math_rcpVec3 = function (v, dest) {
        return SceneJS_math_divScalarVec3(1.0, v, dest);
    };

    /**
     * @param v vec4
     * @param dest vec4 - optional destination
     * @return {vec4} dest if specified, v otherwise
     * @private
     */
    window.SceneJS_math_normalizeVec4 = function (v, dest) {
        var f = 1.0 / SceneJS_math_lenVec4(v);
        return SceneJS_math_mulVec4Scalar(v, f, dest);
    };

    /** @private */
    window.SceneJS_math_normalizeVec3 = function (v, dest) {
        var f = 1.0 / SceneJS_math_lenVec3(v);
        return SceneJS_math_mulVec3Scalar(v, f, dest);
    };

    // @private
    window.SceneJS_math_normalizeVec2 = function (v, dest) {
        var f = 1.0 / SceneJS_math_lenVec2(v);
        return SceneJS_math_mulVec2Scalar(v, f, dest);
    };

    /** @private */
    window.SceneJS_math_getCellMat4 = function (m, row, col) {
        return m[row + col * 4];
    };

    /** @private */
    window.SceneJS_math_setCellMat4 = function (m, row, col, s) {
        m[row + col * 4] = s;
    };

    /** @private */
    window.SceneJS_math_getRowMat4 = function (m, r) {
        return [m[r], m[r + 4], m[r + 8], m[r + 12]];
    };

    /** @private */
    window.SceneJS_math_setRowMat4 = function (m, r, v) {
        m[r] = v[0];
        m[r + 4] = v[1];
        m[r + 8] = v[2];
        m[r + 12] = v[3];
    };

    /** @private */
    window.SceneJS_math_setRowMat4c = function (m, r, x, y, z, w) {
        SceneJS_math_setRowMat4(m, r, [x, y, z, w]);
    };

    /** @private */
    window.SceneJS_math_setRowMat4s = function (m, r, s) {
        SceneJS_math_setRowMat4c(m, r, s, s, s, s);
    };

    /** @private */
    window.SceneJS_math_getColMat4 = function (m, c) {
        var i = c * 4;
        return [m[i], m[i + 1], m[i + 2], m[i + 3]];
    };

    /** @private */
    window.SceneJS_math_setColMat4v = function (m, c, v) {
        var i = c * 4;
        m[i] = v[0];
        m[i + 1] = v[1];
        m[i + 2] = v[2];
        m[i + 3] = v[3];
    };

    /** @private */
    window.SceneJS_math_setColMat4c = function (m, c, x, y, z, w) {
        SceneJS_math_setColMat4v(m, c, [x, y, z, w]);
    };

    /** @private */
    window.SceneJS_math_setColMat4Scalar = function (m, c, s) {
        SceneJS_math_setColMat4c(m, c, s, s, s, s);
    };

    /** @private */
    window.SceneJS_math_mat4To3 = function (m) {
        return [
            m[0], m[1], m[2],
            m[4], m[5], m[6],
            m[8], m[9], m[10]
        ];
    };

    /** @private */
    window.SceneJS_math_m4s = function (s) {
        return [
            s, s, s, s,
            s, s, s, s,
            s, s, s, s,
            s, s, s, s
        ];
    };

    /** @private */
    window.SceneJS_math_setMat4ToZeroes = function () {
        return SceneJS_math_m4s(0.0);
    };

    /** @private */
    window.SceneJS_math_setMat4ToOnes = function () {
        return SceneJS_math_m4s(1.0);
    };

    /** @private */
    window.SceneJS_math_diagonalMat4v = function (v) {
        return [
            v[0], 0.0, 0.0, 0.0,
            0.0, v[1], 0.0, 0.0,
            0.0, 0.0, v[2], 0.0,
            0.0, 0.0, 0.0, v[3]
        ];
    };

    /** @private */
    window.SceneJS_math_diagonalMat4c = function (x, y, z, w) {
        return SceneJS_math_diagonalMat4v([x, y, z, w]);
    };

    /** @private */
    window.SceneJS_math_diagonalMat4s = function (s) {
        return SceneJS_math_diagonalMat4c(s, s, s, s);
    };

    /** @private */
    window.SceneJS_math_identityMat4 = function () {
        return SceneJS_math_diagonalMat4v([1.0, 1.0, 1.0, 1.0]);
    };

    /** @private */
    window.SceneJS_math_isIdentityMat4 = function (m) {
        if (m[0] !== 1.0 || m[1] !== 0.0 || m[2] !== 0.0 || m[3] !== 0.0 ||
            m[4] !== 0.0 || m[5] !== 1.0 || m[6] !== 0.0 || m[7] !== 0.0 ||
            m[8] !== 0.0 || m[9] !== 0.0 || m[10] !== 1.0 || m[11] !== 0.0 ||
            m[12] !== 0.0 || m[13] !== 0.0 || m[14] !== 0.0 || m[15] !== 1.0) {
            return false;
        }

        return true;
    };

    /**
     * @param m mat4
     * @param dest mat4 - optional destination
     * @return {mat4} dest if specified, m otherwise
     * @private
     */
    window.SceneJS_math_negateMat4 = function (m, dest) {
        if (!dest) {
            dest = m;
        }

        dest[0] = -m[0];
        dest[1] = -m[1];
        dest[2] = -m[2];
        dest[3] = -m[3];
        dest[4] = -m[4];
        dest[5] = -m[5];
        dest[6] = -m[6];
        dest[7] = -m[7];
        dest[8] = -m[8];
        dest[9] = -m[9];
        dest[10] = -m[10];
        dest[11] = -m[11];
        dest[12] = -m[12];
        dest[13] = -m[13];
        dest[14] = -m[14];
        dest[15] = -m[15];

        return dest;
    };

    /**
     * @param a mat4
     * @param b mat4
     * @param dest mat4 - optional destination
     * @return {mat4} dest if specified, a otherwise
     * @private
     */
    window.SceneJS_math_addMat4 = function (a, b, dest) {
        if (!dest) {
            dest = a;
        }

        dest[0] = a[0] + b[0];
        dest[1] = a[1] + b[1];
        dest[2] = a[2] + b[2];
        dest[3] = a[3] + b[3];
        dest[4] = a[4] + b[4];
        dest[5] = a[5] + b[5];
        dest[6] = a[6] + b[6];
        dest[7] = a[7] + b[7];
        dest[8] = a[8] + b[8];
        dest[9] = a[9] + b[9];
        dest[10] = a[10] + b[10];
        dest[11] = a[11] + b[11];
        dest[12] = a[12] + b[12];
        dest[13] = a[13] + b[13];
        dest[14] = a[14] + b[14];
        dest[15] = a[15] + b[15];

        return dest;
    };

    /**
     * @param m mat4
     * @param s scalar
     * @param dest mat4 - optional destination
     * @return {mat4} dest if specified, m otherwise
     * @private
     */
    window.SceneJS_math_addMat4Scalar = function (m, s, dest) {
        if (!dest) {
            dest = m;
        }

        dest[0] = m[0] + s;
        dest[1] = m[1] + s;
        dest[2] = m[2] + s;
        dest[3] = m[3] + s;
        dest[4] = m[4] + s;
        dest[5] = m[5] + s;
        dest[6] = m[6] + s;
        dest[7] = m[7] + s;
        dest[8] = m[8] + s;
        dest[9] = m[9] + s;
        dest[10] = m[10] + s;
        dest[11] = m[11] + s;
        dest[12] = m[12] + s;
        dest[13] = m[13] + s;
        dest[14] = m[14] + s;
        dest[15] = m[15] + s;

        return dest;
    };

    /** @private */
    window.SceneJS_math_addScalarMat4 = function (s, m, dest) {
        return SceneJS_math_addMat4Scalar(m, s, dest);
    };

    /**
     * @param a mat4
     * @param b mat4
     * @param dest mat4 - optional destination
     * @return {mat4} dest if specified, a otherwise
     * @private
     */
    window.SceneJS_math_subMat4 = function (a, b, dest) {
        if (!dest) {
            dest = a;
        }

        dest[0] = a[0] - b[0];
        dest[1] = a[1] - b[1];
        dest[2] = a[2] - b[2];
        dest[3] = a[3] - b[3];
        dest[4] = a[4] - b[4];
        dest[5] = a[5] - b[5];
        dest[6] = a[6] - b[6];
        dest[7] = a[7] - b[7];
        dest[8] = a[8] - b[8];
        dest[9] = a[9] - b[9];
        dest[10] = a[10] - b[10];
        dest[11] = a[11] - b[11];
        dest[12] = a[12] - b[12];
        dest[13] = a[13] - b[13];
        dest[14] = a[14] - b[14];
        dest[15] = a[15] - b[15];

        return dest;
    };

    /**
     * @param m mat4
     * @param s scalar
     * @param dest mat4 - optional destination
     * @return {mat4} dest if specified, m otherwise
     * @private
     */
    window.SceneJS_math_subMat4Scalar = function (m, s, dest) {
        if (!dest) {
            dest = m;
        }

        dest[0] = m[0] - s;
        dest[1] = m[1] - s;
        dest[2] = m[2] - s;
        dest[3] = m[3] - s;
        dest[4] = m[4] - s;
        dest[5] = m[5] - s;
        dest[6] = m[6] - s;
        dest[7] = m[7] - s;
        dest[8] = m[8] - s;
        dest[9] = m[9] - s;
        dest[10] = m[10] - s;
        dest[11] = m[11] - s;
        dest[12] = m[12] - s;
        dest[13] = m[13] - s;
        dest[14] = m[14] - s;
        dest[15] = m[15] - s;

        return dest;
    };

    /**
     * @param s scalar
     * @param m mat4
     * @param dest mat4 - optional destination
     * @return {mat4} dest if specified, m otherwise
     * @private
     */
    window.SceneJS_math_subScalarMat4 = function (s, m, dest) {
        if (!dest) {
            dest = m;
        }

        dest[0] = s - m[0];
        dest[1] = s - m[1];
        dest[2] = s - m[2];
        dest[3] = s - m[3];
        dest[4] = s - m[4];
        dest[5] = s - m[5];
        dest[6] = s - m[6];
        dest[7] = s - m[7];
        dest[8] = s - m[8];
        dest[9] = s - m[9];
        dest[10] = s - m[10];
        dest[11] = s - m[11];
        dest[12] = s - m[12];
        dest[13] = s - m[13];
        dest[14] = s - m[14];
        dest[15] = s - m[15];

        return dest;
    };

    /**
     * @param a mat4
     * @param b mat4
     * @param dest mat4 - optional destination
     * @return {mat4} dest if specified, a otherwise
     * @private
     */
    window.SceneJS_math_mulMat4 = function (a, b, dest) {
        if (!dest) {
            dest = a;
        }

        // Cache the matrix values (makes for huge speed increases!)
        var a00 = a[0], a01 = a[1], a02 = a[2], a03 = a[3];
        var a10 = a[4], a11 = a[5], a12 = a[6], a13 = a[7];
        var a20 = a[8], a21 = a[9], a22 = a[10], a23 = a[11];
        var a30 = a[12], a31 = a[13], a32 = a[14], a33 = a[15];

        var b00 = b[0], b01 = b[1], b02 = b[2], b03 = b[3];
        var b10 = b[4], b11 = b[5], b12 = b[6], b13 = b[7];
        var b20 = b[8], b21 = b[9], b22 = b[10], b23 = b[11];
        var b30 = b[12], b31 = b[13], b32 = b[14], b33 = b[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;
    };

    /**
     * @param m mat4
     * @param s scalar
     * @param dest mat4 - optional destination
     * @return {mat4} dest if specified, m otherwise
     * @private
     */
    window.SceneJS_math_mulMat4s = function (m, s, dest) {
        if (!dest) {
            dest = m;
        }

        dest[0] = m[0] * s;
        dest[1] = m[1] * s;
        dest[2] = m[2] * s;
        dest[3] = m[3] * s;
        dest[4] = m[4] * s;
        dest[5] = m[5] * s;
        dest[6] = m[6] * s;
        dest[7] = m[7] * s;
        dest[8] = m[8] * s;
        dest[9] = m[9] * s;
        dest[10] = m[10] * s;
        dest[11] = m[11] * s;
        dest[12] = m[12] * s;
        dest[13] = m[13] * s;
        dest[14] = m[14] * s;
        dest[15] = m[15] * s;

        return dest;
    };

    /**
     * @param m mat4
     * @param v vec4
     * @return {vec4}
     * @private
     */
    window.SceneJS_math_mulMat4v4 = function (m, v) {
        var v0 = v[0], v1 = v[1], v2 = v[2], v3 = v[3];

        return [
            m[0] * v0 + m[4] * v1 + m[8] * v2 + m[12] * v3,
            m[1] * v0 + m[5] * v1 + m[9] * v2 + m[13] * v3,
            m[2] * v0 + m[6] * v1 + m[10] * v2 + m[14] * v3,
            m[3] * v0 + m[7] * v1 + m[11] * v2 + m[15] * v3
        ];
    };

    /**
     * @param mat mat4
     * @param dest mat4 - optional destination
     * @return {mat4} dest if specified, mat otherwise
     * @private
     */
    window.SceneJS_math_transposeMat4 = function (mat, dest) {
        // If we are transposing ourselves we can skip a few steps but have to cache some values
        var m4 = mat[4], m14 = mat[14], m8 = mat[8];
        var m13 = mat[13], m12 = mat[12], m9 = mat[9];
        if (!dest || mat == dest) {
            var a01 = mat[1], a02 = mat[2], a03 = mat[3];
            var a12 = mat[6], a13 = mat[7];
            var a23 = mat[11];

            mat[1] = m4;
            mat[2] = m8;
            mat[3] = m12;
            mat[4] = a01;
            mat[6] = m9;
            mat[7] = m13;
            mat[8] = a02;
            mat[9] = a12;
            mat[11] = m14;
            mat[12] = a03;
            mat[13] = a13;
            mat[14] = a23;
            return mat;
        }

        dest[0] = mat[0];
        dest[1] = m4;
        dest[2] = m8;
        dest[3] = m12;
        dest[4] = mat[1];
        dest[5] = mat[5];
        dest[6] = m9;
        dest[7] = m13;
        dest[8] = mat[2];
        dest[9] = mat[6];
        dest[10] = mat[10];
        dest[11] = m14;
        dest[12] = mat[3];
        dest[13] = mat[7];
        dest[14] = mat[11];
        dest[15] = mat[15];
        return dest;
    };

    /** @private */
    window.SceneJS_math_determinantMat4 = function (mat) {
        // Cache the matrix values (makes for huge speed increases!)
        var a00 = mat[0], a01 = mat[1], a02 = mat[2], a03 = mat[3];
        var a10 = mat[4], a11 = mat[5], a12 = mat[6], a13 = mat[7];
        var a20 = mat[8], a21 = mat[9], a22 = mat[10], a23 = mat[11];
        var 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;
    };

    /**
     * @param mat mat4
     * @param dest mat4 - optional destination
     * @return {mat4} dest if specified, mat otherwise
     * @private
     */
    window.SceneJS_math_inverseMat4 = 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];
        var a10 = mat[4], a11 = mat[5], a12 = mat[6], a13 = mat[7];
        var a20 = mat[8], a21 = mat[9], a22 = mat[10], a23 = mat[11];
        var a30 = mat[12], a31 = mat[13], a32 = mat[14], a33 = mat[15];

        var b00 = a00 * a11 - a01 * a10;
        var b01 = a00 * a12 - a02 * a10;
        var b02 = a00 * a13 - a03 * a10;
        var b03 = a01 * a12 - a02 * a11;
        var b04 = a01 * a13 - a03 * a11;
        var b05 = a02 * a13 - a03 * a12;
        var b06 = a20 * a31 - a21 * a30;
        var b07 = a20 * a32 - a22 * a30;
        var b08 = a20 * a33 - a23 * a30;
        var b09 = a21 * a32 - a22 * a31;
        var b10 = a21 * a33 - a23 * a31;
        var b11 = a22 * a33 - a23 * a32;

        // Calculate the determinant (inlined to avoid double-caching)
        var invDet = 1 / (b00 * b11 - b01 * b10 + b02 * b09 + b03 * b08 - b04 * b07 + b05 * b06);

        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;
    };

    /** @private */
    window.SceneJS_math_traceMat4 = function (m) {
        return (m[0] + m[5] + m[10] + m[15]);
    };

    /** @private */
    window.SceneJS_math_translationMat4v = function (v) {
        var m = SceneJS_math_identityMat4();
        m[12] = v[0];
        m[13] = v[1];
        m[14] = v[2];
        return m;
    };

    /** @private */
    window.SceneJS_math_translationMat4c = function (x, y, z) {
        return SceneJS_math_translationMat4v([x, y, z]);
    };

    /** @private */
    window.SceneJS_math_translationMat4s = function (s) {
        return SceneJS_math_translationMat4c(s, s, s);
    };

    /** @private */
    window.SceneJS_math_rotationMat4v = function (anglerad, axis) {
        var ax = SceneJS_math_normalizeVec4([axis[0], axis[1], axis[2], 0.0]);
        var s = Math.sin(anglerad);
        var c = Math.cos(anglerad);
        var q = 1.0 - c;

        var x = ax[0];
        var y = ax[1];
        var z = ax[2];

        var xy, yz, zx, xs, ys, zs;

        //xx = x * x; used once
        //yy = y * y; used once
        //zz = z * z; used once
        xy = x * y;
        yz = y * z;
        zx = z * x;
        xs = x * s;
        ys = y * s;
        zs = z * s;

        var m = SceneJS_math_mat4();

        m[0] = (q * x * x) + c;
        m[1] = (q * xy) + zs;
        m[2] = (q * zx) - ys;
        m[3] = 0.0;

        m[4] = (q * xy) - zs;
        m[5] = (q * y * y) + c;
        m[6] = (q * yz) + xs;
        m[7] = 0.0;

        m[8] = (q * zx) + ys;
        m[9] = (q * yz) - xs;
        m[10] = (q * z * z) + c;
        m[11] = 0.0;

        m[12] = 0.0;
        m[13] = 0.0;
        m[14] = 0.0;
        m[15] = 1.0;

        return m;
    };

    /** @private */
    window.SceneJS_math_rotationMat4c = function (anglerad, x, y, z) {
        return SceneJS_math_rotationMat4v(anglerad, [x, y, z]);
    };

    /** @private */
    window.SceneJS_math_scalingMat4v = function (v) {
        var m = SceneJS_math_identityMat4();
        m[0] = v[0];
        m[5] = v[1];
        m[10] = v[2];
        return m;
    };

    /** @private */
    window.SceneJS_math_scalingMat4c = function (x, y, z) {
        return SceneJS_math_scalingMat4v([x, y, z]);
    };

    /** @private */
    window.SceneJS_math_scalingMat4s = function (s) {
        return SceneJS_math_scalingMat4c(s, s, s);
    };

    /**
     * Creates a matrix from a quaternion rotation and vector translation
     *
     * @param {Float32Array} q Rotation quaternion
     * @param {Float32Array} v Translation vector
     * @param {Float32Array} dest Destination matrix
     * @returns {Float32Array} dest
     */
    window.SceneJS_math_rotationTranslationMat4 = function (q, v, dest) {

        dest = dest || SceneJS_math_mat4();

        var x = q[0];
        var y = q[1];
        var z = q[2];
        var w = q[3];

        var x2 = x + x;
        var y2 = y + y;
        var z2 = z + z;
        var xx = x * x2;
        var xy = x * y2;
        var xz = x * z2;
        var yy = y * y2;
        var yz = y * z2;
        var zz = z * z2;
        var wx = w * x2;
        var wy = w * y2;
        var wz = w * z2;

        dest[0] = 1 - (yy + zz);
        dest[1] = xy + wz;
        dest[2] = xz - wy;
        dest[3] = 0;
        dest[4] = xy - wz;
        dest[5] = 1 - (xx + zz);
        dest[6] = yz + wx;
        dest[7] = 0;
        dest[8] = xz + wy;
        dest[9] = yz - wx;
        dest[10] = 1 - (xx + yy);
        dest[11] = 0;
        dest[12] = v[0];
        dest[13] = v[1];
        dest[14] = v[2];
        dest[15] = 1;

        return dest;
    };

    /**
     * Default lookat properties - eye at 0,0,1, looking at 0,0,0, up vector pointing up Y-axis
     */
    window.SceneJS_math_LOOKAT_OBJ = {
        eye: {x: 0, y: 0, z: 10.0},
        look: {x: 0, y: 0, z: 0.0},
        up: {x: 0, y: 1, z: 0.0}
    };

    /**
     * Default lookat properties in array form - eye at 0,0,1, looking at 0,0,0, up vector pointing up Y-axis
     */
    window.SceneJS_math_LOOKAT_ARRAYS = {
        eye: [0, 0, 10.0],
        look: [0, 0, 0.0],
        up: [0, 1, 0.0]
    };

    /**
     * Default orthographic projection properties
     */
    window.SceneJS_math_ORTHO_OBJ = {
        left: -1.0,
        right: 1.0,
        bottom: -1.0,
        near: 0.1,
        top: 1.0,
        far: 5000.0
    };

    /**
     * @param pos vec3 position of the viewer
     * @param target vec3 point the viewer is looking at
     * @param up vec3 pointing "up"
     * @param dest mat4 Optional, mat4 frustum matrix will be written into
     *
     * @return {mat4} dest if specified, a new mat4 otherwise
     */
    window.SceneJS_math_lookAtMat4v = function (pos, target, up, dest) {
        if (!dest) {
            dest = SceneJS_math_mat4();
        }

        var posx = pos[0],
            posy = pos[1],
            posz = pos[2],
            upx = up[0],
            upy = up[1],
            upz = up[2],
            targetx = target[0],
            targety = target[1],
            targetz = target[2];

        if (posx == targetx && posy == targety && posz == targetz) {
            return SceneJS_math_identityMat4();
        }

        var z0, z1, z2, x0, x1, x2, y0, y1, y2, len;

        //vec3.direction(eye, center, z);
        z0 = posx - targetx;
        z1 = posy - targety;
        z2 = posz - targetz;

        // normalize (no check needed for 0 because of early return)
        len = 1 / Math.sqrt(z0 * z0 + z1 * z1 + z2 * z2);
        z0 *= len;
        z1 *= len;
        z2 *= len;

        //vec3.normalize(vec3.cross(up, z, x));
        x0 = upy * z2 - upz * z1;
        x1 = upz * z0 - upx * z2;
        x2 = upx * z1 - upy * z0;
        len = Math.sqrt(x0 * x0 + x1 * x1 + x2 * x2);
        if (!len) {
            x0 = 0;
            x1 = 0;
            x2 = 0;
        } else {
            len = 1 / len;
            x0 *= len;
            x1 *= len;
            x2 *= len;
        }

        //vec3.normalize(vec3.cross(z, x, y));
        y0 = z1 * x2 - z2 * x1;
        y1 = z2 * x0 - z0 * x2;
        y2 = z0 * x1 - z1 * x0;

        len = Math.sqrt(y0 * y0 + y1 * y1 + y2 * y2);
        if (!len) {
            y0 = 0;
            y1 = 0;
            y2 = 0;
        } else {
            len = 1 / len;
            y0 *= len;
            y1 *= len;
            y2 *= len;
        }

        dest[0] = x0;
        dest[1] = y0;
        dest[2] = z0;
        dest[3] = 0;
        dest[4] = x1;
        dest[5] = y1;
        dest[6] = z1;
        dest[7] = 0;
        dest[8] = x2;
        dest[9] = y2;
        dest[10] = z2;
        dest[11] = 0;
        dest[12] = -(x0 * posx + x1 * posy + x2 * posz);
        dest[13] = -(y0 * posx + y1 * posy + y2 * posz);
        dest[14] = -(z0 * posx + z1 * posy + z2 * posz);
        dest[15] = 1;

        return dest;
    };

    /** @private */
    window.SceneJS_math_lookAtMat4c = function (posx, posy, posz, targetx, targety, targetz, upx, upy, upz) {
        return SceneJS_math_lookAtMat4v([posx, posy, posz], [targetx, targety, targetz], [upx, upy, upz]);
    };

    /** @private */
    window.SceneJS_math_orthoMat4c = function (left, right, bottom, top, near, far, dest) {
        if (!dest) {
            dest = SceneJS_math_mat4();
        }
        var rl = (right - left);
        var tb = (top - bottom);
        var fn = (far - near);

        dest[0] = 2.0 / rl;
        dest[1] = 0.0;
        dest[2] = 0.0;
        dest[3] = 0.0;

        dest[4] = 0.0;
        dest[5] = 2.0 / tb;
        dest[6] = 0.0;
        dest[7] = 0.0;

        dest[8] = 0.0;
        dest[9] = 0.0;
        dest[10] = -2.0 / fn;
        dest[11] = 0.0;

        dest[12] = -(left + right) / rl;
        dest[13] = -(top + bottom) / tb;
        dest[14] = -(far + near) / fn;
        dest[15] = 1.0;

        return dest;
    };

    /** @private */
    window.SceneJS_math_frustumMat4v = function (fmin, fmax) {
        var fmin4 = [fmin[0], fmin[1], fmin[2], 0.0];
        var fmax4 = [fmax[0], fmax[1], fmax[2], 0.0];
        var vsum = SceneJS_math_mat4();
        SceneJS_math_addVec4(fmax4, fmin4, vsum);
        var vdif = SceneJS_math_mat4();
        SceneJS_math_subVec4(fmax4, fmin4, vdif);
        var t = 2.0 * fmin4[2];

        var m = SceneJS_math_mat4();
        var vdif0 = vdif[0], vdif1 = vdif[1], vdif2 = vdif[2];

        m[0] = t / vdif0;
        m[1] = 0.0;
        m[2] = 0.0;
        m[3] = 0.0;

        m[4] = 0.0;
        m[5] = t / vdif1;
        m[6] = 0.0;
        m[7] = 0.0;

        m[8] = vsum[0] / vdif0;
        m[9] = vsum[1] / vdif1;
        m[10] = -vsum[2] / vdif2;
        m[11] = -1.0;

        m[12] = 0.0;
        m[13] = 0.0;
        m[14] = -t * fmax4[2] / vdif2;
        m[15] = 0.0;

        return m;
    };

    /**
     * Creates projection matrix from frustum boundary.
     * @private
     */
    window.SceneJS_math_frustumMatrix4 = function (left, right, bottom, top, near, far, dest) {
        if (!dest) {
            dest = SceneJS_math_mat4();
        }
        var rl = (right - left);
        var tb = (top - bottom);
        var fn = (far - near);
        dest[0] = (near * 2) / rl;
        dest[1] = 0;
        dest[2] = 0;
        dest[3] = 0;
        dest[4] = 0;
        dest[5] = (near * 2) / tb;
        dest[6] = 0;
        dest[7] = 0;
        dest[8] = (right + left) / rl;
        dest[9] = (top + bottom) / tb;
        dest[10] = -(far + near) / fn;
        dest[11] = -1;
        dest[12] = 0;
        dest[13] = 0;
        dest[14] = -(far * near * 2) / fn;
        dest[15] = 0;
        return dest;
    };

    /**
     * Creates projection matrix from frustum angles.
     * @private
     **/
    window.SceneJS_math_frustumMatrix4FromAngles = function( left, right, down, up,  near, far, dest) {
        if (!dest) {
            dest = SceneJS_math_mat4();
        }
        var o = Math.tan(up);
        var u = Math.tan(down);
        var l = Math.tan(left);
        var e = Math.tan(right);
        var M = 2 / (l + e), s = 2 / (o + u);
        dest[0] = M;
        dest[1] = 0;
        dest[2] = 0;
        dest[3] = 0;
        dest[4] = 0;
        dest[5] = s;
        dest[6] = 0;
        dest[7] = 0;
        dest[8] = -((l - e) * M * .5);
        dest[9] = (o - u) * s * .5;
        dest[10] = far / (near - far);
        dest[11] = -1;
        dest[12] = 0;
        dest[13] = 0;
        dest[14] = far * near / (near - far);
        dest[15] = 0;
        return dest;
    };


    /** @private */
    window.SceneJS_math_perspectiveMatrix4 = function (fovyrad, aspectratio, znear, zfar) {
        var pmin = [];
        var pmax = [];

        pmin[2] = znear;
        pmax[2] = zfar;

        pmax[1] = pmin[2] * Math.tan(fovyrad / 2.0);
        pmin[1] = -pmax[1];

        pmax[0] = pmax[1] * aspectratio;
        pmin[0] = -pmax[0];

        return SceneJS_math_frustumMat4v(pmin, pmax);
    };

    /** @private */
    window.SceneJS_math_transformPoint3 = function (m, p) {
        var p0 = p[0], p1 = p[1], p2 = p[2];
        return [
            (m[0] * p0) + (m[4] * p1) + (m[8] * p2) + m[12],
            (m[1] * p0) + (m[5] * p1) + (m[9] * p2) + m[13],
            (m[2] * p0) + (m[6] * p1) + (m[10] * p2) + m[14],
            (m[3] * p0) + (m[7] * p1) + (m[11] * p2) + m[15]
        ];
    };


    /** @private */
    window.SceneJS_math_transformPoints3 = function (m, points) {
        var result = new Array(points.length);
        var len = points.length;
        var p0, p1, p2;
        var pi;

        // cache values
        var m0 = m[0], m1 = m[1], m2 = m[2], m3 = m[3];
        var m4 = m[4], m5 = m[5], m6 = m[6], m7 = m[7];
        var m8 = m[8], m9 = m[9], m10 = m[10], m11 = m[11];
        var m12 = m[12], m13 = m[13], m14 = m[14], m15 = m[15];

        for (var i = 0; i < len; ++i) {
            // cache values
            pi = points[i];
            p0 = pi[0];
            p1 = pi[1];
            p2 = pi[2];

            result[i] = [
                (m0 * p0) + (m4 * p1) + (m8 * p2) + m12,
                (m1 * p0) + (m5 * p1) + (m9 * p2) + m13,
                (m2 * p0) + (m6 * p1) + (m10 * p2) + m14,
                (m3 * p0) + (m7 * p1) + (m11 * p2) + m15
            ];
        }

        return result;
    };

    /** @private */
    window.SceneJS_math_transformVector3 = function (m, v, dest) {
        var v0 = v[0], v1 = v[1], v2 = v[2];
        dest = dest || SceneJS_math_vec3();
        dest[0] = (m[0] * v0) + (m[4] * v1) + (m[8] * v2);
        dest[1] = (m[1] * v0) + (m[5] * v1) + (m[9] * v2);
        dest[2] = (m[2] * v0) + (m[6] * v1) + (m[10] * v2);
        return dest;
    };

    window.SceneJS_math_transformVector4 = function (m, v, dest) {
        var v0 = v[0], v1 = v[1], v2 = v[2], v3 = v[3];
        dest = dest || SceneJS_math_vec4();
        dest[0] = m[0] * v0 + m[4] * v1 + m[8] * v2 + m[12] * v3;
        dest[1] = m[1] * v0 + m[5] * v1 + m[9] * v2 + m[13] * v3;
        dest[2] = m[2] * v0 + m[6] * v1 + m[10] * v2 + m[14] * v3;
        dest[3] = m[3] * v0 + m[7] * v1 + m[11] * v2 + m[15] * v3;
        return dest;
    };

    /** @private */
    window.SceneJS_math_projectVec4 = function (v) {
        var f = 1.0 / v[3];
        return [v[0] * f, v[1] * f, v[2] * f, 1.0];
    };


    /** @private */
    window.SceneJS_math_Plane3 = function (normal, offset, normalize) {
        this.normal = [0.0, 0.0, 1.0];

        this.offset = 0.0;
        if (normal && offset) {
            var normal0 = normal[0], normal1 = normal[1], normal2 = normal[2];
            this.offset = offset;

            if (normalize) {
                var s = Math.sqrt(
                    normal0 * normal0 +
                    normal1 * normal1 +
                    normal2 * normal2
                );
                if (s > 0.0) {
                    s = 1.0 / s;
                    this.normal[0] = normal0 * s;
                    this.normal[1] = normal1 * s;
                    this.normal[2] = normal2 * s;
                    this.offset *= s;
                }
            }
        }
    };

    /** @private */
    window.SceneJS_math_MAX_DOUBLE = Number.POSITIVE_INFINITY;
    /** @private */
    window.SceneJS_math_MIN_DOUBLE = Number.NEGATIVE_INFINITY;

    /** @private
     *
     */
    window.SceneJS_math_Box3 = function (min, max) {
        this.min = min || [SceneJS_math_MAX_DOUBLE, SceneJS_math_MAX_DOUBLE, SceneJS_math_MAX_DOUBLE];
        this.max = max || [SceneJS_math_MIN_DOUBLE, SceneJS_math_MIN_DOUBLE, SceneJS_math_MIN_DOUBLE];

        /** @private */
        this.init = function (min, max) {
            this.min[0] = min[0];
            this.min[1] = min[1];
            this.min[2] = min[2];
            this.max[0] = max[0];
            this.max[1] = max[1];
            this.max[2] = max[2];
            return this;
        };

        /** @private */
        this.fromPoints = function (points) {
            var pointsLength = points.length;

            for (var i = 0; i < pointsLength; ++i) {
                var points_i3 = points[i][3];
                var pDiv0 = points[i][0] / points_i3;
                var pDiv1 = points[i][1] / points_i3;
                var pDiv2 = points[i][2] / points_i3;

                if (pDiv0 < this.min[0]) {
                    this.min[0] = pDiv0;
                }
                if (pDiv1 < this.min[1]) {
                    this.min[1] = pDiv1;
                }
                if (pDiv2 < this.min[2]) {
                    this.min[2] = pDiv2;
                }

                if (pDiv0 > this.max[0]) {
                    this.max[0] = pDiv0;
                }
                if (pDiv1 > this.max[1]) {
                    this.max[1] = pDiv1;
                }
                if (pDiv2 > this.max[2]) {
                    this.max[2] = pDiv2;
                }
            }
            return this;
        };

        /** @private */
        this.isEmpty = function () {
            return (
                (this.min[0] >= this.max[0]) &&
                (this.min[1] >= this.max[1]) &&
                (this.min[2] >= this.max[2])
            );
        };

        /** @private */
        this.getCenter = function () {
            return [
                (this.max[0] + this.min[0]) / 2.0,
                (this.max[1] + this.min[1]) / 2.0,
                (this.max[2] + this.min[2]) / 2.0
            ];
        };

        /** @private */
        this.getSize = function () {
            return [
                (this.max[0] - this.min[0]),
                (this.max[1] - this.min[1]),
                (this.max[2] - this.min[2])
            ];
        };

        /** @private */
        this.getFacesAreas = function () {
            var s = this.size;
            return [
                (s[1] * s[2]),
                (s[0] * s[2]),
                (s[0] * s[1])
            ];
        };

        /** @private */
        this.getSurfaceArea = function () {
            var a = this.getFacesAreas();
            return ((a[0] + a[1] + a[2]) * 2.0);
        };

        /** @private */
        this.getVolume = function () {
            var s = this.size;
            return (s[0] * s[1] * s[2]);
        };

        /** @private */
        this.getOffset = function (half_delta) {
            this.min[0] -= half_delta;
            this.min[1] -= half_delta;
            this.min[2] -= half_delta;
            this.max[0] += half_delta;
            this.max[1] += half_delta;
            this.max[2] += half_delta;
            return this;
        };
    };

    /** @private
     *
     * @param min
     * @param max
     */
    window.SceneJS_math_AxisBox3 = function (min, max) {
        var min0 = min[0], min1 = min[1], min2 = min[2];
        var max0 = max[0], max1 = max[1], max2 = max[2];

        this.verts = [
            [min0, min1, min2],
            [max0, min1, min2],
            [max0, max1, min2],
            [min0, max1, min2],

            [min0, min1, max2],
            [max0, min1, max2],
            [max0, max1, max2],
            [min0, max1, max2]
        ];

        /** @private */
        this.toBox3 = function () {
            var box = new SceneJS_math_Box3();
            for (var i = 0; i < 8; ++i) {
                var v = this.verts[i];
                for (var j = 0; j < 3; ++j) {
                    if (v[j] < box.min[j]) {
                        box.min[j] = v[j];
                    }
                    if (v[j] > box.max[j]) {
                        box.max[j] = v[j];
                    }
                }
            }
        };
    };

    /** @private
     *
     * @param center
     * @param radius
     */
    window.SceneJS_math_Sphere3 = function (center, radius) {
        this.center = [center[0], center[1], center[2]];
        this.radius = radius;

        /** @private */
        this.isEmpty = function () {
            return (this.radius === 0.0);
        };

        /** @private */
        this.surfaceArea = function () {
            return (4.0 * Math.PI * this.radius * this.radius);
        };

        /** @private */
        this.getVolume = function () {
            var thisRadius = this.radius;
            return ((4.0 / 3.0) * Math.PI * thisRadius * thisRadius * thisRadius);
        };
    };

    /** Creates billboard matrix from given view matrix
     * @private
     */
    window.SceneJS_math_billboardMat = function (viewMatrix) {
        var rotVec = [
            SceneJS_math_getColMat4(viewMatrix, 0),
            SceneJS_math_getColMat4(viewMatrix, 1),
            SceneJS_math_getColMat4(viewMatrix, 2)
        ];

        var scaleVec = [
            SceneJS_math_lenVec4(rotVec[0]),
            SceneJS_math_lenVec4(rotVec[1]),
            SceneJS_math_lenVec4(rotVec[2])
        ];

        var scaleVecRcp = SceneJS_math_mat4();
        SceneJS_math_rcpVec3(scaleVec, scaleVecRcp);
        var sMat = SceneJS_math_scalingMat4v(scaleVec);
        //var sMatInv = SceneJS_math_scalingMat4v(scaleVecRcp);

        SceneJS_math_mulVec4Scalar(rotVec[0], scaleVecRcp[0]);
        SceneJS_math_mulVec4Scalar(rotVec[1], scaleVecRcp[1]);
        SceneJS_math_mulVec4Scalar(rotVec[2], scaleVecRcp[2]);

        var rotMatInverse = SceneJS_math_identityMat4();

        SceneJS_math_setRowMat4(rotMatInverse, 0, rotVec[0]);
        SceneJS_math_setRowMat4(rotMatInverse, 1, rotVec[1]);
        SceneJS_math_setRowMat4(rotMatInverse, 2, rotVec[2]);

        //return rotMatInverse;
        //return SceneJS_math_mulMat4(sMatInv, SceneJS_math_mulMat4(rotMatInverse, sMat));
        return SceneJS_math_mulMat4(rotMatInverse, sMat);
        // return SceneJS_math_mulMat4(sMat, SceneJS_math_mulMat4(rotMatInverse, sMat));
        //return SceneJS_math_mulMat4(sMatInv, SceneJS_math_mulMat4(rotMatInverse, sMat));
    };

    /** @private */
    window.SceneJS_math_FrustumPlane = function (nx, ny, nz, offset) {
        var s = 1.0 / Math.sqrt(nx * nx + ny * ny + nz * nz);
        this.normal = [nx * s, ny * s, nz * s];
        this.offset = offset * s;
        this.testVertex = [
            (this.normal[0] >= 0.0) ? (1) : (0),
            (this.normal[1] >= 0.0) ? (1) : (0),
            (this.normal[2] >= 0.0) ? (1) : (0)];
    };

    /** @private */
    window.SceneJS_math_OUTSIDE_FRUSTUM = 3;
    /** @private */
    window.SceneJS_math_INTERSECT_FRUSTUM = 4;
    /** @private */
    window.SceneJS_math_INSIDE_FRUSTUM = 5;

    /** @private */
    window.SceneJS_math_Frustum = function (viewMatrix, projectionMatrix, viewport) {
        var m = SceneJS_math_mat4();
        SceneJS_math_mulMat4(projectionMatrix, viewMatrix, m);

        // cache m indexes
        var m0 = m[0], m1 = m[1], m2 = m[2], m3 = m[3];
        var m4 = m[4], m5 = m[5], m6 = m[6], m7 = m[7];
        var m8 = m[8], m9 = m[9], m10 = m[10], m11 = m[11];
        var m12 = m[12], m13 = m[13], m14 = m[14], m15 = m[15];

        //var q = [ m[3], m[7], m[11] ]; just reuse m indexes instead of making new var
        var planes = [
            new SceneJS_math_FrustumPlane(m3 - m0, m7 - m4, m11 - m8, m15 - m12),
            new SceneJS_math_FrustumPlane(m3 + m0, m7 + m4, m11 + m8, m15 + m12),
            new SceneJS_math_FrustumPlane(m3 - m1, m7 - m5, m11 - m9, m15 - m13),
            new SceneJS_math_FrustumPlane(m3 + m1, m7 + m5, m11 + m9, m15 + m13),
            new SceneJS_math_FrustumPlane(m3 - m2, m7 - m6, m11 - m10, m15 - m14),
            new SceneJS_math_FrustumPlane(m3 + m2, m7 + m6, m11 + m10, m15 + m14)
        ];

        /* Resources for LOD
         */
        var rotVec = [
            SceneJS_math_getColMat4(viewMatrix, 0),
            SceneJS_math_getColMat4(viewMatrix, 1),
            SceneJS_math_getColMat4(viewMatrix, 2)
        ];

        var scaleVec = [
            SceneJS_math_lenVec4(rotVec[0]),
            SceneJS_math_lenVec4(rotVec[1]),
            SceneJS_math_lenVec4(rotVec[2])
        ];

        var scaleVecRcp = SceneJS_math_rcpVec3(scaleVec);
        var sMat = SceneJS_math_scalingMat4v(scaleVec);
        var sMatInv = SceneJS_math_scalingMat4v(scaleVecRcp);

        SceneJS_math_mulVec4Scalar(rotVec[0], scaleVecRcp[0]);
        SceneJS_math_mulVec4Scalar(rotVec[1], scaleVecRcp[1]);
        SceneJS_math_mulVec4Scalar(rotVec[2], scaleVecRcp[2]);

        var rotMatInverse = SceneJS_math_identityMat4();

        SceneJS_math_setRowMat4(rotMatInverse, 0, rotVec[0]);
        SceneJS_math_setRowMat4(rotMatInverse, 1, rotVec[1]);
        SceneJS_math_setRowMat4(rotMatInverse, 2, rotVec[2]);

        if (!this.matrix) {
            this.matrix = SceneJS_math_mat4();
        }
        SceneJS_math_mulMat4(projectionMatrix, viewMatrix, this.matrix);
        if (!this.billboardMatrix) {
            this.billboardMatrix = SceneJS_math_mat4();
        }
        SceneJS_math_mulMat4(sMatInv, SceneJS_math_mulMat4(rotMatInverse, sMat), this.billboardMatrix);
        this.viewport = viewport.slice(0, 4);

        /** @private */
        this.textAxisBoxIntersection = function (box) {
            var ret = SceneJS_math_INSIDE_FRUSTUM;
            var bminmax = [box.min, box.max];
            var plane = null;

            for (var i = 0; i < 6; ++i) {
                plane = planes[i];
                if (((plane.normal[0] * bminmax[plane.testVertex[0]][0]) +
                    (plane.normal[1] * bminmax[plane.testVertex[1]][1]) +
                    (plane.normal[2] * bminmax[plane.testVertex[2]][2]) +
                    (plane.offset)) < 0.0) {
                    return SceneJS_math_OUTSIDE_FRUSTUM;
                }
                if (((plane.normal[0] * bminmax[1 - plane.testVertex[0]][0]) +
                    (plane.normal[1] * bminmax[1 - plane.testVertex[1]][1]) +
                    (plane.normal[2] * bminmax[1 - plane.testVertex[2]][2]) +
                    (plane.offset)) < 0.0) {
                    ret = SceneJS_math_INTERSECT_FRUSTUM;
                }
            }
            return ret;
        };

        /** @private */
        this.getProjectedSize = function (box) {
            var diagVec = SceneJS_math_mat4();
            SceneJS_math_subVec3(box.max, box.min, diagVec);

            var diagSize = SceneJS_math_lenVec3(diagVec);

            var size = Math.abs(diagSize);

            var p0 = [
                (box.min[0] + box.max[0]) * 0.5,
                (box.min[1] + box.max[1]) * 0.5,
                (box.min[2] + box.max[2]) * 0.5,
                0.0];

            var halfSize = size * 0.5;
            var p1 = [-halfSize, 0.0, 0.0, 1.0];
            var p2 = [halfSize, 0.0, 0.0, 1.0];

            p1 = SceneJS_math_mulMat4v4(this.billboardMatrix, p1);
            p1 = SceneJS_math_addVec4(p1, p0);
            p1 = SceneJS_math_projectVec4(SceneJS_math_mulMat4v4(this.matrix, p1));

            p2 = SceneJS_math_mulMat4v4(this.billboardMatrix, p2);
            p2 = SceneJS_math_addVec4(p2, p0);
            p2 = SceneJS_math_projectVec4(SceneJS_math_mulMat4v4(this.matrix, p2));

            return viewport[2] * Math.abs(p2[0] - p1[0]);
        };


        this.getProjectedState = function (modelCoords) {
            var viewCoords = SceneJS_math_transformPoints3(this.matrix, modelCoords);

            //var canvasBox = {
            //    min: [10000000, 10000000 ],
            //    max: [-10000000, -10000000]
            //};
            // separate variables instead of indexing an array
            var canvasBoxMin0 = 10000000, canvasBoxMin1 = 10000000;
            var canvasBoxMax0 = -10000000, canvasBoxMax1 = -10000000;

            var v, x, y;

            var arrLen = viewCoords.length;
            for (var i = 0; i < arrLen; ++i) {
                v = SceneJS_math_projectVec4(viewCoords[i]);
                x = v[0];
                y = v[1];

                if (x < -0.5) {
                    x = -0.5;
                }

                if (y < -0.5) {
                    y = -0.5;
                }

                if (x > 0.5) {
                    x = 0.5;
                }

                if (y > 0.5) {
                    y = 0.5;
                }


                if (x < canvasBoxMin0) {
                    canvasBoxMin0 = x;
                }
                if (y < canvasBoxMin1) {
                    canvasBoxMin1 = y;
                }

                if (x > canvasBoxMax0) {
                    canvasBoxMax0 = x;
                }
                if (y > canvasBoxMax1) {
                    canvasBoxMax1 = y;
                }
            }

            canvasBoxMin0 += 0.5;
            canvasBoxMin1 += 0.5;
            canvasBoxMax0 += 0.5;
            canvasBoxMax1 += 0.5;

            // cache viewport indexes
            var viewport2 = viewport[2], viewport3 = viewport[3];

            canvasBoxMin0 = (canvasBoxMin0 * (viewport2 + 15));
            canvasBoxMin1 = (canvasBoxMin1 * (viewport3 + 15));
            canvasBoxMax0 = (canvasBoxMax0 * (viewport2 + 15));
            canvasBoxMax1 = (canvasBoxMax1 * (viewport3 + 15));

            var diagCanvasBoxVec = SceneJS_math_mat4();
            SceneJS_math_subVec2([canvasBoxMax0, canvasBoxMax1],
                [canvasBoxMin0, canvasBoxMin1],
                diagCanvasBoxVec);
            var diagCanvasBoxSize = SceneJS_math_lenVec2(diagCanvasBoxVec);

            if (canvasBoxMin0 < 0) {
                canvasBoxMin0 = 0;
            }
            if (canvasBoxMax0 > viewport2) {
                canvasBoxMax0 = viewport2;
            }

            if (canvasBoxMin1 < 0) {
                canvasBoxMin1 = 0;
            }
            if (canvasBoxMax1 > viewport3) {
                canvasBoxMax1 = viewport3;
            }
            return {
                canvasBox: {
                    min: [canvasBoxMin0, canvasBoxMin1],
                    max: [canvasBoxMax0, canvasBoxMax1]
                },
                canvasSize: diagCanvasBoxSize
            };
        };
    };

    window.SceneJS_math_identityQuaternion = function () {
        return [0.0, 0.0, 0.0, 1.0];
    };

    window.SceneJS_math_angleAxisQuaternion = function (x, y, z, degrees) {
        var angleRad = (degrees / 180.0) * Math.PI;
        var halfAngle = angleRad / 2.0;
        var fsin = Math.sin(halfAngle);
        return [
            fsin * x,
            fsin * y,
            fsin * z,
            Math.cos(halfAngle)
        ];
    };

    window.SceneJS_math_mulQuaternions = function (p, q) {
        var p0 = p[0], p1 = p[1], p2 = p[2], p3 = p[3];
        var q0 = q[0], q1 = q[1], q2 = q[2], q3 = q[3];
        return [
            p3 * q0 + p0 * q3 + p1 * q2 - p2 * q1,
            p3 * q1 + p1 * q3 + p2 * q0 - p0 * q2,
            p3 * q2 + p2 * q3 + p0 * q1 - p1 * q0,
            p3 * q3 - p0 * q0 - p1 * q1 - p2 * q2
        ];
    };

    window.SceneJS_math_newMat4FromQuaternion = function (q) {
        var q0 = q[0], q1 = q[1], q2 = q[2], q3 = q[3];
        var tx = 2.0 * q0;
        var ty = 2.0 * q1;
        var tz = 2.0 * q2;
        var twx = tx * q3;
        var twy = ty * q3;
        var twz = tz * q3;
        var txx = tx * q0;
        var txy = ty * q0;
        var txz = tz * q0;
        var tyy = ty * q1;
        var tyz = tz * q1;
        var tzz = tz * q2;
        var m = SceneJS_math_identityMat4();
        SceneJS_math_setCellMat4(m, 0, 0, 1.0 - (tyy + tzz));
        SceneJS_math_setCellMat4(m, 0, 1, txy - twz);
        SceneJS_math_setCellMat4(m, 0, 2, txz + twy);
        SceneJS_math_setCellMat4(m, 1, 0, txy + twz);
        SceneJS_math_setCellMat4(m, 1, 1, 1.0 - (txx + tzz));
        SceneJS_math_setCellMat4(m, 1, 2, tyz - twx);
        SceneJS_math_setCellMat4(m, 2, 0, txz - twy);
        SceneJS_math_setCellMat4(m, 2, 1, tyz + twx);
        SceneJS_math_setCellMat4(m, 2, 2, 1.0 - (txx + tyy));
        return m;
    };

    window.SceneJS_math_slerp = function (t, q1, q2) {
        //var result = SceneJS_math_identityQuaternion();
        var q13 = q1[3] * 0.0174532925;
        var q23 = q2[3] * 0.0174532925;
        var cosHalfAngle = q13 * q23 + q1[0] * q2[0] + q1[1] * q2[1] + q1[2] * q2[2];
        if (Math.abs(cosHalfAngle) >= 1) {
            return [q1[0], q1[1], q1[2], q1[3]];
        } else {
            var halfAngle = Math.acos(cosHalfAngle);
            var sinHalfAngle = Math.sqrt(1 - cosHalfAngle * cosHalfAngle);
            if (Math.abs(sinHalfAngle) < 0.001) {
                return [
                    q1[0] * 0.5 + q2[0] * 0.5,
                    q1[1] * 0.5 + q2[1] * 0.5,
                    q1[2] * 0.5 + q2[2] * 0.5,
                    q1[3] * 0.5 + q2[3] * 0.5
                ];
            } else {
                var a = Math.sin((1 - t) * halfAngle) / sinHalfAngle;
                var b = Math.sin(t * halfAngle) / sinHalfAngle;
                return [
                    q1[0] * a + q2[0] * b,
                    q1[1] * a + q2[1] * b,
                    q1[2] * a + q2[2] * b,
                    (q13 * a + q23 * b) * 57.295779579
                ];
            }
        }
    };

    window.SceneJS_math_normalizeQuaternion = function (q) {
        var len = SceneJS_math_lenVec4([q[0], q[1], q[2], q[3]]);
        return [q[0] / len, q[1] / len, q[2] / len, q[3] / len];
    };

    window.SceneJS_math_conjugateQuaternion = function (q) {
        return [-q[0], -q[1], -q[2], q[3]];
    };

    window.SceneJS_math_angleAxisFromQuaternion = function (q) {
        q = SceneJS_math_normalizeQuaternion(q);
        var q3 = q[3];
        var angle = 2 * Math.acos(q3);
        var s = Math.sqrt(1 - q3 * q3);
        if (s < 0.001) { // test to avoid divide by zero, s is always positive due to sqrt
            return {
                x: q[0],
                y: q[1],
                z: q[2],
                angle: angle * 57.295779579
            };
        } else {
            return {
                x: q[0] / s,
                y: q[1] / s,
                z: q[2] / s,
                angle: angle * 57.295779579
            };
        }
    };

    /**
     * Builds vertex and index arrays needed by color-indexed triangle picking.
     *
     * @method getPickPrimitives
     * @static
     * @param {Array of Number} positions One-dimensional flattened array of positions.
     * @param {Array of Number} indices One-dimensional flattened array of indices.
     * @returns {*} Object containing the arrays, created by this method or reused from 'pickTris' parameter.
     */
    window.SceneJS_math_getPickPrimitives = function (positions, indices) {

        var numIndices = indices.length;

        var pickPositions = new Float32Array(numIndices * 3);
        var pickColors = new Float32Array(numIndices * 4);

        var primIndex = 0;

        // Positions array index
        var vi;

        // Picking positions array index
        var pvi;

        // Picking color array index
        var pci;

        // Triangle indices

        var i;
        var r;
        var g;
        var b;
        var a;

        for (var location = 0; location < numIndices; location += 3) {

            pvi = location * 3;
            pci = location * 4;

            // Primitive-indexed triangle pick color

            a = (primIndex >> 24 & 0xFF) / 255.0;
            b = (primIndex >> 16 & 0xFF) / 255.0;
            g = (primIndex >> 8 & 0xFF) / 255.0;
            r = (primIndex & 0xFF) / 255.0;

            // A

            i = indices[location];
            vi = i * 3;

            pickPositions[pvi]     = positions[vi];
            pickPositions[pvi + 1] = positions[vi + 1];
            pickPositions[pvi + 2] = positions[vi + 2];

            pickColors[pci]     = r;
            pickColors[pci + 1] = g;
            pickColors[pci + 2] = b;
            pickColors[pci + 3] = a;


            // B

            i = indices[location + 1];
            vi = i * 3;

            pickPositions[pvi + 3] = positions[vi];
            pickPositions[pvi + 4] = positions[vi + 1];
            pickPositions[pvi + 5] = positions[vi + 2];

            pickColors[pci + 4] = r;
            pickColors[pci + 5] = g;
            pickColors[pci + 6] = b;
            pickColors[pci + 7] = a;


            // C

            i = indices[location + 2];
            vi = i * 3;

            pickPositions[pvi + 6] = positions[vi];
            pickPositions[pvi + 7] = positions[vi + 1];
            pickPositions[pvi + 8] = positions[vi + 2];

            pickColors[pci + 8]  = r;
            pickColors[pci + 9]  = g;
            pickColors[pci + 10] = b;
            pickColors[pci + 11] = a;

            primIndex++;
        }

        return {
            positions: pickPositions,
            colors: pickColors
        };
    };

    /**
     * Builds vertex array needed by color-indexed triangle picking (for morph target positions).
     *
     * @method getPickPositions
     * @static
     * @param {Array of Number} positions One-dimensional flattened array of positions.
     * @param {Array of Number} indices One-dimensional flattened array of indices.
     * @returns {Array of Number} The pick positions.
     */
    window.SceneJS_math_getPickPositions = function (positions, indices) {

        var numIndices = indices.length;

        var pickPositions = new Float32Array(numIndices * 3);
        var pvi, vi;
        var i;

        for (var location = 0; location < numIndices; location++) {

            // Picking position array index
            pvi = location * 3;

            i = indices[location];

            // Drawing position index
            vi = i * 3;

            pickPositions[pvi]     = positions[vi];
            pickPositions[pvi + 1] = positions[vi + 1];
            pickPositions[pvi + 2] = positions[vi + 2];

        }

        return pickPositions;
    };

    /**
     * Builds color arrays needed by color-indexed triangle picking.
     *
     * @method getPickPrimitives
     * @static
     * @param {Array of Number} indices One-dimensional flattened array of indices.
     * @returns {Array of Number} The pick colors
     */
    window.SceneJS_math_getPickColors = function (indices) {

        var numIndices = indices.length;

        var pickColors = new Float32Array(numIndices * 4);

        var primIndex = 0;
        var pci;

        // Triangle indices

        var r;
        var g;
        var b;
        var a;

        for (var location = 0; location < numIndices; location += 3) {

            // Picking color array index;
            pci = location * 4;

            // Primitive-indexed triangle pick color

            a = (primIndex >> 24 & 0xFF) / 255.0;
            b = (primIndex >> 16 & 0xFF) / 255.0;
            g = (primIndex >> 8 & 0xFF) / 255.0;
            r = (primIndex & 0xFF) / 255.0;

            // A

            pickColors[pci]     = r;
            pickColors[pci + 1] = g;
            pickColors[pci + 2] = b;
            pickColors[pci + 3] = a;

            // B

            pickColors[pci + 4] = r;
            pickColors[pci + 5] = g;
            pickColors[pci + 6] = b;
            pickColors[pci + 7] = a;

            // C

            pickColors[pci + 8]  = r;
            pickColors[pci + 9]  = g;
            pickColors[pci + 10] = b;
            pickColors[pci + 11] = a;

            primIndex++;
        }

        return pickColors;
    };


    /**
     * Finds the intersection of a 3D ray with a 3D triangle.
     *
     * @method rayTriangleIntersect
     * @static
     * @param {Array of Number} origin Ray origin.
     * @param {Array of Number} dir Ray direction.
     * @param {Array of Number} a First triangle vertex.
     * @param {Array of Number} b Second triangle vertex.
     * @param {Array of Number} c Third triangle vertex.
     * @param {Array of Number} [isect] Intersection point.
     * @returns {Array of Number} The intersection point, or null if no intersection found.
     */
    window.SceneJS_math_rayTriangleIntersect = function (origin, dir, a, b, c, isect) {

        isect = isect || SceneJS_math_vec3();

        var EPSILON = 0.000001;

        var edge1 = SceneJS_math_subVec3(b, a, tempVec3);
        var edge2 = SceneJS_math_subVec3(c, a, tempVec3b);

        var pvec = SceneJS_math_cross3Vec3(dir, edge2, tempVec3c);
        var det = SceneJS_math_dotVec3(edge1, pvec);
        if (det < EPSILON) {
            return null;
        }

        var tvec = SceneJS_math_subVec3(origin, a, tempVec3d);
        var u = SceneJS_math_dotVec3(tvec, pvec);
        if (u < 0 || u > det) {
            return null;
        }

        var qvec = SceneJS_math_cross3Vec3(tvec, edge1, tempVec3e);
        var v = SceneJS_math_dotVec3(dir, qvec);
        if (v < 0 || u + v > det) {
            return null;
        }

        var t = SceneJS_math_dotVec3(edge2, qvec) / det;
        isect[0] = origin[0] + t * dir[0];
        isect[1] = origin[1] + t * dir[1];
        isect[2] = origin[2] + t * dir[2];

        return isect;
    };

    /**
     * Finds the intersection of a 3D ray with a plane defined by 3 points.
     *
     * @method rayPlaneIntersect
     * @static
     * @param {Array of Number} origin Ray origin.
     * @param {Array of Number} dir Ray direction.
     * @param {Array of Number} a First point on plane.
     * @param {Array of Number} b Second point on plane.
     * @param {Array of Number} c Third point on plane.
     * @param {Array of Number} [isect] Intersection point.
     * @returns {Array of Number} The intersection point.
     */
    window.SceneJS_math_rayPlaneIntersect = function (origin, dir, a, b, c, isect) {

        isect = isect || SceneJS_math_vec3();
        dir = SceneJS_math_normalizeVec3(dir, tempVec3);

        var edge1 = SceneJS_math_subVec3(b, a, tempVec3b);
        var edge2 = SceneJS_math_subVec3(c, a, tempVec3c);

        var n = SceneJS_math_cross3Vec3(edge1, edge2, tempVec3d);
        SceneJS_math_normalizeVec3(n, n);

        var d = -SceneJS_math_dotVec3(a, n);

        var t = -(SceneJS_math_dotVec3(origin, n) + d) / SceneJS_math_dotVec3(dir, n);
        isect[0] = origin[0] + t * dir[0];
        isect[1] = origin[1] + t * dir[1];
        isect[2] = origin[2] + t * dir[2];

        return isect;
    };


    /**
     * Gets barycentric coordinates from cartesian coordinates within a triangle.
     *
     * @method cartesianToBaryCentric
     * @static
     * @param {Array of Number} cartesian Cartesian coordinates.
     * @param {Array of Number} a First triangle vertex.
     * @param {Array of Number} b Second triangle vertex.
     * @param {Array of Number} c Third triangle vertex.
     * @param {Array of Number} [bary] The barycentric coordinates.
     * @returns {Array of Number} The barycentric coordinates, or null if the triangle was invalid.
     * @returns {*}
     */
    window.SceneJS_math_cartesianToBarycentric = function (cartesian, a, b, c, bary) {

        var f1 = SceneJS_math_subVec3(a, cartesian, tempVec3);
        var f2 = SceneJS_math_subVec3(b, cartesian, tempVec3b);
        var f3 = SceneJS_math_subVec3(c, cartesian, tempVec3c);

        var t1 = SceneJS_math_subVec3(a, b, tempVec3d);
        var t2 = SceneJS_math_subVec3(a, c, tempVec3e);

        var a0 = SceneJS_math_lenVec3(SceneJS_math_cross3Vec3(t1, t2, tempVec3f));

        bary[0] = SceneJS_math_lenVec3(SceneJS_math_cross3Vec3(f2, f3, tempVec3f)) / a0;
        bary[1] = SceneJS_math_lenVec3(SceneJS_math_cross3Vec3(f3, f1, tempVec3f)) / a0;
        bary[2] = SceneJS_math_lenVec3(SceneJS_math_cross3Vec3(f1, f2, tempVec3f)) / a0;

        return bary;
    };

    window.SceneJS_math_cartesianToBarycentric2 = function (cartesian, a, b, c, dest) {

        var v0 = SceneJS_math_subVec3(c, a, tempVec3);
        var v1 = SceneJS_math_subVec3(b, a, tempVec3b);
        var v2 = SceneJS_math_subVec3(cartesian, a, tempVec3c);

        var dot00 = SceneJS_math_dotVector3(v0, v0);
        var dot01 = SceneJS_math_dotVector3(v0, v1);
        var dot02 = SceneJS_math_dotVector3(v0, v2);
        var dot11 = SceneJS_math_dotVector3(v1, v1);
        var dot12 = SceneJS_math_dotVector3(v1, v2);

        var denom = ( dot00 * dot11 - dot01 * dot01 );

        // Colinear or singular triangle

        if (denom === 0) {

            // Arbitrary location outside of triangle

            return null;
        }

        var invDenom = 1 / denom;

        var u = ( dot11 * dot02 - dot01 * dot12 ) * invDenom;
        var v = ( dot00 * dot12 - dot01 * dot02 ) * invDenom;

        dest[0] = 1 - u - v;
        dest[1] = v;
        dest[2] = u;

        return dest;
    };

    /**
     * Returns true if the given barycentric coordinates are within their triangle.
     *
     * @method barycentricInsideTriangle
     * @static
     * @param {Array of Number} bary Barycentric coordinates.
     * @returns {Boolean} True if the barycentric coordinates are inside their triangle.
     * @returns {*}
     */
    window.SceneJS_math_barycentricInsideTriangle = function (bary) {

        var v = bary[1];
        var u = bary[2];

        return (u >= 0) && (v >= 0) && (u + v < 1);
    };

    /**
     * Gets cartesian coordinates from barycentric coordinates within a triangle.
     *
     * @method barycentricToCartesian
     * @static
     * @param {Array of Number} bary The barycentric coordinate.
     * @param {Array of Number} a First triangle vertex.
     * @param {Array of Number} b Second triangle vertex.
     * @param {Array of Number} c Third triangle vertex.
     * @param {Array of Number} [cartesian] Cartesian coordinates.
     * @returns {Array of Number} The cartesian coordinates, or null if the triangle was invalid.
     * @returns {*}
     */
    window.SceneJS_math_barycentricToCartesian = function (bary, a, b, c, cartesian) {

        cartesian = cartesian || SceneJS_math_vec3();

        var u = bary[0];
        var v = bary[1];
        var w = bary[2];

        cartesian[0] = a[0] * u + b[0] * v + c[0] * w;
        cartesian[1] = a[1] * u + b[1] * v + c[1] * w;
        cartesian[2] = a[2] * u + b[2] * v + c[2] * w;

        return cartesian;
    };


    /**
     * Builds vertex tangent vectors from positions, UVs and indices
     *
     * @method buildTangents
     * @static
     * @param {Array of Number} positions One-dimensional flattened array of positions.
     * @param {Array of Number} indices One-dimensional flattened array of indices.
     * @param {Array of Number} uv One-dimensional flattened array of UV coordinates.
     * @returns {Array of Number} One-dimensional flattened array of tangents.
     */
    window.SceneJS_math_buildTangents = function (positions, indices, uv) {

        var tangents = new Float32Array(positions.length);

        // The vertex arrays needs to be calculated
        // before the calculation of the tangents

        for (var location = 0; location < indices.length; location += 3) {

            // Recontructing each vertex and UV coordinate into the respective vectors

            var index = indices[location];

            var v0 = positions.subarray(index * 3, index * 3 + 3);
            var uv0 = uv.subarray(index * 2, index * 2 + 2);

            index = indices[location + 1];

            var v1 = positions.subarray(index * 3, index * 3 + 3);
            var uv1 = uv.subarray(index * 2, index * 2 + 2);

            index = indices[location + 2];

            var v2 = positions.subarray(index * 3, index * 3 + 3);
            var uv2 = uv.subarray(index * 2, index * 2 + 2);

            var deltaPos1 = SceneJS_math_subVec3(v1, v0, tempVec3);
            var deltaPos2 = SceneJS_math_subVec3(v2, v0, tempVec3b);

            var deltaUV1 = SceneJS_math_subVec2(uv1, uv0, tempVec3c);
            var deltaUV2 = SceneJS_math_subVec2(uv2, uv0, tempVec3d);

            var r = 1 / ((deltaUV1[0] * deltaUV2[1]) - (deltaUV1[1] * deltaUV2[0]));

            var tangent = SceneJS_math_mulVec3Scalar(
                SceneJS_math_subVec3(
                    SceneJS_math_mulVec3Scalar(deltaPos1, deltaUV2[1], tempVec3e),
                    SceneJS_math_mulVec3Scalar(deltaPos2, deltaUV1[1], tempVec3f),
                    tempVec3g
                ),
                r,
                tempVec3f
            );

            // Average the value of the vectors outs
            for (var v = 0; v < 3; v++) {
                var addTo = indices[location + v] * 3;

                tangents[addTo]     += tangent[0];
                tangents[addTo + 1] += tangent[1];
                tangents[addTo + 2] += tangent[2];
            }
        }

        return tangents;
    }

})();