safex-webgl 1.0.0

package/dist/core/kazmath/mat4.js

@@ -0,0 +1,671 @@
+import { log } from '../../helper/Debugger';
+import { degreesToRadians } from '../platform/Macro';
+import { Matrix3 } from './mat3';
+import { Plane } from './plane';
+import { Quaternion } from './quaternion';
+import { EPSILON } from './utility';
+import { Vec3 } from './vec3';
+export class Matrix4 {
+    mat;
+    constructor(mat4) {
+        if (mat4 && mat4.mat) {
+            this.mat = new Float32Array(mat4.mat);
+        }
+        else {
+            this.mat = new Float32Array(16);
+        }
+    }
+    /**
+     *  Get the up vector from a matrix.
+     *  @returns {Vec3}
+     */
+    getUpVec3 = function () {
+        const mat = this.mat;
+        const ret = new Vec3(mat[4], mat[5], mat[6]);
+        return ret.normalize();
+    };
+    /**
+     * Extract the right vector from a 4x4 matrix.
+     * @returns {Vec3}
+     */
+    getRightVec3 = function () {
+        const mat = this.mat;
+        const ret = new Vec3(mat[0], mat[1], mat[2]);
+        return ret.normalize();
+    };
+    /**
+     * Extract the forward vector from a 4x4 matrix.
+     * @returns {Vec3}
+     */
+    getForwardVec3 = function () {
+        const mat = this.mat;
+        const ret = new Vec3(mat[8], mat[9], mat[10]);
+        return ret.normalize();
+    };
+    lookAt = function (eyeVec, centerVec, upVec) {
+        const f = new Vec3(centerVec), up = new Vec3(upVec), mat = this.mat;
+        f.subtract(eyeVec);
+        f.normalize();
+        up.normalize();
+        const s = new Vec3(f);
+        s.cross(up);
+        s.normalize();
+        const u = new Vec3(s);
+        u.cross(f);
+        s.normalize();
+        this.identity();
+        mat[0] = s.x;
+        mat[4] = s.y;
+        mat[8] = s.z;
+        mat[1] = u.x;
+        mat[5] = u.y;
+        mat[9] = u.z;
+        mat[2] = -f.x;
+        mat[6] = -f.y;
+        mat[10] = -f.z;
+        tempMatrix = Matrix4.createByTranslation(-eyeVec.x, -eyeVec.y, -eyeVec.z, tempMatrix);
+        this.multiply(tempMatrix);
+        return this;
+    };
+    /**
+     * current matrix multiplies with other matrix mat4
+     * @param {Matrix4} mat4
+     * @returns {Matrix4}
+     */
+    multiply = function (mat4) {
+        // Cache the matrix values (makes for huge speed increases!)
+        const mat = this.mat, mat2 = mat4.mat;
+        const a00 = mat[0], a01 = mat[1], a02 = mat[2], a03 = mat[3];
+        const a10 = mat[4], a11 = mat[5], a12 = mat[6], a13 = mat[7];
+        const a20 = mat[8], a21 = mat[9], a22 = mat[10], a23 = mat[11];
+        const a30 = mat[12], a31 = mat[13], a32 = mat[14], a33 = mat[15];
+        const b00 = mat2[0], b01 = mat2[1], b02 = mat2[2], b03 = mat2[3];
+        const b10 = mat2[4], b11 = mat2[5], b12 = mat2[6], b13 = mat2[7];
+        const b20 = mat2[8], b21 = mat2[9], b22 = mat2[10], b23 = mat2[11];
+        const b30 = mat2[12], b31 = mat2[13], b32 = mat2[14], b33 = mat2[15];
+        mat[0] = b00 * a00 + b01 * a10 + b02 * a20 + b03 * a30;
+        mat[1] = b00 * a01 + b01 * a11 + b02 * a21 + b03 * a31;
+        mat[2] = b00 * a02 + b01 * a12 + b02 * a22 + b03 * a32;
+        mat[3] = b00 * a03 + b01 * a13 + b02 * a23 + b03 * a33;
+        mat[4] = b10 * a00 + b11 * a10 + b12 * a20 + b13 * a30;
+        mat[5] = b10 * a01 + b11 * a11 + b12 * a21 + b13 * a31;
+        mat[6] = b10 * a02 + b11 * a12 + b12 * a22 + b13 * a32;
+        mat[7] = b10 * a03 + b11 * a13 + b12 * a23 + b13 * a33;
+        mat[8] = b20 * a00 + b21 * a10 + b22 * a20 + b23 * a30;
+        mat[9] = b20 * a01 + b21 * a11 + b22 * a21 + b23 * a31;
+        mat[10] = b20 * a02 + b21 * a12 + b22 * a22 + b23 * a32;
+        mat[11] = b20 * a03 + b21 * a13 + b22 * a23 + b23 * a33;
+        mat[12] = b30 * a00 + b31 * a10 + b32 * a20 + b33 * a30;
+        mat[13] = b30 * a01 + b31 * a11 + b32 * a21 + b33 * a31;
+        mat[14] = b30 * a02 + b31 * a12 + b32 * a22 + b33 * a32;
+        mat[15] = b30 * a03 + b31 * a13 + b32 * a23 + b33 * a33;
+        return this;
+    };
+    /**
+     * Extract a 3x3 rotation matrix from the input 4x4 transformation.
+     * @returns {Matrix3}
+     */
+    extractRotation = function () {
+        const matrix = new Matrix3(), mat4 = this.mat, mat3 = matrix.mat;
+        mat3[0] = mat4[0];
+        mat3[1] = mat4[1];
+        mat3[2] = mat4[2];
+        mat3[3] = mat4[4];
+        mat3[4] = mat4[5];
+        mat3[5] = mat4[6];
+        mat3[6] = mat4[8];
+        mat3[7] = mat4[9];
+        mat3[8] = mat4[10];
+        return matrix;
+    };
+    extractPlane = function (planeType) {
+        const plane = new Plane(), mat = this.mat;
+        switch (planeType) {
+            case Plane.RIGHT:
+                plane.a = mat[3] - mat[0];
+                plane.b = mat[7] - mat[4];
+                plane.c = mat[11] - mat[8];
+                plane.d = mat[15] - mat[12];
+                break;
+            case Plane.LEFT:
+                plane.a = mat[3] + mat[0];
+                plane.b = mat[7] + mat[4];
+                plane.c = mat[11] + mat[8];
+                plane.d = mat[15] + mat[12];
+                break;
+            case Plane.BOTTOM:
+                plane.a = mat[3] + mat[1];
+                plane.b = mat[7] + mat[5];
+                plane.c = mat[11] + mat[9];
+                plane.d = mat[15] + mat[13];
+                break;
+            case Plane.TOP:
+                plane.a = mat[3] - mat[1];
+                plane.b = mat[7] - mat[5];
+                plane.c = mat[11] - mat[9];
+                plane.d = mat[15] - mat[13];
+                break;
+            case Plane.FAR:
+                plane.a = mat[3] - mat[2];
+                plane.b = mat[7] - mat[6];
+                plane.c = mat[11] - mat[10];
+                plane.d = mat[15] - mat[14];
+                break;
+            case Plane.NEAR:
+                plane.a = mat[3] + mat[2];
+                plane.b = mat[7] + mat[6];
+                plane.c = mat[11] + mat[10];
+                plane.d = mat[15] + mat[14];
+                break;
+            default:
+                log(' static extractPlane: Invalid plane index');
+                break;
+        }
+        const t = Math.sqrt(plane.a * plane.a + plane.b * plane.b + plane.c * plane.c);
+        plane.a /= t;
+        plane.b /= t;
+        plane.c /= t;
+        plane.d /= t;
+        return plane;
+    };
+    /**
+     * Take the rotation from a 4x4 transformation matrix, and return it as an axis and an angle (in radians)
+     * @returns {*|{axis: Vec3, angle: number}}
+     */
+    toAxisAndAngle = function () {
+        /*Surely not this easy?*/
+        const rotation = this.extractRotation();
+        const temp = Quaternion.rotationMatrix(rotation);
+        return temp.toAxisAndAngle();
+    };
+    /**
+     * Calculates the inverse of current matrix.
+     * @returns {Matrix4} Returns null if there is no inverse, else returns a new inverse matrix object
+     */
+    inverse = function () {
+        //kmMat4Inverse
+        const inv = new Matrix4(this);
+        const tmp = new Matrix4(identityMatrix);
+        if (Matrix4._gaussj(inv, tmp) === false)
+            return null;
+        return inv;
+    };
+    /**
+     * Returns true if current matrix is an identity matrix, false otherwise
+     */
+    isIdentity = function () {
+        // kmMat4IsIdentity
+        const mat = this.mat;
+        return (mat[0] === 1 &&
+            mat[1] === 0 &&
+            mat[2] === 0 &&
+            mat[3] === 0 &&
+            mat[4] === 0 &&
+            mat[5] === 1 &&
+            mat[6] === 0 &&
+            mat[7] === 0 &&
+            mat[8] === 0 &&
+            mat[9] === 0 &&
+            mat[10] === 1 &&
+            mat[11] === 0 &&
+            mat[12] === 0 &&
+            mat[13] === 0 &&
+            mat[14] === 0 &&
+            mat[15] === 1);
+    };
+    /**
+     *  transpose the current matrix
+     */
+    transpose = function () {
+        // kmMat4Transpose
+        const mat = this.mat;
+        const m1 = mat[1], m2 = mat[2], m3 = mat[3], m4 = mat[4], m6 = mat[6], m7 = mat[7], m8 = mat[8], m9 = mat[9], m11 = mat[11], m12 = mat[12], m13 = mat[13], m14 = mat[14];
+        mat[1] = m4;
+        mat[2] = m8;
+        mat[3] = m12;
+        mat[4] = m1;
+        mat[6] = m9;
+        mat[7] = m13;
+        mat[8] = m2;
+        mat[9] = m6;
+        mat[11] = m14;
+        mat[12] = m3;
+        mat[13] = m7;
+        mat[14] = m11;
+        return this;
+    };
+    /**
+     * Sets matrix to identity value.
+     * @returns {Matrix4}
+     */
+    identity = function () {
+        const mat = this.mat;
+        mat[1] = mat[2] = mat[3] = mat[4] = mat[6] = mat[7] = mat[8] = mat[9] = mat[11] = mat[12] = mat[13] = mat[14] = 0;
+        mat[0] = mat[5] = mat[10] = mat[15] = 1.0;
+        return this;
+    };
+    get = function (row, col) {
+        return this.mat[row + 4 * col];
+    };
+    set = function (row, col, value) {
+        this.mat[row + 4 * col] = value;
+    };
+    swap = function (r1, c1, r2, c2) {
+        /*        var tmp = this.get(r1, c1);
+                this.set(r1, c1, this.get(r2, c2));
+                this.set(r2, c2, tmp);*/
+        const mat = this.mat, tmp = mat[r1 + 4 * c1];
+        mat[r1 + 4 * c1] = mat[r2 + 4 * c2];
+        mat[r2 + 4 * c2] = tmp;
+    };
+    /**
+     * Fills a Matrix4 structure with the values from a 16 element array of floats
+     * @param {Array} scalarArr
+     */
+    fill = function (scalarArr) {
+        //kmMat4Fill
+        const mat = this.mat;
+        for (let i = 0; i < 16; i++) {
+            mat[i] = scalarArr[i];
+        }
+        return this;
+    };
+    /**
+     * Assigns the value of current matrix from mat4
+     * @param {Matrix4} mat4
+     * @returns {Matrix4}
+     */
+    assignFrom = function (mat4) {
+        if (this === mat4) {
+            log('mat. static assignFrom(): mat4 equals current matrix');
+            return this;
+        }
+        const outArr = this.mat, inArr = mat4.mat;
+        outArr[0] = inArr[0];
+        outArr[1] = inArr[1];
+        outArr[2] = inArr[2];
+        outArr[3] = inArr[3];
+        outArr[4] = inArr[4];
+        outArr[5] = inArr[5];
+        outArr[6] = inArr[6];
+        outArr[7] = inArr[7];
+        outArr[8] = inArr[8];
+        outArr[9] = inArr[9];
+        outArr[10] = inArr[10];
+        outArr[11] = inArr[11];
+        outArr[12] = inArr[12];
+        outArr[13] = inArr[13];
+        outArr[14] = inArr[14];
+        outArr[15] = inArr[15];
+        return this;
+    };
+    /**
+     * Returns true if current matrix equal mat4 (approximately)
+     * @param {Matrix4} mat4
+     * @returns {boolean}
+     */
+    equals = function (mat4) {
+        if (this === mat4) {
+            log('kmMat4AreEqual(): pMat1 and pMat2 are same object.');
+            return true;
+        }
+        const matA = this.mat;
+        const matB = mat4.mat;
+        for (let i = 0; i < 16; i++) {
+            if (!(matA[i] + EPSILON > matB[i] && matA[i] - EPSILON < matB[i]))
+                return false;
+        }
+        return true;
+    };
+    /**
+     * Builds an X-axis rotation matrix and stores it in matrix, returns matrix, if matrix is null, create a new matrix
+     * @param {Number} radians
+     * @param {Matrix4} [matrix]
+     * @returns {Matrix4}
+     */
+    static createByRotationX = function (radians, matrix) {
+        //kmMat4RotationX
+        /*
+         |  1  0       0       0 |
+         M = |  0  cos(A) -sin(A)  0 |
+         |  0  sin(A)  cos(A)  0 |
+         |  0  0       0       1 |
+         */
+        matrix = matrix || new Matrix4();
+        const mat = matrix.mat;
+        mat[0] = 1.0;
+        mat[3] = mat[2] = mat[1] = 0.0;
+        mat[4] = 0.0;
+        mat[5] = Math.cos(radians);
+        mat[6] = Math.sin(radians);
+        mat[7] = 0.0;
+        mat[8] = 0.0;
+        mat[9] = -Math.sin(radians);
+        mat[10] = Math.cos(radians);
+        mat[11] = 0.0;
+        mat[14] = mat[13] = mat[12] = 0.0;
+        mat[15] = 1.0;
+        return matrix;
+    };
+    /**
+     * Builds a rotation matrix using the rotation around the Y-axis, The result is stored in matrix, matrix is returned.
+     * @param {Number} radians
+     * @param {Matrix4} [matrix]
+     * @returns {*}
+     */
+    static createByRotationY = function (radians, matrix) {
+        // kmMat4RotationY
+        /*
+         |  cos(A)  0   sin(A)  0 |
+         M = |  0       1   0       0 |
+         | -sin(A)  0   cos(A)  0 |
+         |  0       0   0       1 |
+         */
+        matrix = matrix || new Matrix4();
+        const mat = matrix.mat;
+        mat[0] = Math.cos(radians);
+        mat[1] = 0.0;
+        mat[2] = -Math.sin(radians);
+        mat[3] = 0.0;
+        mat[7] = mat[6] = mat[4] = 0.0;
+        mat[5] = 1.0;
+        mat[8] = Math.sin(radians);
+        mat[9] = 0.0;
+        mat[10] = Math.cos(radians);
+        mat[11] = 0.0;
+        mat[14] = mat[13] = mat[12] = 0.0;
+        mat[15] = 1.0;
+        return matrix;
+    };
+    /**
+     * Builds a rotation matrix around the Z-axis. The resulting matrix is stored in matrix. matrix is returned.
+     * @param {Number} radians
+     * @param {Matrix4} matrix
+     * @return {Matrix4}
+     */
+    static createByRotationZ = function (radians, matrix) {
+        // kmMat4RotationZ
+        /*
+         |  cos(A)  -sin(A)   0   0 |
+         M = |  sin(A)   cos(A)   0   0 |
+         |  0        0        1   0 |
+         |  0        0        0   1 |
+         */
+        matrix = matrix || new Matrix4();
+        const mat = matrix.mat;
+        mat[0] = Math.cos(radians);
+        mat[1] = Math.sin(radians);
+        mat[3] = mat[2] = 0.0;
+        mat[4] = -Math.sin(radians);
+        mat[5] = Math.cos(radians);
+        mat[7] = mat[6] = 0.0;
+        mat[11] = mat[9] = mat[8] = 0.0;
+        mat[10] = 1.0;
+        mat[14] = mat[13] = mat[12] = 0.0;
+        mat[15] = 1.0;
+        return matrix;
+    };
+    /**
+     * Builds a rotation matrix from pitch, yaw and roll. The resulting matrix is stored in parameter matrix and returns.
+     * @param {Number} pitch
+     * @param {Number} yaw
+     * @param {Number} roll
+     * @param {Matrix4} [matrix] if matrix is undefined, creates a new matrix.
+     * @returns {Matrix4}
+     */
+    static createByPitchYawRoll = function (pitch, yaw, roll, matrix) {
+        matrix = matrix || new Matrix4();
+        const cr = Math.cos(pitch), sr = Math.sin(pitch);
+        const cp = Math.cos(yaw), sp = Math.sin(yaw);
+        const cy = Math.cos(roll), sy = Math.sin(roll);
+        const srsp = sr * sp, crsp = cr * sp;
+        const mat = matrix.mat;
+        mat[0] = cp * cy;
+        mat[4] = cp * sy;
+        mat[8] = -sp;
+        mat[1] = srsp * cy - cr * sy;
+        mat[5] = srsp * sy + cr * cy;
+        mat[9] = sr * cp;
+        mat[2] = crsp * cy + sr * sy;
+        mat[6] = crsp * sy - sr * cy;
+        mat[10] = cr * cp;
+        mat[3] = mat[7] = mat[11] = 0.0;
+        mat[15] = 1.0;
+        return matrix;
+    };
+    /**
+     * Builds a matrix by a quaternion.
+     * @param {Quaternion} quaternion
+     * @param {Matrix4} [matrix] if matrix is undefined, creates a new matrix.
+     * @returns {Matrix4}
+     */
+    static createByQuaternion = function (quaternion, matrix) {
+        matrix = matrix || new Matrix4();
+        const mat = matrix.mat;
+        mat[0] = 1.0 - 2.0 * (quaternion.y * quaternion.y + quaternion.z * quaternion.z);
+        mat[1] = 2.0 * (quaternion.x * quaternion.y + quaternion.z * quaternion.w);
+        mat[2] = 2.0 * (quaternion.x * quaternion.z - quaternion.y * quaternion.w);
+        mat[3] = 0.0;
+        // Second row
+        mat[4] = 2.0 * (quaternion.x * quaternion.y - quaternion.z * quaternion.w);
+        mat[5] = 1.0 - 2.0 * (quaternion.x * quaternion.x + quaternion.z * quaternion.z);
+        mat[6] = 2.0 * (quaternion.z * quaternion.y + quaternion.x * quaternion.w);
+        mat[7] = 0.0;
+        // Third row
+        mat[8] = 2.0 * (quaternion.x * quaternion.z + quaternion.y * quaternion.w);
+        mat[9] = 2.0 * (quaternion.y * quaternion.z - quaternion.x * quaternion.w);
+        mat[10] = 1.0 - 2.0 * (quaternion.x * quaternion.x + quaternion.y * quaternion.y);
+        mat[11] = 0.0;
+        // Fourth row
+        mat[14] = mat[13] = mat[12] = 0;
+        mat[15] = 1.0;
+        return matrix;
+    };
+    /**
+     * Build a 4x4 OpenGL transformation matrix using a 3x3 rotation matrix, and a 3d vector representing a translation.
+     * @param {Matrix3} rotation
+     * @param {Vec3} translation
+     * @param {Matrix4} [matrix] if matrix is undefined, creates a new matrix.
+     * @returns {Matrix4}
+     */
+    static createByRotationTranslation = function (rotation, translation, matrix) {
+        matrix = matrix || new Matrix4();
+        const mat = matrix.mat, rMat = rotation.mat;
+        mat[0] = rMat[0];
+        mat[1] = rMat[1];
+        mat[2] = rMat[2];
+        mat[3] = 0.0;
+        mat[4] = rMat[3];
+        mat[5] = rMat[4];
+        mat[6] = rMat[5];
+        mat[7] = 0.0;
+        mat[8] = rMat[6];
+        mat[9] = rMat[7];
+        mat[10] = rMat[8];
+        mat[11] = 0.0;
+        mat[12] = translation.x;
+        mat[13] = translation.y;
+        mat[14] = translation.z;
+        mat[15] = 1.0;
+        return matrix;
+    };
+    /**
+     * Builds a scaling matrix
+     * @param {Number} x
+     * @param {Number} y
+     * @param {Number} z
+     * @param {Matrix4} [matrix] if matrix is undefined, creates a new matrix.
+     * @returns {Matrix4}
+     */
+    static createByScale = function (x, y, z, matrix) {
+        //kmMat4Scaling
+        matrix = matrix || new Matrix4();
+        const mat = matrix.mat;
+        mat[0] = x;
+        mat[5] = y;
+        mat[10] = z;
+        mat[15] = 1.0;
+        mat[1] = mat[2] = mat[3] = mat[4] = mat[6] = mat[7] = mat[8] = mat[9] = mat[11] = mat[12] = mat[13] = mat[14] = 0;
+        return matrix;
+    };
+    /**
+     * Creates an orthographic projection matrix like glOrtho
+     * @param {Number} left
+     * @param {Number} right
+     * @param {Number} bottom
+     * @param {Number} top
+     * @param {Number} nearVal
+     * @param {Number} farVal
+     * @returns {Matrix4}
+     */
+    static createOrthographicProjection = function (left, right, bottom, top, nearVal, farVal) {
+        const matrix = new Matrix4(), mat = matrix.mat;
+        matrix.identity();
+        mat[0] = 2 / (right - left);
+        mat[5] = 2 / (top - bottom);
+        mat[10] = -2 / (farVal - nearVal);
+        mat[12] = -((right + left) / (right - left));
+        mat[13] = -((top + bottom) / (top - bottom));
+        mat[14] = -((farVal + nearVal) / (farVal - nearVal));
+        return matrix;
+    };
+    //Returns an upper and a lower triangular matrix which are L and R in the Gauss algorithm
+    static _gaussj = function (a, b) {
+        let i, icol = 0, irow = 0, j, k, l, ll;
+        const n = 4;
+        const m = 4;
+        let selElement;
+        let big, dumb, pivinv;
+        const indxc = [0, 0, 0, 0], indxr = [0, 0, 0, 0], ipiv = [0, 0, 0, 0];
+        /*    for (j = 0; j < n; j++) {
+         ipiv[j] = 0;
+         }*/
+        for (i = 0; i < n; i++) {
+            big = 0.0;
+            for (j = 0; j < n; j++) {
+                if (ipiv[j] !== 1) {
+                    for (k = 0; k < n; k++) {
+                        if (ipiv[k] === 0) {
+                            selElement = Math.abs(a.get(j, k));
+                            if (selElement >= big) {
+                                big = selElement;
+                                irow = j;
+                                icol = k;
+                            }
+                        }
+                    }
+                }
+            }
+            ++ipiv[icol];
+            if (irow !== icol) {
+                for (l = 0; l < n; l++)
+                    a.swap(irow, l, icol, l);
+                for (l = 0; l < m; l++)
+                    b.swap(irow, l, icol, l);
+            }
+            indxr[i] = irow;
+            indxc[i] = icol;
+            if (a.get(icol, icol) === 0.0)
+                return false;
+            pivinv = 1.0 / a.get(icol, icol);
+            a.set(icol, icol, 1.0);
+            for (l = 0; l < n; l++)
+                a.set(icol, l, a.get(icol, l) * pivinv);
+            for (l = 0; l < m; l++)
+                b.set(icol, l, b.get(icol, l) * pivinv);
+            for (ll = 0; ll < n; ll++) {
+                if (ll !== icol) {
+                    dumb = a.get(ll, icol);
+                    a.set(ll, icol, 0.0);
+                    for (l = 0; l < n; l++)
+                        a.set(ll, l, a.get(ll, l) - a.get(icol, l) * dumb);
+                    for (l = 0; l < m; l++)
+                        b.set(ll, l, a.get(ll, l) - b.get(icol, l) * dumb);
+                }
+            }
+        }
+        //    This is the end of the main loop over columns of the reduction. It only remains to unscram-
+        //    ble the solution in view of the column interchanges. We do this by interchanging pairs of
+        //    columns in the reverse order that the permutation was built up.
+        for (l = n - 1; l >= 0; l--) {
+            if (indxr[l] !== indxc[l]) {
+                for (k = 0; k < n; k++)
+                    a.swap(k, indxr[l], k, indxc[l]);
+            }
+        }
+        return true;
+    };
+    /**
+     * Build a rotation matrix from an axis and an angle.
+     * @param {Vec3} axis
+     * @param {Number} radians
+     * @param {Matrix4} [matrix]
+     * @returns {Matrix4}
+     */
+    static createByAxisAndAngle = function (axis, radians, matrix) {
+        matrix = matrix || new Matrix4();
+        const mat = this.mat, rcos = Math.cos(radians), rsin = Math.sin(radians);
+        const normalizedAxis = new Vec3(axis);
+        normalizedAxis.normalize();
+        mat[0] = rcos + normalizedAxis.x * normalizedAxis.x * (1 - rcos);
+        mat[1] = normalizedAxis.z * rsin + normalizedAxis.y * normalizedAxis.x * (1 - rcos);
+        mat[2] = -normalizedAxis.y * rsin + normalizedAxis.z * normalizedAxis.x * (1 - rcos);
+        mat[3] = 0.0;
+        mat[4] = -normalizedAxis.z * rsin + normalizedAxis.x * normalizedAxis.y * (1 - rcos);
+        mat[5] = rcos + normalizedAxis.y * normalizedAxis.y * (1 - rcos);
+        mat[6] = normalizedAxis.x * rsin + normalizedAxis.z * normalizedAxis.y * (1 - rcos);
+        mat[7] = 0.0;
+        mat[8] = normalizedAxis.y * rsin + normalizedAxis.x * normalizedAxis.z * (1 - rcos);
+        mat[9] = -normalizedAxis.x * rsin + normalizedAxis.y * normalizedAxis.z * (1 - rcos);
+        mat[10] = rcos + normalizedAxis.z * normalizedAxis.z * (1 - rcos);
+        mat[11] = 0.0;
+        mat[12] = mat[13] = mat[14] = 0.0;
+        mat[15] = 1.0;
+        return matrix;
+    };
+    /**
+     *  Builds a translation matrix.
+     * @param {Number} x
+     * @param {Number} y
+     * @param {Number} z
+     * @param {Matrix4} [matrix] if matrix is undefined, creates a new matrix.
+     * @returns {Matrix4}
+     */
+    static createByTranslation = function (x, y, z, matrix) {
+        //kmMat4Translation
+        matrix = matrix || new Matrix4();
+        matrix.identity();
+        matrix.mat[12] = x;
+        matrix.mat[13] = y;
+        matrix.mat[14] = z;
+        return matrix;
+    };
+    /**
+     * Creates a perspective projection matrix in the same way as gluPerspective
+     * @param {Number} fovY
+     * @param {Number} aspect
+     * @param {Number} zNear
+     * @param {Number} zFar
+     * @returns {Matrix4|Null}
+     */
+    static createPerspectiveProjection = function (fovY, aspect, zNear, zFar) {
+        const r = degreesToRadians(fovY / 2), deltaZ = zFar - zNear;
+        const s = Math.sin(r);
+        if (deltaZ === 0 || s === 0 || aspect === 0)
+            return null;
+        //cos(r) / sin(r) = cot(r)
+        const cotangent = Math.cos(r) / s;
+        const matrix = new Matrix4(), mat = matrix.mat;
+        matrix.identity();
+        mat[0] = cotangent / aspect;
+        mat[5] = cotangent;
+        mat[10] = -(zFar + zNear) / deltaZ;
+        mat[11] = -1;
+        mat[14] = (-2 * zNear * zFar) / deltaZ;
+        mat[15] = 0;
+        return matrix;
+    };
+}
+let tempMatrix = new Matrix4(); // an internal matrix
+export const identityMatrix = new Matrix4().identity();
+//# sourceMappingURL=mat4.js.map