@rings-webgpu/core 1.0.0 → 1.0.2

package/dist/src/math/Matrix4.js

@@ -0,0 +1,2571 @@
+import { CreateFloatArray, WasmMatrix, } from "@rings/wasm-matrix/WasmMatrix";
+import { DEGREES_TO_RADIANS, clamp, RADIANS_TO_DEGREES } from "./MathUtil";
+import { Orientation3D } from "./Orientation3D";
+import { Quaternion } from "./Quaternion";
+import { Vector3 } from "./Vector3";
+const EPSILON = 0.000001;
+/**
+ * math 4*4 matrix
+ * @group Math
+ */
+export class Matrix4 {
+    /**
+     * matrix44 bytes block size
+     */
+    static { this.blockBytes = 16 * 4; }
+    /**
+     * @internal
+     */
+    static { this.block = 16; }
+    /**
+     * matrix do total count
+     */
+    static { this.allocCount = 1000; }
+    /**
+     * quantity allocated for each capacity expansion
+     */
+    static { this.allocOnceCount = 1000; }
+    /**
+     * matrix has max limit count
+     */
+    static { this.maxCount = 50 * 10000; }
+    /**
+     * current matrix use count
+     */
+    static { this.useCount = 0; }
+    /**
+     * @internal
+     * wasm use memory use first ptr
+     */
+    static { this.wasmMatrixPtr = 0; }
+    static { this._zero = new Vector3(0, 0, 0); }
+    static { this._one = new Vector3(1, 1, 1); }
+    static { this._prs = [
+        new Vector3(),
+        new Vector3(),
+        new Vector3(),
+    ]; }
+    /**
+     * alloc web runtime cpu memory totalCount * 4(float) * 4
+     * init matrix memory by totalCount * 4(float) * 4
+     * @param count every alloc matrix count
+     */
+    /* eslint-disable */
+    static allocMatrix(allocCount) {
+        this.allocCount = allocCount;
+        Matrix4.dynamicMatrixBytes = WasmMatrix.matrixBuffer;
+        Matrix4.buffer = Matrix4.dynamicMatrixBytes.buffer;
+        Matrix4.wasmMatrixPtr = WasmMatrix.matrixBufferPtr;
+        this.dynamicGlobalMatrixRef ||= [];
+        this.dynamicGlobalMatrixRef.forEach((m) => {
+            m.offset = Matrix4.wasmMatrixPtr + m.index * Matrix4.blockBytes;
+            m.rawData = CreateFloatArray(Matrix4.dynamicMatrixBytes.buffer, m.offset, 16);
+        });
+        Matrix4.help_matrix_0 ||= new Matrix4();
+        Matrix4.help_matrix_1 ||= new Matrix4();
+        Matrix4.help_matrix_2 ||= new Matrix4();
+        Matrix4.helpMatrix ||= new Matrix4();
+        Matrix4.helpMatrix2 ||= new Matrix4();
+        Matrix4._getEulerMatrix ||= new Matrix4();
+        Matrix4._getEulerMatrix.identity();
+    }
+    /**
+     * create matrix from two direction
+     * @param fromDirection first direction
+     * @param toDirection  second direction
+     * @param target ref matrix
+     * @returns return new one matrix
+     */
+    static fromToRotation(fromDirection, toDirection, target) {
+        target ||= new Matrix4();
+        target.transformDir(fromDirection, toDirection);
+        return target;
+    }
+    /**
+     * Generate a matrix (rotate degrees with x,y,z as the center axis)
+     * @param x x on the central axis
+     * @param y y on the central axis
+     * @param z z on the central axis
+     * @param degrees rotation angle
+     * @returns Matrix4 result
+     */
+    static getAxisRotation(x, y, z, degrees) {
+        let m = new Matrix4();
+        let rad = degrees * (Math.PI / 180);
+        let c = Math.cos(rad);
+        let s = Math.sin(rad);
+        let t = 1 - c;
+        let tmp1, tmp2;
+        m.rawData[0] = c + x * x * t;
+        m.rawData[5] = c + y * y * t;
+        m.rawData[10] = c + z * z * t;
+        tmp1 = x * y * t;
+        tmp2 = z * s;
+        m.rawData[1] = tmp1 + tmp2;
+        m.rawData[4] = tmp1 - tmp2;
+        tmp1 = x * z * t;
+        tmp2 = y * s;
+        m.rawData[8] = tmp1 + tmp2;
+        m.rawData[2] = tmp1 - tmp2;
+        tmp1 = y * z * t;
+        tmp2 = x * s;
+        m.rawData[9] = tmp1 - tmp2;
+        m.rawData[6] = tmp1 + tmp2;
+        return m;
+    }
+    /**
+     * Arrange the Euler values
+     * @param euler Euler values
+     */
+    static sanitizeEuler(euler) {
+        Matrix4.makePositive(euler);
+    }
+    /**
+     *
+     * @param euler
+     */
+    static makePositive(euler) {
+        let negativeFlip = -0.0001;
+        let positiveFlip = Math.PI * 2.0 - 0.0001;
+        if (euler.x < negativeFlip) {
+            euler.x += 2.0 * Math.PI;
+        }
+        else if (euler.x > positiveFlip) {
+            euler.x -= 2.0 * Math.PI;
+        }
+        if (euler.y < negativeFlip) {
+            euler.y += 2.0 * Math.PI;
+        }
+        else if (euler.y > positiveFlip) {
+            euler.y -= 2.0 * Math.PI;
+        }
+        if (euler.z < negativeFlip) {
+            euler.z += 2.0 * Math.PI;
+        }
+        else if (euler.z > positiveFlip) {
+            euler.z -= 2.0 * Math.PI;
+        }
+    }
+    /**
+     * Convert the matrix to Euler angles
+     * @param matrix Matrix to be transformed
+     * @param v euler angle
+     * @returns
+     */
+    static matrixToEuler(matrix, v) {
+        if (matrix.get(1, 2) < 0.999) {
+            // some fudge for imprecision
+            if (matrix.get(1, 2) > -0.999) {
+                // some fudge for imprecision
+                v.x = Math.asin(-matrix.get(1, 2));
+                v.y = Math.atan2(matrix.get(0, 2), matrix.get(2, 2));
+                v.z = Math.atan2(matrix.get(1, 0), matrix.get(1, 1));
+                Matrix4.sanitizeEuler(v);
+                return true;
+            }
+            else {
+                // WARNING.  Not unique.  YA - ZA = atan2(r01,r00)
+                v.x = Math.PI * 0.5;
+                v.y = Math.atan2(matrix.get(0, 1), matrix.get(0, 0));
+                v.z = 0.0;
+                Matrix4.sanitizeEuler(v);
+                return false;
+            }
+        }
+        else {
+            // WARNING.  Not unique.  YA + ZA = atan2(-r01,r00)
+            v.x = -Math.PI * 0.5;
+            v.y = Math.atan2(-matrix.get(0, 1), matrix.get(0, 0));
+            v.z = 0.0;
+            Matrix4.sanitizeEuler(v);
+            return false;
+        }
+    }
+    /**
+     * Multiply the world matrix, specifying parameters and results according to the index
+     * @param aMat Matrix to be multiplied (please specify index)
+     * @param bMat Matrix to be multiplied (please specify index)
+     * @param target_Mat Result matrix (get results based on index)
+     */
+    static matrixMultiply(aMat, bMat, target_Mat) {
+        Matrix4.wasm.Matrix_Multiply(aMat.index, bMat.index, target_Mat.index);
+    }
+    /**
+     * World matrix extension, according to the index to specify parameters and results
+     * @param aMat Matrix to be multiplied (please specify index)
+     * @param bMat Matrix to be multiplied (please specify index)
+     * @param target_Mat Result matrix (get results based on index)
+     */
+    static matrixAppend(aMat, bMat, target_Mat) {
+        Matrix4.wasm.Matrix_Append(aMat.index, bMat.index, target_Mat.index);
+    }
+    /**
+     * The Y-axis is rotated between the world matrix, and the parameters and results are specified according to the index
+     * @param aMat Matrix to be multiplied (please specify index)
+     * @param bMat Matrix to be multiplied (please specify index)
+     * @param target_Mat Result matrix (get results based on index)
+     */
+    static matrixRotateY(rad, target_Mat) {
+        Matrix4.wasm.Matrix_Append(rad, target_Mat.index);
+    }
+    /**
+     * Rotate the world matrix, specifying parameters and results according to the index
+     * @param aMat Matrix to be multiplied (please specify index)
+     * @param bMat Matrix to be multiplied (please specify index)
+     * @param target_Mat Result matrix (get results based on index)
+     */
+    static matrixRotate(rad, axis, target_Mat) {
+        Matrix4.wasm.Matrix_Rotate(rad, axis, target_Mat.index);
+    }
+    /**
+     *
+     * @param local --
+     */
+    constructor(doMatrix = false) {
+        /**
+         * matrix index at global matrix list
+         */
+        this.index = 0;
+        /**
+         * @internal
+         */
+        this.offset = 0;
+        // if (doMatrix) {
+        if (Matrix4.useCount >= Matrix4.allocCount) {
+            let allocCount = Matrix4.allocCount + Matrix4.allocOnceCount;
+            import.meta.env.DEV && console.warn(`allocMatrix(${allocCount})`);
+            WasmMatrix.allocMatrix(allocCount);
+        }
+        this.index = Matrix4.useCount;
+        this.offset = Matrix4.wasmMatrixPtr + this.index * Matrix4.blockBytes;
+        // if (Matrix4.dynamicGlobalMatrixRef) {
+        Matrix4.dynamicGlobalMatrixRef[this.index] = this;
+        Matrix4.useCount++;
+        this.rawData = CreateFloatArray(Matrix4.dynamicMatrixBytes.buffer, this.offset, 16);
+        this._position = new Vector3();
+        this.identity();
+    }
+    /**
+     * current matrix move position and rotation to target
+     * @param eye eye position
+     * @param at target position
+     * @param up normalize axis way
+     */
+    lookAt(eye, at, up = Vector3.Y_AXIS) {
+        let data = this.rawData;
+        let zAxis = at.subtract(eye, Vector3.HELP_0);
+        if (zAxis.length === 0) {
+            zAxis.z = 1;
+        }
+        zAxis.normalize();
+        let xAxis = up.crossProduct(zAxis, Vector3.HELP_1);
+        if (xAxis.length === 0) {
+            if (Math.abs(up.z) === 1) {
+                zAxis.x += 0.0001;
+            }
+            else {
+                zAxis.z -= 0.0001;
+            }
+            zAxis.normalize();
+            xAxis = up.crossProduct(zAxis, Vector3.HELP_1);
+        }
+        xAxis.normalize();
+        let yAxis = zAxis.crossProduct(xAxis, Vector3.HELP_2);
+        data[0] = xAxis.x;
+        data[1] = yAxis.x;
+        data[2] = zAxis.x;
+        data[3] = 0;
+        data[4] = xAxis.y;
+        data[5] = yAxis.y;
+        data[6] = zAxis.y;
+        data[7] = 0;
+        data[8] = xAxis.z;
+        data[9] = yAxis.z;
+        data[10] = zAxis.z;
+        data[11] = 0;
+        data[12] = -xAxis.dotProduct(eye);
+        data[13] = -yAxis.dotProduct(eye);
+        data[14] = -zAxis.dotProduct(eye);
+        data[15] = 1;
+    }
+    static { this.floatArray = new Float64Array(16).fill(0); }
+    /**
+     * matrix multiply
+     * @param mat4 multiply target
+     */
+    multiply(mat4) {
+        let a = this.rawData;
+        let b = mat4.rawData;
+        let r = Matrix4.floatArray;
+        r[0] = a[0] * b[0] + a[1] * b[4] + a[2] * b[8] + a[3] * b[12];
+        r[1] = a[0] * b[1] + a[1] * b[5] + a[2] * b[9] + a[3] * b[13];
+        r[2] = a[0] * b[2] + a[1] * b[6] + a[2] * b[10] + a[3] * b[14];
+        r[3] = a[0] * b[3] + a[1] * b[7] + a[2] * b[11] + a[3] * b[15];
+        r[4] = a[4] * b[0] + a[5] * b[4] + a[6] * b[8] + a[7] * b[12];
+        r[5] = a[4] * b[1] + a[5] * b[5] + a[6] * b[9] + a[7] * b[13];
+        r[6] = a[4] * b[2] + a[5] * b[6] + a[6] * b[10] + a[7] * b[14];
+        r[7] = a[4] * b[3] + a[5] * b[7] + a[6] * b[11] + a[7] * b[15];
+        r[8] = a[8] * b[0] + a[9] * b[4] + a[10] * b[8] + a[11] * b[12];
+        r[9] = a[8] * b[1] + a[9] * b[5] + a[10] * b[9] + a[11] * b[13];
+        r[10] = a[8] * b[2] + a[9] * b[6] + a[10] * b[10] + a[11] * b[14];
+        r[11] = a[8] * b[3] + a[9] * b[7] + a[10] * b[11] + a[11] * b[15];
+        r[12] = a[12] * b[0] + a[13] * b[4] + a[14] * b[8] + a[15] * b[12];
+        r[13] = a[12] * b[1] + a[13] * b[5] + a[14] * b[9] + a[15] * b[13];
+        r[14] = a[12] * b[2] + a[13] * b[6] + a[14] * b[10] + a[15] * b[14];
+        r[15] = a[12] * b[3] + a[13] * b[7] + a[14] * b[11] + a[15] * b[15];
+        a[0] = r[0];
+        a[1] = r[1];
+        a[2] = r[2];
+        a[3] = r[3];
+        a[4] = r[4];
+        a[5] = r[5];
+        a[6] = r[6];
+        a[7] = r[7];
+        a[8] = r[8];
+        a[9] = r[9];
+        a[10] = r[10];
+        a[11] = r[11];
+        a[12] = r[12];
+        a[13] = r[13];
+        a[14] = r[14];
+        a[15] = r[15];
+    }
+    /**
+     *
+     * @param a
+     * @param b
+     * @returns
+     */
+    multiplyMatrices(a, b) {
+        const ae = a.rawData;
+        const be = b.rawData;
+        const te = this.rawData;
+        const a11 = ae[0], a12 = ae[4], a13 = ae[8], a14 = ae[12];
+        const a21 = ae[1], a22 = ae[5], a23 = ae[9], a24 = ae[13];
+        const a31 = ae[2], a32 = ae[6], a33 = ae[10], a34 = ae[14];
+        const a41 = ae[3], a42 = ae[7], a43 = ae[11], a44 = ae[15];
+        const b11 = be[0], b12 = be[4], b13 = be[8], b14 = be[12];
+        const b21 = be[1], b22 = be[5], b23 = be[9], b24 = be[13];
+        const b31 = be[2], b32 = be[6], b33 = be[10], b34 = be[14];
+        const b41 = be[3], b42 = be[7], b43 = be[11], b44 = be[15];
+        te[0] = a11 * b11 + a12 * b21 + a13 * b31 + a14 * b41;
+        te[4] = a11 * b12 + a12 * b22 + a13 * b32 + a14 * b42;
+        te[8] = a11 * b13 + a12 * b23 + a13 * b33 + a14 * b43;
+        te[12] = a11 * b14 + a12 * b24 + a13 * b34 + a14 * b44;
+        te[1] = a21 * b11 + a22 * b21 + a23 * b31 + a24 * b41;
+        te[5] = a21 * b12 + a22 * b22 + a23 * b32 + a24 * b42;
+        te[9] = a21 * b13 + a22 * b23 + a23 * b33 + a24 * b43;
+        te[13] = a21 * b14 + a22 * b24 + a23 * b34 + a24 * b44;
+        te[2] = a31 * b11 + a32 * b21 + a33 * b31 + a34 * b41;
+        te[6] = a31 * b12 + a32 * b22 + a33 * b32 + a34 * b42;
+        te[10] = a31 * b13 + a32 * b23 + a33 * b33 + a34 * b43;
+        te[14] = a31 * b14 + a32 * b24 + a33 * b34 + a34 * b44;
+        te[3] = a41 * b11 + a42 * b21 + a43 * b31 + a44 * b41;
+        te[7] = a41 * b12 + a42 * b22 + a43 * b32 + a44 * b42;
+        te[11] = a41 * b13 + a42 * b23 + a43 * b33 + a44 * b43;
+        te[15] = a41 * b14 + a42 * b24 + a43 * b34 + a44 * b44;
+        return this;
+    }
+    /**
+     * convert a vector3 to this matrix space
+     * if output not set , return a new one
+     * @param v target vector3
+     * @param output save target
+     * @returns save target
+     */
+    multiplyPoint3(v, output) {
+        output ||= new Vector3();
+        let rawData = this.rawData;
+        output.x =
+            rawData[0] * v.x + rawData[4] * v.y + rawData[8] * v.z + rawData[12];
+        output.y =
+            rawData[1] * v.x + rawData[5] * v.y + rawData[9] * v.z + rawData[13];
+        output.z =
+            rawData[2] * v.x + rawData[6] * v.y + rawData[10] * v.z + rawData[14];
+        return output;
+    }
+    multiplyVector4(a, out) {
+        out ||= new Vector3();
+        let m = this.rawData;
+        let x = a.x;
+        let y = a.y;
+        let z = a.z;
+        let w = m[3] * x + m[7] * y + m[11] * z + m[15];
+        w = w || 1.0;
+        out.x = (m[0] * x + m[4] * y + m[8] * z + m[12]) / w;
+        out.y = (m[1] * x + m[5] * y + m[9] * z + m[13]) / w;
+        out.z = (m[2] * x + m[6] * y + m[10] * z + m[14]) / w;
+        out.w = 1;
+        return out;
+    }
+    /**
+     * convert a vector3 to this matrix space
+     * if output not set , return a new one
+     * @param v convert target
+     * @param target ref one vector3
+     * @returns Vector3
+     */
+    transformVector4(v, target) {
+        let data = this.rawData;
+        target ||= new Vector3();
+        let x = v.x;
+        let y = v.y;
+        let z = v.z;
+        let w = v.w;
+        target.x = x * data[0] + y * data[4] + z * data[8] + w * data[12];
+        target.y = x * data[1] + y * data[5] + z * data[9] + w * data[13];
+        target.z = x * data[2] + y * data[6] + z * data[10] + w * data[14];
+        target.w = x * data[3] + y * data[7] + z * data[11] + w * data[15];
+        return target;
+    }
+    /**
+     * Convert projection coordinates to 3D coordinates
+     * @param v vector3 target
+     * @param output ref vector3d
+     * @returns
+     */
+    perspectiveMultiplyPoint3(v, output) {
+        let res = Vector3.HELP_2;
+        let w;
+        let rawData = this.rawData;
+        res.x =
+            rawData[0] * v.x + rawData[4] * v.y + rawData[8] * v.z + rawData[12];
+        res.y =
+            rawData[1] * v.x + rawData[5] * v.y + rawData[9] * v.z + rawData[13];
+        res.z =
+            rawData[2] * v.x + rawData[6] * v.y + rawData[10] * v.z + rawData[14];
+        w = rawData[3] * v.x + rawData[7] * v.y + rawData[11] * v.z + rawData[15];
+        if (Math.abs(w) > 1.0e-7) {
+            let invW = 1.0 / w;
+            output.x = res.x * invW;
+            output.y = res.y * invW;
+            output.z = res.z * invW;
+            return true;
+        }
+        else {
+            output.x = 0.0;
+            output.y = 0.0;
+            output.z = 0.0;
+            return false;
+        }
+    }
+    /**
+     * set matrix perspective
+     * @param fov perspective angle 0 ~ 90
+     * @param aspect aspect ratio
+     * @param zn near plane
+     * @param zf far plane
+     */
+    perspective(fov, aspect, zn, zf) {
+        let data = this.rawData;
+        let angle = (fov * DEGREES_TO_RADIANS) / 2.0;
+        let f = Math.cos(angle) / Math.sin(angle);
+        // 0.5 / tan
+        data[0] = -f / aspect;
+        // data[0] = xScale;
+        data[1] = 0;
+        data[2] = 0;
+        data[3] = 0;
+        data[4] = 0;
+        data[5] = f;
+        data[6] = 0;
+        data[7] = 0;
+        data[8] = 0;
+        data[9] = 0;
+        data[10] = zf / (zf - zn);
+        data[11] = 1;
+        data[12] = 0;
+        data[13] = 0;
+        data[14] = (-zn * zf) / (zf - zn);
+        data[15] = 0;
+    }
+    perspective3(fov, aspect, near, far) {
+        let y = Math.tan((fov * Math.PI) / 360) * near;
+        let x = y * aspect;
+        this.frustum(-x, x, -y, y, near, far);
+    }
+    frustum(l, r, b, t, n, f) {
+        let m = this.rawData;
+        m[0] = (-2 * n) / (r - l);
+        m[1] = 0;
+        m[2] = 0;
+        m[3] = 0;
+        m[4] = 0;
+        m[5] = (2 * n) / (t - b);
+        m[6] = 0;
+        m[7] = 0;
+        m[8] = (r + l) / (r - l);
+        m[9] = (t + b) / (t - b);
+        m[10] = f / (f - n);
+        m[11] = 1;
+        m[12] = 0;
+        m[13] = 0;
+        m[14] = (-f * n) / (f - n);
+        m[15] = 0;
+    }
+    /**
+     * set matrix orthogonal projection
+     * @param w screen width
+     * @param h screen height
+     * @param zn camera near plane
+     * @param zf camera far plane
+     * @returns this matrix
+     */
+    ortho(w, h, zn, zf) {
+        let data = this.rawData;
+        data[0] = 2 / w;
+        data[1] = 0;
+        data[2] = 0;
+        data[3] = 0;
+        data[4] = 0;
+        data[5] = 2 / h;
+        data[6] = 0;
+        data[7] = 0;
+        data[8] = 0;
+        data[9] = 0;
+        data[10] = 1 / (zf - zn);
+        data[11] = 0;
+        data[12] = 0;
+        data[13] = 0;
+        data[14] = zn / (zn - zf);
+        data[15] = 1;
+        return this;
+    }
+    /**
+     * set matrix orthogonal projection by view side
+     * @param left orthogonal view left
+     * @param right orthogonal view right
+     * @param bottom orthogonal view bottom
+     * @param top orthogonal view top
+     * @param near camera near plane
+     * @param far camera far plane
+     * @returns this matrix
+     */
+    orthoZO(left, right, bottom, top, near, far) {
+        let data = this.rawData;
+        let lr = 1 / (left - right);
+        let bt = 1 / (bottom - top);
+        let nf = 1 / (near - far);
+        data[0] = -2 * lr;
+        data[1] = 0;
+        data[2] = 0;
+        data[3] = 0;
+        data[4] = 0;
+        data[5] = -2 * bt;
+        data[6] = 0;
+        data[7] = 0;
+        data[8] = 0;
+        data[9] = 0;
+        data[10] = nf;
+        data[11] = 0;
+        data[12] = (left + right) * lr;
+        data[13] = (top + bottom) * bt;
+        data[14] = near * nf;
+        data[15] = 1;
+        return this;
+    }
+    /**
+     * set matrix orthogonal projection by view center
+     */
+    orthoOffCenter(l, r, b, t, zn, zf) {
+        let data = this.rawData;
+        data[0] = 2 / (r - l);
+        data[1] = 0;
+        data[2] = 0;
+        data[3] = 0;
+        data[4] = 0;
+        data[5] = 2 / (t - b);
+        data[6] = 0;
+        data[7] = 0;
+        data[8] = 0;
+        data[9] = 0;
+        data[10] = 1.0 / (zf - zn);
+        data[11] = 0;
+        data[12] = (l + r) / (l - r);
+        data[13] = (t + b) / (b - t);
+        data[14] = zn / (zn - zf);
+        data[15] = 1;
+    }
+    /**
+     * set matrix from two direction
+     * @param fromDirection first direction
+     * @param toDirection second direction
+     */
+    transformDir(fromDirection, toDirection) {
+        let data = this.rawData;
+        let EPSILON = 0.000001;
+        let v = Vector3.ZERO;
+        toDirection.crossProduct(fromDirection, v);
+        let e = toDirection.dotProduct(fromDirection);
+        if (e > 1.0 - EPSILON) {
+            this.identity();
+        }
+        else if (e < -1.0 + EPSILON) {
+            let up = Vector3.HELP_1;
+            let left = Vector3.HELP_2; //
+            let invLen = 0;
+            let fxx;
+            let fyy;
+            let fzz;
+            let fxy;
+            let fxz;
+            let fyz;
+            let uxx;
+            let uyy;
+            let uzz;
+            let uxy;
+            let uxz;
+            let uyz;
+            let lxx;
+            let lyy;
+            let lzz;
+            let lxy;
+            let lxz;
+            let lyz;
+            left.x = 0.0;
+            left.y = fromDirection.z;
+            left.z = -fromDirection.y;
+            if (left.dotProduct(left) < EPSILON) {
+                left.x = -fromDirection.z;
+                left.y = 0.0;
+                left.z = fromDirection.x;
+            }
+            /* normalize "left" */
+            invLen = 1.0 / Math.sqrt(left.dotProduct(left));
+            left.x *= invLen;
+            left.y *= invLen;
+            left.z *= invLen;
+            left.crossProduct(fromDirection, up);
+            fxx = -fromDirection.x * fromDirection.x;
+            fyy = -fromDirection.y * fromDirection.y;
+            fzz = -fromDirection.z * fromDirection.z;
+            fxy = -fromDirection.x * fromDirection.y;
+            fxz = -fromDirection.x * fromDirection.z;
+            fyz = -fromDirection.y * fromDirection.z;
+            uxx = up.x * up.x;
+            uyy = up.y * up.y;
+            uzz = up.z * up.z;
+            uxy = up.x * up.y;
+            uxz = up.x * up.z;
+            uyz = up.y * up.z;
+            lxx = -left.x * left.x;
+            lyy = -left.y * left.y;
+            lzz = -left.z * left.z;
+            lxy = -left.x * left.y;
+            lxz = -left.x * left.z;
+            lyz = -left.y * left.z;
+            data[0] = fxx + uxx + lxx;
+            data[1] = fxy + uxy + lxy;
+            data[2] = fxz + uxz + lxz;
+            data[4] = data[1];
+            data[5] = fyy + uyy + lyy;
+            data[6] = fyz + uyz + lyz;
+            data[8] = data[2];
+            data[9] = data[6];
+            data[10] = fzz + uzz + lzz;
+            data[3] = 0;
+            data[7] = 0;
+            data[11] = 0;
+            data[15] = 1;
+        }
+        else {
+            let hvx;
+            let hvz;
+            let hvxy;
+            let hvxz;
+            let hvyz;
+            let v2 = v.dotProduct(v);
+            let h = (1.0 - e) / v2;
+            hvx = h * v.x;
+            hvz = h * v.z;
+            hvxy = hvx * v.y;
+            hvxz = hvx * v.z;
+            hvyz = hvz * v.y;
+            data[0] = e + hvx * v.x;
+            data[1] = hvxy - v.z;
+            data[2] = hvxz + v.y;
+            data[4] = hvxy + v.z;
+            data[5] = e + h * v.y * v.y;
+            data[6] = hvyz - v.x;
+            data[8] = hvxz - v.y;
+            data[9] = hvyz + v.x;
+            data[10] = e + hvz * v.z;
+            data[3] = 0;
+            data[7] = 0;
+            data[11] = 0;
+            data[15] = 1;
+        }
+        return this;
+    }
+    /**
+     * multiply matrix a b
+     * @param lhs target matrix
+     */
+    append(lhs) {
+        let data = this.rawData;
+        let m111 = data[0];
+        let m121 = data[4];
+        let m131 = data[8];
+        let m141 = data[12];
+        let m112 = data[1];
+        let m122 = data[5];
+        let m132 = data[9];
+        let m142 = data[13];
+        let m113 = data[2];
+        let m123 = data[6];
+        let m133 = data[10];
+        let m143 = data[14];
+        let m114 = data[3];
+        let m124 = data[7];
+        let m134 = data[11];
+        let m144 = data[15];
+        data[0] =
+            m111 * lhs.rawData[0] +
+                m112 * lhs.rawData[4] +
+                m113 * lhs.rawData[8] +
+                m114 * lhs.rawData[12];
+        data[1] =
+            m111 * lhs.rawData[1] +
+                m112 * lhs.rawData[5] +
+                m113 * lhs.rawData[9] +
+                m114 * lhs.rawData[13];
+        data[2] =
+            m111 * lhs.rawData[2] +
+                m112 * lhs.rawData[6] +
+                m113 * lhs.rawData[10] +
+                m114 * lhs.rawData[14];
+        data[3] =
+            m111 * lhs.rawData[3] +
+                m112 * lhs.rawData[7] +
+                m113 * lhs.rawData[11] +
+                m114 * lhs.rawData[15];
+        data[4] =
+            m121 * lhs.rawData[0] +
+                m122 * lhs.rawData[4] +
+                m123 * lhs.rawData[8] +
+                m124 * lhs.rawData[12];
+        data[5] =
+            m121 * lhs.rawData[1] +
+                m122 * lhs.rawData[5] +
+                m123 * lhs.rawData[9] +
+                m124 * lhs.rawData[13];
+        data[6] =
+            m121 * lhs.rawData[2] +
+                m122 * lhs.rawData[6] +
+                m123 * lhs.rawData[10] +
+                m124 * lhs.rawData[14];
+        data[7] =
+            m121 * lhs.rawData[3] +
+                m122 * lhs.rawData[7] +
+                m123 * lhs.rawData[11] +
+                m124 * lhs.rawData[15];
+        data[8] =
+            m131 * lhs.rawData[0] +
+                m132 * lhs.rawData[4] +
+                m133 * lhs.rawData[8] +
+                m134 * lhs.rawData[12];
+        data[9] =
+            m131 * lhs.rawData[1] +
+                m132 * lhs.rawData[5] +
+                m133 * lhs.rawData[9] +
+                m134 * lhs.rawData[13];
+        data[10] =
+            m131 * lhs.rawData[2] +
+                m132 * lhs.rawData[6] +
+                m133 * lhs.rawData[10] +
+                m134 * lhs.rawData[14];
+        data[11] =
+            m131 * lhs.rawData[3] +
+                m132 * lhs.rawData[7] +
+                m133 * lhs.rawData[11] +
+                m134 * lhs.rawData[15];
+        data[12] =
+            m141 * lhs.rawData[0] +
+                m142 * lhs.rawData[4] +
+                m143 * lhs.rawData[8] +
+                m144 * lhs.rawData[12];
+        data[13] =
+            m141 * lhs.rawData[1] +
+                m142 * lhs.rawData[5] +
+                m143 * lhs.rawData[9] +
+                m144 * lhs.rawData[13];
+        data[14] =
+            m141 * lhs.rawData[2] +
+                m142 * lhs.rawData[6] +
+                m143 * lhs.rawData[10] +
+                m144 * lhs.rawData[14];
+        data[15] =
+            m141 * lhs.rawData[3] +
+                m142 * lhs.rawData[7] +
+                m143 * lhs.rawData[11] +
+                m144 * lhs.rawData[15];
+    }
+    /**
+     * matrix a add matrix b
+     * @param lhs target matrix.
+     * @returns Matrix4 result.
+     */
+    add(lhs) {
+        let data = this.rawData;
+        let m111 = data[0];
+        let m121 = data[4];
+        let m131 = data[8];
+        let m141 = data[12];
+        let m112 = data[1];
+        let m122 = data[5];
+        let m132 = data[9];
+        let m142 = data[13];
+        let m113 = data[2];
+        let m123 = data[6];
+        let m133 = data[10];
+        let m143 = data[14];
+        let m114 = data[3];
+        let m124 = data[7];
+        let m134 = data[11];
+        let m144 = data[15];
+        let m211 = lhs.rawData[0];
+        let m221 = lhs.rawData[4];
+        let m231 = lhs.rawData[8];
+        let m241 = lhs.rawData[12];
+        let m212 = lhs.rawData[1];
+        let m222 = lhs.rawData[5];
+        let m232 = lhs.rawData[9];
+        let m242 = lhs.rawData[13];
+        let m213 = lhs.rawData[2];
+        let m223 = lhs.rawData[6];
+        let m233 = lhs.rawData[10];
+        let m243 = lhs.rawData[14];
+        let m214 = lhs.rawData[3];
+        let m224 = lhs.rawData[7];
+        let m234 = lhs.rawData[11];
+        let m244 = lhs.rawData[15];
+        data[0] = m111 + m211;
+        data[1] = m112 + m212;
+        data[2] = m113 + m213;
+        data[3] = m114 + m214;
+        data[4] = m121 + m221;
+        data[5] = m122 + m222;
+        data[6] = m123 + m223;
+        data[7] = m124 + m224;
+        data[8] = m131 + m231;
+        data[9] = m132 + m232;
+        data[10] = m133 + m233;
+        data[11] = m134 + m234;
+        data[12] = m141 + m241;
+        data[13] = m142 + m242;
+        data[14] = m143 + m243;
+        data[15] = m144 + m244;
+        return this;
+    }
+    /**
+     * matrix a sub matrix b
+     * @param lhs target matrix b.
+     * @returns Matrix4 .
+     */
+    sub(lhs) {
+        let data = this.rawData;
+        let m111 = data[0];
+        let m121 = data[4];
+        let m131 = data[8];
+        let m141 = data[12];
+        let m112 = data[1];
+        let m122 = data[5];
+        let m132 = data[9];
+        let m142 = data[13];
+        let m113 = data[2];
+        let m123 = data[6];
+        let m133 = data[10];
+        let m143 = data[14];
+        let m114 = data[3];
+        let m124 = data[7];
+        let m134 = data[11];
+        let m144 = data[15];
+        let m211 = lhs.rawData[0];
+        let m221 = lhs.rawData[4];
+        let m231 = lhs.rawData[8];
+        let m241 = lhs.rawData[12];
+        let m212 = lhs.rawData[1];
+        let m222 = lhs.rawData[5];
+        let m232 = lhs.rawData[9];
+        let m242 = lhs.rawData[13];
+        let m213 = lhs.rawData[2];
+        let m223 = lhs.rawData[6];
+        let m233 = lhs.rawData[10];
+        let m243 = lhs.rawData[14];
+        let m214 = lhs.rawData[3];
+        let m224 = lhs.rawData[7];
+        let m234 = lhs.rawData[11];
+        let m244 = lhs.rawData[15];
+        data[0] = m111 - m211;
+        data[1] = m112 - m212;
+        data[2] = m113 - m213;
+        data[3] = m114 - m214;
+        data[4] = m121 - m221;
+        data[5] = m122 - m222;
+        data[6] = m123 - m223;
+        data[7] = m124 - m224;
+        data[8] = m131 - m231;
+        data[9] = m132 - m232;
+        data[10] = m133 - m233;
+        data[11] = m134 - m234;
+        data[12] = m141 - m241;
+        data[13] = m142 - m242;
+        data[14] = m143 - m243;
+        data[15] = m144 - m244;
+        return this;
+    }
+    /**
+     * Matrix times components.
+     * @param v This matrix is going to be multiplied by this value
+     * @returns Matrix4 Returns a multiplicative result matrix.
+     */
+    mult(v) {
+        let data = this.rawData;
+        data[0] *= v;
+        data[1] *= v;
+        data[2] *= v;
+        data[3] *= v;
+        data[4] *= v;
+        data[5] *= v;
+        data[6] *= v;
+        data[7] *= v;
+        data[8] *= v;
+        data[9] *= v;
+        data[10] *= v;
+        data[11] *= v;
+        data[12] *= v;
+        data[13] *= v;
+        data[14] *= v;
+        data[15] *= v;
+        return this;
+    }
+    appendRotation(degrees, axis) {
+        let m = Matrix4.getAxisRotation(axis.x, axis.y, axis.z, degrees);
+        this.append(m);
+    }
+    /**
+     * Create a matrix based on the axis and rotation Angle (the matrix created by rotating the degrees according to the axis)
+     * @param degrees Angle of rotation.
+     * @param axis Rotation Angle around axis axis. Axis needs to be specified as the orientation of an axis between x/y/z
+     */
+    createByRotation(degrees, axis) {
+        let tmp = Matrix4.helpMatrix;
+        let s;
+        let c;
+        let angle = degrees * DEGREES_TO_RADIANS;
+        s = Math.sin(angle);
+        c = Math.cos(angle);
+        if (axis.x == 1) {
+            tmp.rawData[0] = 1.0;
+            tmp.rawData[1] = 0.0;
+            tmp.rawData[2] = 0.0;
+            tmp.rawData[3] = 0.0;
+            tmp.rawData[4] = 0.0;
+            tmp.rawData[5] = c;
+            tmp.rawData[6] = s;
+            tmp.rawData[7] = 0.0;
+            tmp.rawData[8] = 0.0;
+            tmp.rawData[9] = -s;
+            tmp.rawData[10] = c;
+            tmp.rawData[11] = 0.0;
+            tmp.rawData[12] = 0.0;
+            tmp.rawData[13] = 0.0;
+            tmp.rawData[14] = 0.0;
+            tmp.rawData[15] = 1.0;
+        }
+        if (axis.y == 1) {
+            tmp.rawData[0] = c;
+            tmp.rawData[1] = 0.0;
+            tmp.rawData[2] = -s;
+            tmp.rawData[3] = 0.0;
+            tmp.rawData[4] = 0.0;
+            tmp.rawData[5] = 1.0;
+            tmp.rawData[6] = 0.0;
+            tmp.rawData[7] = 0.0;
+            tmp.rawData[8] = s;
+            tmp.rawData[9] = 0.0;
+            tmp.rawData[10] = c;
+            tmp.rawData[11] = 0.0;
+            tmp.rawData[12] = 0.0;
+            tmp.rawData[13] = 0.0;
+            tmp.rawData[14] = 0.0;
+            tmp.rawData[15] = 1.0;
+        }
+        if (axis.z == 1) {
+            tmp.rawData[0] = c;
+            tmp.rawData[1] = s;
+            tmp.rawData[2] = 0.0;
+            tmp.rawData[3] = 0.0;
+            tmp.rawData[4] = -s;
+            tmp.rawData[5] = c;
+            tmp.rawData[6] = 0.0;
+            tmp.rawData[7] = 0.0;
+            tmp.rawData[8] = 0.0;
+            tmp.rawData[9] = 0.0;
+            tmp.rawData[10] = 1.0;
+            tmp.rawData[11] = 0.0;
+            tmp.rawData[12] = 0.0;
+            tmp.rawData[13] = 0.0;
+            tmp.rawData[14] = 0.0;
+            tmp.rawData[15] = 1.0;
+        }
+        this.append(tmp);
+        return this;
+    }
+    /**
+     * Append the triaxial scaling value
+     * @param xScale x axis scaling
+     * @param yScale y axis scaling
+     * @param zScale z axis scaling
+     */
+    appendScale(xScale, yScale, zScale) {
+        Matrix4.helpMatrix.createByScale(xScale, yScale, zScale);
+        this.append(Matrix4.helpMatrix);
+    }
+    /**
+     * A scaling matrix is generated and other properties are reset
+     * @param xScale x axis scaling
+     * @param yScale y axis scaling
+     * @param zScale z axis scaling
+     */
+    createByScale(xScale, yScale, zScale) {
+        let data = this.rawData;
+        data[0] = xScale;
+        data[1] = 0.0;
+        data[2] = 0.0;
+        data[3] = 0.0;
+        data[4] = 0.0;
+        data[5] = yScale;
+        data[6] = 0.0;
+        data[7] = 0.0;
+        data[8] = 0.0;
+        data[9] = 0.0;
+        data[10] = zScale;
+        data[11] = 0.0;
+        data[12] = 0.0;
+        data[13] = 0.0;
+        data[14] = 0.0;
+        data[15] = 1.0;
+    }
+    /**
+     * Plus a translation matrix
+     * @param x x axis scaling
+     * @param y y axis scaling
+     * @param z z axis scaling
+     */
+    appendTranslation(x, y, z) {
+        let data = this.rawData;
+        data[12] += x;
+        data[13] += y;
+        data[14] += z;
+    }
+    /**
+     * Returns a clone of the current matrix
+     * @returns Matrix4 The cloned matrix
+     */
+    clone() {
+        let ret = new Matrix4();
+        ret.copyFrom(this);
+        return ret;
+    }
+    /**
+     * Assigns a value to one row of the current matrix
+     * @param row Row of copy
+     * @param Vector3 Value of copy
+     */
+    copyRowFrom(row, Vector3) {
+        let data = this.rawData;
+        switch (row) {
+            case 0:
+                data[0] = Vector3.x;
+                data[1] = Vector3.y;
+                data[2] = Vector3.z;
+                data[3] = Vector3.w;
+                break;
+            case 1:
+                data[4] = Vector3.x;
+                data[5] = Vector3.y;
+                data[6] = Vector3.z;
+                data[7] = Vector3.w;
+                break;
+            case 2:
+                data[8] = Vector3.x;
+                data[9] = Vector3.y;
+                data[10] = Vector3.z;
+                data[11] = Vector3.w;
+                break;
+            case 3:
+                data[12] = Vector3.x;
+                data[13] = Vector3.y;
+                data[14] = Vector3.z;
+                data[15] = Vector3.w;
+                break;
+            default:
+            ///throw new ArgumentError("ArgumentError, Column " + column + " out of bounds [0, ..., 3]");
+        }
+    }
+    /**
+     * One of the rows in the copy matrix stores the values in Vector3.
+     * @param row Row of copy
+     * @param Vector3 Copy the storage target
+     */
+    copyRowTo(row, Vector3) {
+        let data = this.rawData;
+        switch (row) {
+            case 0:
+                Vector3.x = data[0];
+                Vector3.y = data[1];
+                Vector3.z = data[2];
+                Vector3.w = data[3];
+                break;
+            case 1:
+                Vector3.x = data[4];
+                Vector3.y = data[5];
+                Vector3.z = data[6];
+                Vector3.w = data[7];
+                break;
+            case 2:
+                Vector3.x = data[8];
+                Vector3.y = data[9];
+                Vector3.z = data[10];
+                Vector3.w = data[11];
+                break;
+            case 3:
+                Vector3.x = data[12];
+                Vector3.y = data[13];
+                Vector3.z = data[14];
+                Vector3.w = data[15];
+                break;
+            default:
+            /// throw new ArgumentError("ArgumentError, Column " + column + " out of bounds [0, ..., 3]");
+        }
+    }
+    /**
+     * Assigns the value of a matrix to the current matrix.
+     * @param sourceMatrix3D source Matrix
+     * @returns Returns the current matrix
+     */
+    copyFrom(sourceMatrix3D) {
+        let data = this.rawData;
+        data[0] = sourceMatrix3D.rawData[0];
+        data[1] = sourceMatrix3D.rawData[1];
+        data[2] = sourceMatrix3D.rawData[2];
+        data[3] = sourceMatrix3D.rawData[3];
+        data[4] = sourceMatrix3D.rawData[4];
+        data[5] = sourceMatrix3D.rawData[5];
+        data[6] = sourceMatrix3D.rawData[6];
+        data[7] = sourceMatrix3D.rawData[7];
+        data[8] = sourceMatrix3D.rawData[8];
+        data[9] = sourceMatrix3D.rawData[9];
+        data[10] = sourceMatrix3D.rawData[10];
+        data[11] = sourceMatrix3D.rawData[11];
+        data[12] = sourceMatrix3D.rawData[12];
+        data[13] = sourceMatrix3D.rawData[13];
+        data[14] = sourceMatrix3D.rawData[14];
+        data[15] = sourceMatrix3D.rawData[15];
+        return this;
+    }
+    /**
+     * CoMath.PIes the value of the current matrix to a float array.
+     * @param vector The target array.
+     * @param index copy from the index of the array.
+     * @param transpose Whether to transpose the current matrix.
+     */
+    copyRawDataTo(vector, index = 0, transpose = false) {
+        let data = this.rawData;
+        vector[0 + index] = data[0];
+        vector[1 + index] = data[1];
+        vector[2 + index] = data[2];
+        vector[3 + index] = data[3];
+        vector[4 + index] = data[4];
+        vector[5 + index] = data[5];
+        vector[6 + index] = data[6];
+        vector[7 + index] = data[7];
+        vector[8 + index] = data[8];
+        vector[9 + index] = data[9];
+        vector[10 + index] = data[10];
+        vector[11 + index] = data[11];
+        vector[12 + index] = data[12];
+        vector[13 + index] = data[13];
+        vector[14 + index] = data[14];
+        vector[15 + index] = data[15];
+    }
+    /**
+     * Assigns a value to a column of the current matrix
+     * @param col column
+     * @param Vector3 Source of value
+     */
+    copyColFrom(col, Vector3) {
+        let data = this.rawData;
+        switch (col) {
+            case 0:
+                data[0] = Vector3.x;
+                data[4] = Vector3.y;
+                data[8] = Vector3.z;
+                data[12] = Vector3.w;
+                break;
+            case 1:
+                data[1] = Vector3.x;
+                data[5] = Vector3.y;
+                data[9] = Vector3.z;
+                data[13] = Vector3.w;
+                break;
+            case 2:
+                data[2] = Vector3.x;
+                data[6] = Vector3.y;
+                data[10] = Vector3.z;
+                data[14] = Vector3.w;
+                break;
+            case 3:
+                data[3] = Vector3.x;
+                data[7] = Vector3.y;
+                data[11] = Vector3.z;
+                data[15] = Vector3.w;
+                break;
+            default:
+                new Error("no more raw!");
+        }
+    }
+    /**
+     * Copy a column of the current matrix
+     * @param col column
+     * @param Vector3 Target of copy
+     */
+    copyColTo(col, Vector3) {
+        let data = this.rawData;
+        switch (col) {
+            case 0:
+                Vector3.x = data[0];
+                Vector3.y = data[4];
+                Vector3.z = data[8];
+                Vector3.w = data[12];
+                break;
+            case 1:
+                Vector3.x = data[1];
+                Vector3.y = data[5];
+                Vector3.z = data[9];
+                Vector3.w = data[13];
+                break;
+            case 2:
+                Vector3.x = data[2];
+                Vector3.y = data[6];
+                Vector3.z = data[10];
+                Vector3.w = data[14];
+                break;
+            case 3:
+                Vector3.x = data[3];
+                Vector3.y = data[7];
+                Vector3.z = data[11];
+                Vector3.w = data[15];
+                break;
+            default:
+                new Error("no more raw!");
+        }
+    }
+    /**
+     * Copy the current matrix
+     * @param dest Target of copy
+     */
+    copyToMatrix3D(dest) {
+        dest.rawData = this.rawData.slice(0);
+    }
+    /**
+     * Calculate rotation matrix
+     * @param quaternion Rotate the quaternion
+     * @returns
+     */
+    makeRotationFromQuaternion(quaternion) {
+        this.compose(Matrix4._zero, quaternion, Matrix4._one);
+        return this;
+    }
+    static { this.decomposeRawData = new Float64Array(16).fill(0); }
+    /**
+     * Decompose the current matrix
+     * @param orientationStyle The default decomposition type is Orientation3D.EULER_ANGLES
+     * @see Orientation3D.AXIS_ANGLE
+     * @see Orientation3D.EULER_ANGLES
+     * @see Orientation3D.QUATERNION
+     * @returns Vector3[3] pos rot scale
+     */
+    decompose(orientationStyle = "eulerAngles", target) {
+        let q = Quaternion.CALCULATION_QUATERNION;
+        let vec = target ? target : Matrix4._prs;
+        this.copyRawDataTo(Matrix4.decomposeRawData);
+        let mr = Matrix4.decomposeRawData;
+        let pos = vec[0];
+        pos.x = mr[12];
+        pos.y = mr[13];
+        pos.z = mr[14];
+        mr[12] = 0;
+        mr[13] = 0;
+        mr[14] = 0;
+        let scale = vec[2];
+        scale.x = Math.sqrt(mr[0] * mr[0] + mr[1] * mr[1] + mr[2] * mr[2]);
+        scale.y = Math.sqrt(mr[4] * mr[4] + mr[5] * mr[5] + mr[6] * mr[6]);
+        scale.z = Math.sqrt(mr[8] * mr[8] + mr[9] * mr[9] + mr[10] * mr[10]);
+        if (mr[0] * (mr[5] * mr[10] - mr[6] * mr[9]) -
+            mr[1] * (mr[4] * mr[10] - mr[6] * mr[8]) +
+            mr[2] * (mr[4] * mr[9] - mr[5] * mr[8]) <
+            0) {
+            scale.z = -scale.z;
+        }
+        mr[0] /= scale.x;
+        mr[1] /= scale.x;
+        mr[2] /= scale.x;
+        mr[4] /= scale.y;
+        mr[5] /= scale.y;
+        mr[6] /= scale.y;
+        mr[8] /= scale.z;
+        mr[9] /= scale.z;
+        mr[10] /= scale.z;
+        let rot = vec[1];
+        let tr;
+        switch (orientationStyle) {
+            case Orientation3D.AXIS_ANGLE:
+                rot.w = Math.acos((mr[0] + mr[5] + mr[10] - 1) / 2);
+                let len = Math.sqrt((mr[6] - mr[9]) * (mr[6] - mr[9]) +
+                    (mr[8] - mr[2]) * (mr[8] - mr[2]) +
+                    (mr[1] - mr[4]) * (mr[1] - mr[4]));
+                rot.x = (mr[6] - mr[9]) / len;
+                rot.y = (mr[8] - mr[2]) / len;
+                rot.z = (mr[1] - mr[4]) / len;
+                break;
+            case Orientation3D.QUATERNION:
+                tr = mr[0] + mr[5] + mr[10];
+                if (tr > 0) {
+                    rot.w = Math.sqrt(1 + tr) / 2;
+                    rot.x = (mr[6] - mr[9]) / (4 * rot.w);
+                    rot.y = (mr[8] - mr[2]) / (4 * rot.w);
+                    rot.z = (mr[1] - mr[4]) / (4 * rot.w);
+                }
+                else if (mr[0] > mr[5] && mr[0] > mr[10]) {
+                    rot.x = Math.sqrt(1 + mr[0] - mr[5] - mr[10]) / 2;
+                    rot.w = (mr[6] - mr[9]) / (4 * rot.x);
+                    rot.y = (mr[1] + mr[4]) / (4 * rot.x);
+                    rot.z = (mr[8] + mr[2]) / (4 * rot.x);
+                }
+                else if (mr[5] > mr[10]) {
+                    rot.y = Math.sqrt(1 + mr[5] - mr[0] - mr[10]) / 2;
+                    rot.x = (mr[1] + mr[4]) / (4 * rot.y);
+                    rot.w = (mr[8] - mr[2]) / (4 * rot.y);
+                    rot.z = (mr[6] + mr[9]) / (4 * rot.y);
+                }
+                else {
+                    rot.z = Math.sqrt(1 + mr[10] - mr[0] - mr[5]) / 2;
+                    rot.x = (mr[8] + mr[2]) / (4 * rot.z);
+                    rot.y = (mr[6] + mr[9]) / (4 * rot.z);
+                    rot.w = (mr[1] - mr[4]) / (4 * rot.z);
+                }
+                break;
+            case Orientation3D.EULER_ANGLES:
+                tr = mr[0] + mr[5] + mr[10];
+                if (tr > 0) {
+                    q.w = Math.sqrt(1 + tr) / 2;
+                    q.x = (mr[6] - mr[9]) / (4 * q.w);
+                    q.y = (mr[8] - mr[2]) / (4 * q.w);
+                    q.z = (mr[1] - mr[4]) / (4 * q.w);
+                }
+                else if (mr[0] > mr[5] && mr[0] > mr[10]) {
+                    q.x = Math.sqrt(1 + mr[0] - mr[5] - mr[10]) / 2;
+                    q.w = (mr[6] - mr[9]) / (4 * q.x);
+                    q.y = (mr[1] + mr[4]) / (4 * q.x);
+                    q.z = (mr[8] + mr[2]) / (4 * q.x);
+                }
+                else if (mr[5] > mr[10]) {
+                    rot.y = Math.sqrt(1 + mr[5] - mr[0] - mr[10]) / 2;
+                    q.x = (mr[1] + mr[4]) / (4 * q.y);
+                    q.w = (mr[8] - mr[2]) / (4 * q.y);
+                    q.z = (mr[6] + mr[9]) / (4 * q.y);
+                }
+                else {
+                    q.z = Math.sqrt(1 + mr[10] - mr[0] - mr[5]) / 2;
+                    q.x = (mr[8] + mr[2]) / (4 * q.z);
+                    q.y = (mr[6] + mr[9]) / (4 * q.z);
+                    q.w = (mr[1] - mr[4]) / (4 * q.z);
+                }
+                q.getEulerAngles(rot);
+                break;
+        }
+        vec[0] = pos;
+        vec[1] = rot;
+        vec[2] = scale;
+        return vec;
+    }
+    /**
+     * Get the Euler vector
+     * @param target Vector of results
+     * @param quaternion Rotate the quaternion
+     * @param isDegree Whether to convert to Angle
+     * @param order convert order
+     * @returns
+     */
+    static getEuler(target, quaternion, isDegree = true, order) {
+        target ||= new Vector3();
+        Matrix4._getEulerMatrix
+            .makeRotationFromQuaternion(quaternion)
+            .makeEuler(target, isDegree, order);
+        return target;
+    }
+    /**
+     * Calculate the combined matrix of displacement, rotation and scaling
+     * @param position translation
+     * @param quaternion rotation
+     * @param scale scale
+     * @returns
+     */
+    compose(position, quaternion, scale) {
+        const te = this.rawData;
+        const x = quaternion.x;
+        const y = quaternion.y;
+        const z = quaternion.z;
+        const w = quaternion.w;
+        const x2 = x + x;
+        const y2 = y + y;
+        const z2 = z + z;
+        const xx = x * x2;
+        const xy = x * y2;
+        const xz = x * z2;
+        const yy = y * y2;
+        const yz = y * z2;
+        const zz = z * z2;
+        const wx = w * x2;
+        const wy = w * y2;
+        const wz = w * z2;
+        const sx = scale.x;
+        const sy = scale.y;
+        const sz = scale.z;
+        te[0] = (1 - (yy + zz)) * sx;
+        te[1] = (xy + wz) * sx;
+        te[2] = (xz - wy) * sx;
+        te[3] = 0;
+        te[4] = (xy - wz) * sy;
+        te[5] = (1 - (xx + zz)) * sy;
+        te[6] = (yz + wx) * sy;
+        te[7] = 0;
+        te[8] = (xz + wy) * sz;
+        te[9] = (yz - wx) * sz;
+        te[10] = (1 - (xx + yy)) * sz;
+        te[11] = 0;
+        te[12] = position.x;
+        te[13] = position.y;
+        te[14] = position.z;
+        te[15] = 1;
+        return this;
+    }
+    /**
+     * The current matrix transforms a vector
+     * @param v Vector to transform
+     * @param target The default is null and if the current argument is null then a new Vector3 will be returned
+     * @returns Vector3 The transformed vector
+     */
+    deltaTransformVector(v, target) {
+        target ||= new Vector3();
+        let data = this.rawData;
+        let x = v.x;
+        let y = v.y;
+        let z = v.z;
+        target.x = x * data[0] + y * data[4] + z * data[8];
+        target.y = x * data[1] + y * data[5] + z * data[9];
+        target.z = x * data[2] + y * data[6] + z * data[10];
+        target.w = x * data[3] + y * data[7] + z * data[11];
+        return target;
+    }
+    /**
+     * Unifies the current matrix
+     */
+    identity() {
+        let data = this.rawData;
+        //1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1
+        data[0] = 1;
+        data[1] = 0;
+        data[2] = 0;
+        data[3] = 0;
+        data[4] = 0;
+        data[5] = 1;
+        data[6] = 0;
+        data[7] = 0;
+        data[8] = 0;
+        data[9] = 0;
+        data[10] = 1;
+        data[11] = 0;
+        data[12] = 0;
+        data[13] = 0;
+        data[14] = 0;
+        data[15] = 1;
+        return this;
+    }
+    /**
+     * Fill the current matrix
+     * @param value The filled value
+     */
+    fill(value) {
+        let data = this.rawData;
+        data[1] = value;
+        data[2] = value;
+        data[3] = value;
+        data[4] = value;
+        data[6] = value;
+        data[7] = value;
+        data[8] = value;
+        data[9] = value;
+        data[11] = value;
+        data[12] = value;
+        data[13] = value;
+        data[14] = value;
+        data[0] = value;
+        data[5] = value;
+        data[10] = value;
+        data[15] = value;
+    }
+    /**
+     * Invert the current matrix
+     */
+    invers33() {
+        /// Invert a 3x3 using cofactors.  This is about 8 times faster than
+        /// the Numerical Recipes code which uses Gaussian elimination.
+        let data = this.rawData;
+        let rkInverse_00 = data[5] * data[10] - data[9] * data[6];
+        let rkInverse_01 = data[8] * data[6] - data[4] * data[10];
+        let rkInverse_02 = data[4] * data[9] - data[8] * data[5];
+        let rkInverse_10 = data[9] * data[2] - data[1] * data[10];
+        let rkInverse_11 = data[0] * data[10] - data[8] * data[2];
+        let rkInverse_12 = data[8] * data[1] - data[0] * data[9];
+        let rkInverse_20 = data[1] * data[6] - data[5] * data[2];
+        let rkInverse_21 = data[4] * data[2] - data[0] * data[6];
+        let rkInverse_22 = data[0] * data[5] - data[4] * data[1];
+        let fDet = data[0] * rkInverse_00 + data[4] * rkInverse_10 + data[8] * rkInverse_20;
+        if (Math.abs(fDet) > 0.00000000001) {
+            let fInvDet = 1.0 / fDet;
+            data[0] = fInvDet * rkInverse_00;
+            data[4] = fInvDet * rkInverse_01;
+            data[8] = fInvDet * rkInverse_02;
+            data[1] = fInvDet * rkInverse_10;
+            data[5] = fInvDet * rkInverse_11;
+            data[9] = fInvDet * rkInverse_12;
+            data[2] = fInvDet * rkInverse_20;
+            data[6] = fInvDet * rkInverse_21;
+            data[10] = fInvDet * rkInverse_22;
+        }
+    }
+    /**
+     * Invert the current matrix
+     * @returns boolean Whether can invert it
+     */
+    invert() {
+        let d = this.determinant;
+        let invertable = Math.abs(d) > 0.00000000001;
+        let data = this.rawData;
+        if (invertable) {
+            d = 1 / d;
+            let m11 = data[0];
+            let m21 = data[4];
+            let m31 = data[8];
+            let m41 = data[12];
+            let m12 = data[1];
+            let m22 = data[5];
+            let m32 = data[9];
+            let m42 = data[13];
+            let m13 = data[2];
+            let m23 = data[6];
+            let m33 = data[10];
+            let m43 = data[14];
+            let m14 = data[3];
+            let m24 = data[7];
+            let m34 = data[11];
+            let m44 = data[15];
+            data[0] =
+                d *
+                    (m22 * (m33 * m44 - m43 * m34) -
+                        m32 * (m23 * m44 - m43 * m24) +
+                        m42 * (m23 * m34 - m33 * m24));
+            data[1] =
+                -d *
+                    (m12 * (m33 * m44 - m43 * m34) -
+                        m32 * (m13 * m44 - m43 * m14) +
+                        m42 * (m13 * m34 - m33 * m14));
+            data[2] =
+                d *
+                    (m12 * (m23 * m44 - m43 * m24) -
+                        m22 * (m13 * m44 - m43 * m14) +
+                        m42 * (m13 * m24 - m23 * m14));
+            data[3] =
+                -d *
+                    (m12 * (m23 * m34 - m33 * m24) -
+                        m22 * (m13 * m34 - m33 * m14) +
+                        m32 * (m13 * m24 - m23 * m14));
+            data[4] =
+                -d *
+                    (m21 * (m33 * m44 - m43 * m34) -
+                        m31 * (m23 * m44 - m43 * m24) +
+                        m41 * (m23 * m34 - m33 * m24));
+            data[5] =
+                d *
+                    (m11 * (m33 * m44 - m43 * m34) -
+                        m31 * (m13 * m44 - m43 * m14) +
+                        m41 * (m13 * m34 - m33 * m14));
+            data[6] =
+                -d *
+                    (m11 * (m23 * m44 - m43 * m24) -
+                        m21 * (m13 * m44 - m43 * m14) +
+                        m41 * (m13 * m24 - m23 * m14));
+            data[7] =
+                d *
+                    (m11 * (m23 * m34 - m33 * m24) -
+                        m21 * (m13 * m34 - m33 * m14) +
+                        m31 * (m13 * m24 - m23 * m14));
+            data[8] =
+                d *
+                    (m21 * (m32 * m44 - m42 * m34) -
+                        m31 * (m22 * m44 - m42 * m24) +
+                        m41 * (m22 * m34 - m32 * m24));
+            data[9] =
+                -d *
+                    (m11 * (m32 * m44 - m42 * m34) -
+                        m31 * (m12 * m44 - m42 * m14) +
+                        m41 * (m12 * m34 - m32 * m14));
+            data[10] =
+                d *
+                    (m11 * (m22 * m44 - m42 * m24) -
+                        m21 * (m12 * m44 - m42 * m14) +
+                        m41 * (m12 * m24 - m22 * m14));
+            data[11] =
+                -d *
+                    (m11 * (m22 * m34 - m32 * m24) -
+                        m21 * (m12 * m34 - m32 * m14) +
+                        m31 * (m12 * m24 - m22 * m14));
+            data[12] =
+                -d *
+                    (m21 * (m32 * m43 - m42 * m33) -
+                        m31 * (m22 * m43 - m42 * m23) +
+                        m41 * (m22 * m33 - m32 * m23));
+            data[13] =
+                d *
+                    (m11 * (m32 * m43 - m42 * m33) -
+                        m31 * (m12 * m43 - m42 * m13) +
+                        m41 * (m12 * m33 - m32 * m13));
+            data[14] =
+                -d *
+                    (m11 * (m22 * m43 - m42 * m23) -
+                        m21 * (m12 * m43 - m42 * m13) +
+                        m41 * (m12 * m23 - m22 * m13));
+            data[15] =
+                d *
+                    (m11 * (m22 * m33 - m32 * m23) -
+                        m21 * (m12 * m33 - m32 * m13) +
+                        m31 * (m12 * m23 - m22 * m13));
+        }
+        return invertable;
+    }
+    /**
+     * Converts the current coordinates to the world coordinates
+     * @param v Current coordinates
+     * @param target world coordinate
+     * @returns world coordinate
+     */
+    transformPoint(v, target) {
+        let data = this.rawData;
+        target ||= new Vector3();
+        let x = v.x;
+        let y = v.y;
+        let z = v.z;
+        target.x = x * data[0] + y * data[4] + z * data[8] + data[12];
+        target.y = x * data[1] + y * data[5] + z * data[9] + data[13];
+        target.z = x * data[2] + y * data[6] + z * data[10] + data[14];
+        return target;
+    }
+    /**
+     * Transforming a 3D vector with the current matrix does not deal with displacement
+     * @param v Vector of transformation
+     * @param target If the current argument is null then a new Vector3 will be returned
+     * @returns Vector3 The transformed vector
+     */
+    transformVector(v, target) {
+        let data = this.rawData;
+        target ||= new Vector3();
+        let x = v.x;
+        let y = v.y;
+        let z = v.z;
+        target.x = x * data[0] + y * data[4] + z * data[8];
+        target.y = x * data[1] + y * data[5] + z * data[9];
+        target.z = x * data[2] + y * data[6] + z * data[10];
+        return target;
+    }
+    /**
+     * The current matrix transpose
+     */
+    transpose() {
+        let data = this.rawData;
+        for (let i = 0; i < Matrix4.helpMatrix.rawData.length; i++) {
+            Matrix4.helpMatrix.rawData[i] = data[i];
+        }
+        data[1] = Matrix4.helpMatrix.rawData[4];
+        data[2] = Matrix4.helpMatrix.rawData[8];
+        data[3] = Matrix4.helpMatrix.rawData[12];
+        data[4] = Matrix4.helpMatrix.rawData[1];
+        data[6] = Matrix4.helpMatrix.rawData[9];
+        data[7] = Matrix4.helpMatrix.rawData[13];
+        data[8] = Matrix4.helpMatrix.rawData[2];
+        data[9] = Matrix4.helpMatrix.rawData[6];
+        data[11] = Matrix4.helpMatrix.rawData[14];
+        data[12] = Matrix4.helpMatrix.rawData[3];
+        data[13] = Matrix4.helpMatrix.rawData[7];
+        data[14] = Matrix4.helpMatrix.rawData[11];
+    }
+    /**
+     * Returns the matrix determinant
+     * @returns number determinant
+     */
+    get determinant() {
+        let data = this.rawData;
+        return ((data[0] * data[5] - data[4] * data[1]) *
+            (data[10] * data[15] - data[14] * data[11]) -
+            (data[0] * data[9] - data[8] * data[1]) *
+                (data[6] * data[15] - data[14] * data[7]) +
+            (data[0] * data[13] - data[12] * data[1]) *
+                (data[6] * data[11] - data[10] * data[7]) +
+            (data[4] * data[9] - data[8] * data[5]) *
+                (data[2] * data[15] - data[14] * data[3]) -
+            (data[4] * data[13] - data[12] * data[5]) *
+                (data[2] * data[11] - data[10] * data[3]) +
+            (data[8] * data[13] - data[12] * data[9]) *
+                (data[2] * data[7] - data[6] * data[3]));
+    }
+    /**
+     * Return matrix displacement
+     * @param out Position of translation
+     * @returns Position of translation
+     */
+    getPosition(out) {
+        out ||= new Vector3();
+        let data = this.rawData;
+        out.x = data[12];
+        out.y = data[13];
+        out.z = data[14];
+        return out;
+    }
+    /**
+     * Return translation
+     * @returns Vector3 Position of translation
+     */
+    get position() {
+        this._position.set(this.rawData[12], this.rawData[13], this.rawData[14]);
+        return this._position;
+    }
+    /**
+     * Set Position of translation
+     * @param value Position of translation
+     */
+    set position(value) {
+        let data = this.rawData;
+        data[12] = value.x;
+        data[13] = value.y;
+        data[14] = value.z;
+    }
+    /**
+     * get Component of scale
+     *
+     * @returns Vector3 scale
+     */
+    get scale() {
+        let data = this.rawData;
+        return new Vector3(data[0], data[5], data[10]);
+    }
+    /**
+     * Set component of scale
+     */
+    set scale(value) {
+        let data = this.rawData;
+        data[0] = value.x;
+        data[5] = value.y;
+        data[10] = value.z;
+    }
+    // public setWorldTrans( pos:Vector3 , rotQ:Quaternion,scale:Vector3 = Vector3.SCALE){
+    //     this.makeTransform(pos,scale,rotQ);
+    // }
+    /**
+     * Returns the value of the matrix as a string
+     *
+     * @returns string
+     */
+    toString() {
+        let data = this.rawData;
+        return ("matrix3d(" +
+            Math.round(data[0] * 1000) / 1000 +
+            "," +
+            Math.round(data[1] * 1000) / 1000 +
+            "," +
+            Math.round(data[2] * 1000) / 1000 +
+            "," +
+            Math.round(data[3] * 1000) / 1000 +
+            "," +
+            Math.round(data[4] * 1000) / 1000 +
+            "," +
+            Math.round(data[5] * 1000) / 1000 +
+            "," +
+            Math.round(data[6] * 1000) / 1000 +
+            "," +
+            Math.round(data[7] * 1000) / 1000 +
+            "," +
+            Math.round(data[8] * 1000) / 1000 +
+            "," +
+            Math.round(data[9] * 1000) / 1000 +
+            "," +
+            Math.round(data[10] * 1000) / 1000 +
+            "," +
+            Math.round(data[11] * 1000) / 1000 +
+            "," +
+            Math.round(data[12] * 1000) / 1000 +
+            "," +
+            Math.round(data[13] * 1000) / 1000 +
+            "," +
+            Math.round(data[14] * 1000) / 1000 +
+            "," +
+            Math.round(data[15] * 1000) / 1000 +
+            ")");
+    }
+    /**
+     * Interpolate between two matrices
+     * @param m0 Matrix 0
+     * @param m1 Matrix 1
+     * @param t Factor of interpolation 0.0 - 1.0
+     */
+    lerp(m0, m1, t) {
+        ///t(m1 - m0) + m0
+        this.copyFrom(m1).sub(m0).mult(t).add(m0);
+    }
+    /**
+     * Read matrix element values
+     * @param row row
+     * @param column column
+     * @returns
+     */
+    get(row, column) {
+        return this.rawData[row + column * 4];
+    }
+    /**
+     * Sets the matrix element values
+     * @param row row
+     * @param column column
+     * @param v value
+     */
+    set(row, column, v) {
+        this.rawData[row + column * 4] = v;
+    }
+    /**
+     * Get the maximum value of the matrix scaled on each axis
+     */
+    getMaxScaleOnAxis() {
+        let te = this.rawData;
+        let scaleXSq = te[0] * te[0] + te[1] * te[1] + te[2] * te[2];
+        let scaleYSq = te[4] * te[4] + te[5] * te[5] + te[6] * te[6];
+        let scaleZSq = te[8] * te[8] + te[9] * te[9] + te[10] * te[10];
+        return Math.sqrt(Math.max(scaleXSq, scaleYSq, scaleZSq));
+    }
+    /**
+     * Calculate the displacement from the vector
+     * @param inTrans Vector
+     * @returns current matrix
+     */
+    translate(inTrans) {
+        // let Get = this.Get ;
+        let x = this.get(0, 0) * inTrans.x +
+            this.get(0, 1) * inTrans.y +
+            this.get(0, 2) * inTrans.z +
+            this.get(0, 3);
+        let y = this.get(1, 0) * inTrans.x +
+            this.get(1, 1) * inTrans.y +
+            this.get(1, 2) * inTrans.z +
+            this.get(1, 3);
+        let z = this.get(2, 0) * inTrans.x +
+            this.get(2, 1) * inTrans.y +
+            this.get(2, 2) * inTrans.z +
+            this.get(2, 3);
+        let w = this.get(3, 0) * inTrans.x +
+            this.get(3, 1) * inTrans.y +
+            this.get(3, 2) * inTrans.z +
+            this.get(3, 3);
+        this.set(0, 3, x);
+        this.set(1, 3, y);
+        this.set(2, 3, z);
+        this.set(3, 3, w);
+        return this;
+    }
+    /**
+     * from unity AMath.PI
+     */
+    setTRInverse(pos, q) {
+        q = q.inverse();
+        Quaternion.quaternionToMatrix(q, this);
+        this.translate(new Vector3(-pos.x, -pos.y, -pos.z));
+    }
+    /**
+     * Set scale value
+     * @param inScale scale value
+     * @returns this matrix
+     */
+    setScale(inScale) {
+        this.set(0, 0, inScale.x);
+        this.set(0, 1, 0.0);
+        this.set(0, 2, 0.0);
+        this.set(0, 3, 0.0);
+        this.set(1, 0, 0.0);
+        this.set(1, 1, inScale.y);
+        this.set(1, 2, 0.0);
+        this.set(1, 3, 0.0);
+        this.set(2, 0, 0.0);
+        this.set(2, 1, 0.0);
+        this.set(2, 2, inScale.z);
+        this.set(2, 3, 0.0);
+        this.set(3, 0, 0.0);
+        this.set(3, 1, 0.0);
+        this.set(3, 2, 0.0);
+        this.set(3, 3, 1.0);
+        return this;
+    }
+    /**
+     * Generate the matrix according to the three axes
+     * @param xAxis
+     * @param yAxis
+     * @param zAxis
+     */
+    makeBasis(xAxis, yAxis, zAxis) {
+        this.setElements(xAxis.x, yAxis.x, zAxis.x, 0, xAxis.y, yAxis.y, zAxis.y, 0, xAxis.z, yAxis.z, zAxis.z, 0, 0, 0, 0, 1);
+        return this;
+    }
+    makeRotationAxis(axis, angle) {
+        const c = Math.cos(angle);
+        const s = Math.sin(angle);
+        const t = 1 - c;
+        const x = axis.x, y = axis.y, z = axis.z;
+        const tx = t * x, ty = t * y;
+        this.setElements(tx * x + c, tx * y - s * z, tx * z + s * y, 0, tx * y + s * z, ty * y + c, ty * z - s * x, 0, tx * z - s * y, ty * z + s * x, t * z * z + c, 0, 0, 0, 0, 1);
+        return this;
+    }
+    /**
+     * private
+     */
+    static transpose(matrix, result) {
+        result ||= new Matrix4();
+        let m = matrix.rawData;
+        let r = result.rawData;
+        r[0] = m[0];
+        r[1] = m[4];
+        r[2] = m[8];
+        r[3] = m[12];
+        r[4] = m[1];
+        r[5] = m[5];
+        r[6] = m[9];
+        r[7] = m[13];
+        r[8] = m[2];
+        r[9] = m[6];
+        r[10] = m[10];
+        r[11] = m[14];
+        r[12] = m[3];
+        r[13] = m[7];
+        r[14] = m[11];
+        r[15] = m[15];
+        return result;
+    }
+    /**
+     * private
+     */
+    static inverse(matrix, result) {
+        result ||= new Matrix4();
+        let m = matrix.rawData;
+        let r = result.rawData;
+        r[0] =
+            m[5] * m[10] * m[15] -
+                m[5] * m[14] * m[11] -
+                m[6] * m[9] * m[15] +
+                m[6] * m[13] * m[11] +
+                m[7] * m[9] * m[14] -
+                m[7] * m[13] * m[10];
+        r[1] =
+            -m[1] * m[10] * m[15] +
+                m[1] * m[14] * m[11] +
+                m[2] * m[9] * m[15] -
+                m[2] * m[13] * m[11] -
+                m[3] * m[9] * m[14] +
+                m[3] * m[13] * m[10];
+        r[2] =
+            m[1] * m[6] * m[15] -
+                m[1] * m[14] * m[7] -
+                m[2] * m[5] * m[15] +
+                m[2] * m[13] * m[7] +
+                m[3] * m[5] * m[14] -
+                m[3] * m[13] * m[6];
+        r[3] =
+            -m[1] * m[6] * m[11] +
+                m[1] * m[10] * m[7] +
+                m[2] * m[5] * m[11] -
+                m[2] * m[9] * m[7] -
+                m[3] * m[5] * m[10] +
+                m[3] * m[9] * m[6];
+        r[4] =
+            -m[4] * m[10] * m[15] +
+                m[4] * m[14] * m[11] +
+                m[6] * m[8] * m[15] -
+                m[6] * m[12] * m[11] -
+                m[7] * m[8] * m[14] +
+                m[7] * m[12] * m[10];
+        r[5] =
+            m[0] * m[10] * m[15] -
+                m[0] * m[14] * m[11] -
+                m[2] * m[8] * m[15] +
+                m[2] * m[12] * m[11] +
+                m[3] * m[8] * m[14] -
+                m[3] * m[12] * m[10];
+        r[6] =
+            -m[0] * m[6] * m[15] +
+                m[0] * m[14] * m[7] +
+                m[2] * m[4] * m[15] -
+                m[2] * m[12] * m[7] -
+                m[3] * m[4] * m[14] +
+                m[3] * m[12] * m[6];
+        r[7] =
+            m[0] * m[6] * m[11] -
+                m[0] * m[10] * m[7] -
+                m[2] * m[4] * m[11] +
+                m[2] * m[8] * m[7] +
+                m[3] * m[4] * m[10] -
+                m[3] * m[8] * m[6];
+        r[8] =
+            m[4] * m[9] * m[15] -
+                m[4] * m[13] * m[11] -
+                m[5] * m[8] * m[15] +
+                m[5] * m[12] * m[11] +
+                m[7] * m[8] * m[13] -
+                m[7] * m[12] * m[9];
+        r[9] =
+            -m[0] * m[9] * m[15] +
+                m[0] * m[13] * m[11] +
+                m[1] * m[8] * m[15] -
+                m[1] * m[12] * m[11] -
+                m[3] * m[8] * m[13] +
+                m[3] * m[12] * m[9];
+        r[10] =
+            m[0] * m[5] * m[15] -
+                m[0] * m[13] * m[7] -
+                m[1] * m[4] * m[15] +
+                m[1] * m[12] * m[7] +
+                m[3] * m[4] * m[13] -
+                m[3] * m[12] * m[5];
+        r[11] =
+            -m[0] * m[5] * m[11] +
+                m[0] * m[9] * m[7] +
+                m[1] * m[4] * m[11] -
+                m[1] * m[8] * m[7] -
+                m[3] * m[4] * m[9] +
+                m[3] * m[8] * m[5];
+        r[12] =
+            -m[4] * m[9] * m[14] +
+                m[4] * m[13] * m[10] +
+                m[5] * m[8] * m[14] -
+                m[5] * m[12] * m[10] -
+                m[6] * m[8] * m[13] +
+                m[6] * m[12] * m[9];
+        r[13] =
+            m[0] * m[9] * m[14] -
+                m[0] * m[13] * m[10] -
+                m[1] * m[8] * m[14] +
+                m[1] * m[12] * m[10] +
+                m[2] * m[8] * m[13] -
+                m[2] * m[12] * m[9];
+        r[14] =
+            -m[0] * m[5] * m[14] +
+                m[0] * m[13] * m[6] +
+                m[1] * m[4] * m[14] -
+                m[1] * m[12] * m[6] -
+                m[2] * m[4] * m[13] +
+                m[2] * m[12] * m[5];
+        r[15] =
+            m[0] * m[5] * m[10] -
+                m[0] * m[9] * m[6] -
+                m[1] * m[4] * m[10] +
+                m[1] * m[8] * m[6] +
+                m[2] * m[4] * m[9] -
+                m[2] * m[8] * m[5];
+        let det = m[0] * r[0] + m[1] * r[4] + m[2] * r[8] + m[3] * r[12];
+        for (let i = 0; i < 16; i++) {
+            r[i] /= det;
+        }
+        return result;
+    }
+    makeEuler(target, toDegree, order = "XYZ") {
+        const te = this.rawData;
+        const m11 = te[0];
+        const m12 = te[4];
+        const m13 = te[8];
+        const m21 = te[1];
+        const m22 = te[5];
+        const m23 = te[9];
+        const m31 = te[2];
+        const m32 = te[6];
+        const m33 = te[10];
+        switch (order) {
+            case "XYZ":
+                target.y = Math.asin(clamp(m13, -1, 1));
+                if (Math.abs(m13) < 0.9999999) {
+                    target.x = Math.atan2(-m23, m33);
+                    target.z = Math.atan2(-m12, m11);
+                }
+                else {
+                    target.x = Math.atan2(m32, m22);
+                    target.z = 0;
+                }
+                break;
+            case "YXZ":
+                target.x = Math.asin(-clamp(m23, -1, 1));
+                if (Math.abs(m23) < 0.9999999) {
+                    target.y = Math.atan2(m13, m33);
+                    target.z = Math.atan2(m21, m22);
+                }
+                else {
+                    target.y = Math.atan2(-m31, m11);
+                    target.z = 0;
+                }
+                break;
+            case "ZXY":
+                target.x = Math.asin(clamp(m32, -1, 1));
+                if (Math.abs(m32) < 0.9999999) {
+                    target.y = Math.atan2(-m31, m33);
+                    target.z = Math.atan2(-m12, m22);
+                }
+                else {
+                    target.y = 0;
+                    target.z = Math.atan2(m21, m11);
+                }
+                break;
+            case "ZYX":
+                target.y = Math.asin(-clamp(m31, -1, 1));
+                if (Math.abs(m31) < 0.9999999) {
+                    target.x = Math.atan2(m32, m33);
+                    target.z = Math.atan2(m21, m11);
+                }
+                else {
+                    target.x = 0;
+                    target.z = Math.atan2(-m12, m22);
+                }
+                break;
+            case "YZX":
+                target.z = Math.asin(clamp(m21, -1, 1));
+                if (Math.abs(m21) < 0.9999999) {
+                    target.x = Math.atan2(-m23, m22);
+                    target.y = Math.atan2(-m31, m11);
+                }
+                else {
+                    target.x = 0;
+                    target.y = Math.atan2(m13, m33);
+                }
+                break;
+            case "XZY":
+                target.z = Math.asin(-clamp(m12, -1, 1));
+                if (Math.abs(m12) < 0.9999999) {
+                    target.x = Math.atan2(m32, m22);
+                    target.y = Math.atan2(m13, m11);
+                }
+                else {
+                    target.x = Math.atan2(-m23, m33);
+                    target.y = 0;
+                }
+                break;
+            default: {
+            }
+        }
+        if (toDegree) {
+            target.multiplyScalar(RADIANS_TO_DEGREES);
+        }
+        return target;
+    }
+    setElements(n11, n12, n13, n14, n21, n22, n23, n24, n31, n32, n33, n34, n41, n42, n43, n44) {
+        const te = this.rawData;
+        te[0] = n11;
+        te[4] = n12;
+        te[8] = n13;
+        te[12] = n14;
+        te[1] = n21;
+        te[5] = n22;
+        te[9] = n23;
+        te[13] = n24;
+        te[2] = n31;
+        te[6] = n32;
+        te[10] = n33;
+        te[14] = n34;
+        te[3] = n41;
+        te[7] = n42;
+        te[11] = n43;
+        te[15] = n44;
+        return this;
+    }
+    /**
+     * @internal
+     */
+    makeMatrix44ByQuaternion(pos, scale, rot) {
+        this.identity();
+        Quaternion.quaternionToMatrix(rot, this);
+        this.appendTranslation(pos.x, pos.y, pos.z);
+        this.appendScale(scale.x, scale.y, scale.z);
+    }
+}
+/**
+ * @internal
+ */
+export function multiplyMatrices4x4REF(lhs, rhs, res) {
+    for (let i = 0; i < 4; i++) {
+        res.rawData[i] =
+            lhs.rawData[i] * rhs.rawData[0] +
+                lhs.rawData[i + 4] * rhs.rawData[1] +
+                lhs.rawData[i + 8] * rhs.rawData[2] +
+                lhs.rawData[i + 12] * rhs.rawData[3];
+        res.rawData[i + 4] =
+            lhs.rawData[i] * rhs.rawData[4] +
+                lhs.rawData[i + 4] * rhs.rawData[5] +
+                lhs.rawData[i + 8] * rhs.rawData[6] +
+                lhs.rawData[i + 12] * rhs.rawData[7];
+        res.rawData[i + 8] =
+            lhs.rawData[i] * rhs.rawData[8] +
+                lhs.rawData[i + 4] * rhs.rawData[9] +
+                lhs.rawData[i + 8] * rhs.rawData[10] +
+                lhs.rawData[i + 12] * rhs.rawData[11];
+        res.rawData[i + 12] =
+            lhs.rawData[i] * rhs.rawData[12] +
+                lhs.rawData[i + 4] * rhs.rawData[13] +
+                lhs.rawData[i + 8] * rhs.rawData[14] +
+                lhs.rawData[i + 12] * rhs.rawData[15];
+    }
+}
+/**
+ * @internal
+ */
+export function makeMatrix44(r, p, s, outMat) {
+    // Quaternion.CALCULATION_QUATERNION.fromEulerAngles(r.x, r.y, r.z);
+    let rawData = outMat.rawData;
+    let x = r.x * DEGREES_TO_RADIANS;
+    let y = r.y * DEGREES_TO_RADIANS;
+    let z = r.z * DEGREES_TO_RADIANS;
+    let w = 0;
+    let halfX = x * 0.5;
+    let halfY = y * 0.5;
+    let halfZ = z * 0.5;
+    let cosX = Math.cos(halfX);
+    let sinX = Math.sin(halfX);
+    let cosY = Math.cos(halfY);
+    let sinY = Math.sin(halfY);
+    let cosZ = Math.cos(halfZ);
+    let sinZ = Math.sin(halfZ);
+    w = cosX * cosY * cosZ + sinX * sinY * sinZ;
+    x = sinX * cosY * cosZ - cosX * sinY * sinZ;
+    y = cosX * sinY * cosZ + sinX * cosY * sinZ;
+    z = cosX * cosY * sinZ - sinX * sinY * cosZ;
+    let x2 = x + x;
+    let y2 = y + y;
+    let z2 = z + z;
+    let xx = x * x2;
+    let xy = x * y2;
+    let xz = x * z2;
+    let yy = y * y2;
+    let yz = y * z2;
+    let zz = z * z2;
+    let wx = w * x2;
+    let wy = w * y2;
+    let wz = w * z2;
+    let sx = s.x;
+    let sy = s.y;
+    let sz = s.z;
+    rawData[0] = (1 - (yy + zz)) * sx;
+    rawData[1] = (xy + wz) * sx;
+    rawData[2] = (xz - wy) * sx;
+    rawData[3] = 0;
+    rawData[4] = (xy - wz) * sy;
+    rawData[5] = (1 - (xx + zz)) * sy;
+    rawData[6] = (yz + wx) * sy;
+    rawData[7] = 0;
+    rawData[8] = (xz + wy) * sz;
+    rawData[9] = (yz - wx) * sz;
+    rawData[10] = (1 - (xx + yy)) * sz;
+    rawData[11] = 0;
+    rawData[12] = p.x;
+    rawData[13] = p.y;
+    rawData[14] = p.z;
+    rawData[15] = 1;
+}
+/**
+ * @internal
+ */
+export function append(src, lhs, target) {
+    let data = src.rawData;
+    let targetData = target.rawData;
+    let m111 = data[0];
+    let m121 = data[4];
+    let m131 = data[8];
+    let m141 = data[12];
+    let m112 = data[1];
+    let m122 = data[5];
+    let m132 = data[9];
+    let m142 = data[13];
+    let m113 = data[2];
+    let m123 = data[6];
+    let m133 = data[10];
+    let m143 = data[14];
+    let m114 = data[3];
+    let m124 = data[7];
+    let m134 = data[11];
+    let m144 = data[15];
+    targetData[0] =
+        m111 * lhs.rawData[0] +
+            m112 * lhs.rawData[4] +
+            m113 * lhs.rawData[8] +
+            m114 * lhs.rawData[12];
+    targetData[1] =
+        m111 * lhs.rawData[1] +
+            m112 * lhs.rawData[5] +
+            m113 * lhs.rawData[9] +
+            m114 * lhs.rawData[13];
+    targetData[2] =
+        m111 * lhs.rawData[2] +
+            m112 * lhs.rawData[6] +
+            m113 * lhs.rawData[10] +
+            m114 * lhs.rawData[14];
+    targetData[3] =
+        m111 * lhs.rawData[3] +
+            m112 * lhs.rawData[7] +
+            m113 * lhs.rawData[11] +
+            m114 * lhs.rawData[15];
+    targetData[4] =
+        m121 * lhs.rawData[0] +
+            m122 * lhs.rawData[4] +
+            m123 * lhs.rawData[8] +
+            m124 * lhs.rawData[12];
+    targetData[5] =
+        m121 * lhs.rawData[1] +
+            m122 * lhs.rawData[5] +
+            m123 * lhs.rawData[9] +
+            m124 * lhs.rawData[13];
+    targetData[6] =
+        m121 * lhs.rawData[2] +
+            m122 * lhs.rawData[6] +
+            m123 * lhs.rawData[10] +
+            m124 * lhs.rawData[14];
+    targetData[7] =
+        m121 * lhs.rawData[3] +
+            m122 * lhs.rawData[7] +
+            m123 * lhs.rawData[11] +
+            m124 * lhs.rawData[15];
+    targetData[8] =
+        m131 * lhs.rawData[0] +
+            m132 * lhs.rawData[4] +
+            m133 * lhs.rawData[8] +
+            m134 * lhs.rawData[12];
+    targetData[9] =
+        m131 * lhs.rawData[1] +
+            m132 * lhs.rawData[5] +
+            m133 * lhs.rawData[9] +
+            m134 * lhs.rawData[13];
+    targetData[10] =
+        m131 * lhs.rawData[2] +
+            m132 * lhs.rawData[6] +
+            m133 * lhs.rawData[10] +
+            m134 * lhs.rawData[14];
+    targetData[11] =
+        m131 * lhs.rawData[3] +
+            m132 * lhs.rawData[7] +
+            m133 * lhs.rawData[11] +
+            m134 * lhs.rawData[15];
+    targetData[12] =
+        m141 * lhs.rawData[0] +
+            m142 * lhs.rawData[4] +
+            m143 * lhs.rawData[8] +
+            m144 * lhs.rawData[12];
+    targetData[13] =
+        m141 * lhs.rawData[1] +
+            m142 * lhs.rawData[5] +
+            m143 * lhs.rawData[9] +
+            m144 * lhs.rawData[13];
+    targetData[14] =
+        m141 * lhs.rawData[2] +
+            m142 * lhs.rawData[6] +
+            m143 * lhs.rawData[10] +
+            m144 * lhs.rawData[14];
+    targetData[15] =
+        m141 * lhs.rawData[3] +
+            m142 * lhs.rawData[7] +
+            m143 * lhs.rawData[11] +
+            m144 * lhs.rawData[15];
+}
+/**
+ * @internal
+ */
+export function rotMatrix(mat, q) {
+    let x = q.x;
+    let y = q.y;
+    let z = q.z;
+    let w = q.w;
+    let rawData = mat.rawData;
+    let xy2 = 2.0 * x * y;
+    let xz2 = 2.0 * x * z;
+    let xw2 = 2.0 * x * w;
+    let yz2 = 2.0 * y * z;
+    let yw2 = 2.0 * y * w;
+    let zw2 = 2.0 * z * w;
+    let xx = x * x;
+    let yy = y * y;
+    let zz = z * z;
+    let ww = w * w;
+    rawData[0] = xx - yy - zz + ww;
+    rawData[4] = xy2 - zw2;
+    rawData[8] = xz2 + yw2;
+    rawData[12] = 0;
+    rawData[1] = xy2 + zw2;
+    rawData[5] = -xx + yy - zz + ww;
+    rawData[9] = yz2 - xw2;
+    rawData[13] = 0;
+    rawData[2] = xz2 - yw2;
+    rawData[6] = yz2 + xw2;
+    rawData[10] = -xx - yy + zz + ww;
+    rawData[14] = 0;
+    rawData[3] = 0.0;
+    rawData[7] = 0.0;
+    rawData[11] = 0;
+    rawData[15] = 1;
+    return mat;
+}
+/**
+ * @internal
+ */
+export function matrixRotateY(rad, target) {
+    let out = target.rawData;
+    let s = Math.sin(rad);
+    let c = Math.cos(rad);
+    out[0] = c;
+    out[1] = 0;
+    out[2] = -s;
+    out[3] = 0;
+    out[8] = s;
+    out[9] = 0;
+    out[10] = c;
+    out[11] = 0;
+    return out;
+}
+/**
+ * Rotates a mat4 by the given angle around the given axis
+ * @internal
+ * @param {mat4} out the receiving matrix
+ * @param {ReadonlyMat4} a the matrix to rotate
+ * @param {Number} rad the angle to rotate the matrix by
+ * @param {ReadonlyVec3} axis the axis to rotate around
+ * @returns {mat4} out
+ */
+export function matrixRotate(rad, axis, target) {
+    let x = axis.x;
+    let y = axis.y;
+    let z = axis.z;
+    let len = Math.hypot(x, y, z);
+    let s;
+    let c;
+    let t;
+    let a23;
+    let b00;
+    let b01;
+    let b02;
+    let b10;
+    let b11;
+    let b12;
+    let b20;
+    let b21;
+    let b22;
+    if (len < EPSILON) {
+        return null;
+    }
+    len = 1 / len;
+    x *= len;
+    y *= len;
+    z *= len;
+    s = Math.sin(rad);
+    c = Math.cos(rad);
+    t = 1 - c;
+    a23 = 0; // Construct the elements of the rotation matrix
+    b00 = x * x * t + c;
+    b01 = y * x * t + z * s;
+    b02 = z * x * t - y * s;
+    b10 = x * y * t - z * s;
+    b11 = y * y * t + c;
+    b12 = z * y * t + x * s;
+    b20 = x * z * t + y * s;
+    b21 = y * z * t - x * s;
+    b22 = z * z * t + c; // Perform rotation-specific matrix multiplication
+    let out = target.rawData;
+    out[0] = b00;
+    out[1] = b01;
+    out[2] = b02;
+    out[3] = 0;
+    out[4] = b10;
+    out[5] = b11;
+    out[6] = b12;
+    out[7] = 0;
+    out[8] = b20;
+    out[9] = b21;
+    out[10] = b22;
+    out[11] = 0;
+    out[12] = 0;
+    out[13] = 0;
+    out[14] = 0;
+    out[15] = 1;
+    return out;
+}
+/**
+ * @internal
+ */
+export function matrixMultiply(aMat, bMat, target) {
+    let a = aMat.rawData;
+    let a00 = a[0];
+    let a01 = a[1];
+    let a02 = a[2];
+    let a03 = a[3];
+    let a10 = a[4];
+    let a11 = a[5];
+    let a12 = a[6];
+    let a13 = a[7];
+    let a20 = a[8];
+    let a21 = a[9];
+    let a22 = a[10];
+    let a23 = a[11];
+    let a30 = a[12];
+    let a31 = a[13];
+    let a32 = a[14];
+    let a33 = a[15]; // Cache only the current line of the second matrix
+    let b = bMat.rawData;
+    let out = target.rawData;
+    let b0 = b[0];
+    let b1 = b[1];
+    let b2 = b[2];
+    let b3 = b[3];
+    out[0] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30;
+    out[1] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31;
+    out[2] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32;
+    out[3] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33;
+    b0 = b[4];
+    b1 = b[5];
+    b2 = b[6];
+    b3 = b[7];
+    out[4] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30;
+    out[5] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31;
+    out[6] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32;
+    out[7] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33;
+    b0 = b[8];
+    b1 = b[9];
+    b2 = b[10];
+    b3 = b[11];
+    out[8] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30;
+    out[9] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31;
+    out[10] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32;
+    out[11] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33;
+    b0 = b[12];
+    b1 = b[13];
+    b2 = b[14];
+    b3 = b[15];
+    out[12] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30;
+    out[13] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31;
+    out[14] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32;
+    out[15] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33;
+    return out;
+}