action-engine-js 1.0.0

package/actionengine/math/matrix4.js

@@ -0,0 +1,785 @@
+// actionengine/math/matrix4.js
+class Matrix4 {
+    static create() {
+        return new Float32Array([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]);
+    }
+
+    static identity(out) {
+        out[0] = 1;
+        out[1] = 0;
+        out[2] = 0;
+        out[3] = 0;
+        out[4] = 0;
+        out[5] = 1;
+        out[6] = 0;
+        out[7] = 0;
+        out[8] = 0;
+        out[9] = 0;
+        out[10] = 1;
+        out[11] = 0;
+        out[12] = 0;
+        out[13] = 0;
+        out[14] = 0;
+        out[15] = 1;
+        return out;
+    }
+    /**
+     * Multiply a vector by a matrix
+     * @param {Array} out - Output vector (will be modified)
+     * @param {Array|Float32Array} matrix - 4x4 matrix
+     * @param {Array} vec - Input vector [x, y, z, w]
+     * @returns {Array} - The output vector
+     */
+    static multiplyVector(out, matrix, vec) {
+        const x = vec[0];
+        const y = vec[1];
+        const z = vec[2];
+        const w = vec[3] || 1.0;
+        
+        out[0] = matrix[0] * x + matrix[4] * y + matrix[8] * z + matrix[12] * w;
+        out[1] = matrix[1] * x + matrix[5] * y + matrix[9] * z + matrix[13] * w;
+        out[2] = matrix[2] * x + matrix[6] * y + matrix[10] * z + matrix[14] * w;
+        out[3] = matrix[3] * x + matrix[7] * y + matrix[11] * z + matrix[15] * w;
+        
+        return out;
+    }
+    
+    static transformVector(vector, viewMatrix, projectionMatrix) {
+        // First multiply by view matrix
+        const viewResult = [0, 0, 0, 0];
+        for (let i = 0; i < 4; i++) {
+            viewResult[i] =
+                vector[0] * viewMatrix[i] +
+                vector[1] * viewMatrix[i + 4] +
+                vector[2] * viewMatrix[i + 8] +
+                vector[3] * viewMatrix[i + 12];
+        }
+
+        // Then multiply by projection matrix
+        const result = [0, 0, 0, 0];
+        for (let i = 0; i < 4; i++) {
+            result[i] =
+                viewResult[0] * projectionMatrix[i] +
+                viewResult[1] * projectionMatrix[i + 4] +
+                viewResult[2] * projectionMatrix[i + 8] +
+                viewResult[3] * projectionMatrix[i + 12];
+        }
+
+        return result;
+    }
+    static fromQuat(out, q) {
+        const x = q.x,
+            y = q.y,
+            z = q.z,
+            w = q.w;
+        const x2 = x + x,
+            y2 = y + y,
+            z2 = z + z;
+        const xx = x * x2,
+            xy = x * y2,
+            xz = x * z2;
+        const yy = y * y2,
+            yz = y * z2,
+            zz = z * z2;
+        const wx = w * x2,
+            wy = w * y2,
+            wz = w * z2;
+
+        out[0] = 1 - (yy + zz);
+        out[1] = xy + wz;
+        out[2] = xz - wy;
+        out[3] = 0;
+
+        out[4] = xy - wz;
+        out[5] = 1 - (xx + zz);
+        out[6] = yz + wx;
+        out[7] = 0;
+
+        out[8] = xz + wy;
+        out[9] = yz - wx;
+        out[10] = 1 - (xx + yy);
+        out[11] = 0;
+
+        out[12] = 0;
+        out[13] = 0;
+        out[14] = 0;
+        out[15] = 1;
+
+        return out;
+    }
+
+    static fromLightDirection(out, dir) {
+        // Make sure the direction is normalized
+        const nx = dir.x;
+        const ny = dir.y;
+        const nz = dir.z;
+
+        // Find a perpendicular vector for the "right" direction
+        // Using world-up (0,1,0) as a reference
+        const right = [
+            nz, // Cross product of dir with (0,1,0)
+            0,
+            -nx
+        ];
+
+        // Normalize right vector
+        const rLength = Math.sqrt(right[0] * right[0] + right[2] * right[2]);
+        right[0] /= rLength;
+        right[2] /= rLength;
+
+        // Get up vector by crossing right with direction
+        const up = [
+            -nx * ny, // Cross product of right with dir
+            nx * nx + nz * nz,
+            -ny * nz
+        ];
+
+        // Build the view matrix
+        out[0] = right[0];
+        out[1] = up[0];
+        out[2] = nx;
+        out[3] = 0;
+
+        out[4] = right[1];
+        out[5] = up[1];
+        out[6] = ny;
+        out[7] = 0;
+
+        out[8] = right[2];
+        out[9] = up[2];
+        out[10] = nz;
+        out[11] = 0;
+
+        out[12] = 0;
+        out[13] = 0;
+        out[14] = 0;
+        out[15] = 1;
+
+        return out;
+    }
+    static copy(out, a) {
+        out[0] = a[0];
+        out[1] = a[1];
+        out[2] = a[2];
+        out[3] = a[3];
+        out[4] = a[4];
+        out[5] = a[5];
+        out[6] = a[6];
+        out[7] = a[7];
+        out[8] = a[8];
+        out[9] = a[9];
+        out[10] = a[10];
+        out[11] = a[11];
+        out[12] = a[12];
+        out[13] = a[13];
+        out[14] = a[14];
+        out[15] = a[15];
+        return out;
+    }
+
+    static multiply(out, a, b) {
+        const a00 = a[0],
+            a01 = a[1],
+            a02 = a[2],
+            a03 = a[3];
+        const a10 = a[4],
+            a11 = a[5],
+            a12 = a[6],
+            a13 = a[7];
+        const a20 = a[8],
+            a21 = a[9],
+            a22 = a[10],
+            a23 = a[11];
+        const a30 = a[12],
+            a31 = a[13],
+            a32 = a[14],
+            a33 = a[15];
+
+        let b0 = b[0],
+            b1 = b[1],
+            b2 = b[2],
+            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;
+    }
+    static fromRotationTranslation(out, q, v) {
+        // Similar to his code but using our Quaternion class
+        const x = q.x,
+            y = q.y,
+            z = q.z,
+            w = q.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;
+
+        out[0] = 1 - (yy + zz);
+        out[1] = xy + wz;
+        out[2] = xz - wy;
+        out[3] = 0;
+        out[4] = xy - wz;
+        out[5] = 1 - (xx + zz);
+        out[6] = yz + wx;
+        out[7] = 0;
+        out[8] = xz + wy;
+        out[9] = yz - wx;
+        out[10] = 1 - (xx + yy);
+        out[11] = 0;
+        out[12] = v.x;
+        out[13] = v.y;
+        out[14] = v.z;
+        out[15] = 1;
+        return out;
+    }
+
+    static transformVertex(vertex, modelMatrix) {
+        const v = [vertex.x, vertex.y, vertex.z, 1];
+        const result = [0, 0, 0, 0];
+
+        for (let i = 0; i < 4; i++) {
+            result[i] =
+                v[0] * modelMatrix[i] +
+                v[1] * modelMatrix[i + 4] +
+                v[2] * modelMatrix[i + 8] +
+                v[3] * modelMatrix[i + 12];
+        }
+
+        return new Vector3(result[0] / result[3], result[1] / result[3], result[2] / result[3]);
+    }
+
+    static transformNormal(normal, modelMatrix) {
+        // Calculate inverse transpose of 3x3 portion of model matrix
+        const a = modelMatrix[0],
+            b = modelMatrix[1],
+            c = modelMatrix[2],
+            d = modelMatrix[4],
+            e = modelMatrix[5],
+            f = modelMatrix[6],
+            g = modelMatrix[8],
+            h = modelMatrix[9],
+            i = modelMatrix[10];
+
+        const det = a * (e * i - f * h) - b * (d * i - f * g) + c * (d * h - e * g);
+        const invdet = 1.0 / det;
+
+        const invTranspose = [
+            (e * i - f * h) * invdet,
+            (c * h - b * i) * invdet,
+            (b * f - c * e) * invdet,
+            (f * g - d * i) * invdet,
+            (a * i - c * g) * invdet,
+            (c * d - a * f) * invdet,
+            (d * h - e * g) * invdet,
+            (b * g - a * h) * invdet,
+            (a * e - b * d) * invdet
+        ];
+
+        const x = normal.x * invTranspose[0] + normal.y * invTranspose[1] + normal.z * invTranspose[2];
+        const y = normal.x * invTranspose[3] + normal.y * invTranspose[4] + normal.z * invTranspose[5];
+        const z = normal.x * invTranspose[6] + normal.y * invTranspose[7] + normal.z * invTranspose[8];
+
+        return new Vector3(x, y, z).normalize();
+    }
+    static perspective(out, fovy, aspect, near, far) {
+        const f = 1.0 / Math.tan(fovy / 2);
+        out[0] = f / aspect;
+        out[1] = 0;
+        out[2] = 0;
+        out[3] = 0;
+        out[4] = 0;
+        out[5] = f;
+        out[6] = 0;
+        out[7] = 0;
+        out[8] = 0;
+        out[9] = 0;
+        out[10] = (far + near) / (near - far);
+        out[11] = -1;
+        out[12] = 0;
+        out[13] = 0;
+        out[14] = (2 * far * near) / (near - far);
+        out[15] = 0;
+        return out;
+    }
+
+    static ortho(out, left, right, bottom, top, near, far) {
+        const lr = 1 / (left - right);
+        const bt = 1 / (bottom - top);
+        const nf = 1 / (near - far);
+        out[0] = -2 * lr;
+        out[1] = 0;
+        out[2] = 0;
+        out[3] = 0;
+        out[4] = 0;
+        out[5] = -2 * bt;
+        out[6] = 0;
+        out[7] = 0;
+        out[8] = 0;
+        out[9] = 0;
+        out[10] = 2 * nf;
+        out[11] = 0;
+        out[12] = (left + right) * lr;
+        out[13] = (top + bottom) * bt;
+        out[14] = (far + near) * nf;
+        out[15] = 1;
+        return out;
+    }
+
+    static translate(out, a, v) {
+        const x = v[0],
+            y = v[1],
+            z = v[2];
+
+        if (a !== out) {
+            out[0] = a[0];
+            out[1] = a[1];
+            out[2] = a[2];
+            out[3] = a[3];
+            out[4] = a[4];
+            out[5] = a[5];
+            out[6] = a[6];
+            out[7] = a[7];
+            out[8] = a[8];
+            out[9] = a[9];
+            out[10] = a[10];
+            out[11] = a[11];
+        }
+
+        out[12] = a[0] * x + a[4] * y + a[8] * z + a[12];
+        out[13] = a[1] * x + a[5] * y + a[9] * z + a[13];
+        out[14] = a[2] * x + a[6] * y + a[10] * z + a[14];
+        out[15] = a[3] * x + a[7] * y + a[11] * z + a[15];
+
+        return out;
+    }
+
+    static rotate(out, a, rad, axis) {
+        let x = axis[0],
+            y = axis[1],
+            z = axis[2];
+
+        let len = Math.hypot(x, y, z);
+        if (len < 0.000001) {
+            return null;
+        }
+        len = 1 / len;
+        x *= len;
+        y *= len;
+        z *= len;
+
+        const s = Math.sin(rad);
+        const c = Math.cos(rad);
+        const t = 1 - c;
+
+        const a00 = a[0],
+            a01 = a[1],
+            a02 = a[2],
+            a03 = a[3];
+        const a10 = a[4],
+            a11 = a[5],
+            a12 = a[6],
+            a13 = a[7];
+        const a20 = a[8],
+            a21 = a[9],
+            a22 = a[10],
+            a23 = a[11];
+
+        const b00 = x * x * t + c;
+        const b01 = y * x * t + z * s;
+        const b02 = z * x * t - y * s;
+        const b10 = x * y * t - z * s;
+        const b11 = y * y * t + c;
+        const b12 = z * y * t + x * s;
+        const b20 = x * z * t + y * s;
+        const b21 = y * z * t - x * s;
+        const b22 = z * z * t + c;
+
+        out[0] = a00 * b00 + a10 * b01 + a20 * b02;
+        out[1] = a01 * b00 + a11 * b01 + a21 * b02;
+        out[2] = a02 * b00 + a12 * b01 + a22 * b02;
+        out[3] = a03 * b00 + a13 * b01 + a23 * b02;
+        out[4] = a00 * b10 + a10 * b11 + a20 * b12;
+        out[5] = a01 * b10 + a11 * b11 + a21 * b12;
+        out[6] = a02 * b10 + a12 * b11 + a22 * b12;
+        out[7] = a03 * b10 + a13 * b11 + a23 * b12;
+        out[8] = a00 * b20 + a10 * b21 + a20 * b22;
+        out[9] = a01 * b20 + a11 * b21 + a21 * b22;
+        out[10] = a02 * b20 + a12 * b21 + a22 * b22;
+        out[11] = a03 * b20 + a13 * b21 + a23 * b22;
+
+        if (a !== out) {
+            out[12] = a[12];
+            out[13] = a[13];
+            out[14] = a[14];
+            out[15] = a[15];
+        }
+        return out;
+    }
+
+    static scale(out, a, v) {
+        const x = v[0],
+            y = v[1],
+            z = v[2];
+        out[0] = a[0] * x;
+        out[1] = a[1] * x;
+        out[2] = a[2] * x;
+        out[3] = a[3] * x;
+        out[4] = a[4] * y;
+        out[5] = a[5] * y;
+        out[6] = a[6] * y;
+        out[7] = a[7] * y;
+        out[8] = a[8] * z;
+        out[9] = a[9] * z;
+        out[10] = a[10] * z;
+        out[11] = a[11] * z;
+        out[12] = a[12];
+        out[13] = a[13];
+        out[14] = a[14];
+        out[15] = a[15];
+        return out;
+    }
+
+    static invert(out, a) {
+        const a00 = a[0],
+            a01 = a[1],
+            a02 = a[2],
+            a03 = a[3];
+        const a10 = a[4],
+            a11 = a[5],
+            a12 = a[6],
+            a13 = a[7];
+        const a20 = a[8],
+            a21 = a[9],
+            a22 = a[10],
+            a23 = a[11];
+        const a30 = a[12],
+            a31 = a[13],
+            a32 = a[14],
+            a33 = a[15];
+
+        const b00 = a00 * a11 - a01 * a10;
+        const b01 = a00 * a12 - a02 * a10;
+        const b02 = a00 * a13 - a03 * a10;
+        const b03 = a01 * a12 - a02 * a11;
+        const b04 = a01 * a13 - a03 * a11;
+        const b05 = a02 * a13 - a03 * a12;
+        const b06 = a20 * a31 - a21 * a30;
+        const b07 = a20 * a32 - a22 * a30;
+        const b08 = a20 * a33 - a23 * a30;
+        const b09 = a21 * a32 - a22 * a31;
+        const b10 = a21 * a33 - a23 * a31;
+        const b11 = a22 * a33 - a23 * a32;
+
+        let det = b00 * b11 - b01 * b10 + b02 * b09 + b03 * b08 - b04 * b07 + b05 * b06;
+        if (!det) {
+            return null;
+        }
+        det = 1.0 / det;
+
+        out[0] = (a11 * b11 - a12 * b10 + a13 * b09) * det;
+        out[1] = (a02 * b10 - a01 * b11 - a03 * b09) * det;
+        out[2] = (a31 * b05 - a32 * b04 + a33 * b03) * det;
+        out[3] = (a22 * b04 - a21 * b05 - a23 * b03) * det;
+        out[4] = (a12 * b08 - a10 * b11 - a13 * b07) * det;
+        out[5] = (a00 * b11 - a02 * b08 + a03 * b07) * det;
+        out[6] = (a32 * b02 - a30 * b05 - a33 * b01) * det;
+        out[7] = (a20 * b05 - a22 * b02 + a23 * b01) * det;
+        out[8] = (a10 * b10 - a11 * b08 + a13 * b06) * det;
+        out[9] = (a01 * b08 - a00 * b10 - a03 * b06) * det;
+        out[10] = (a30 * b04 - a31 * b02 + a33 * b00) * det;
+        out[11] = (a21 * b02 - a20 * b04 - a23 * b00) * det;
+        out[12] = (a11 * b07 - a10 * b09 - a12 * b06) * det;
+        out[13] = (a00 * b09 - a01 * b07 + a02 * b06) * det;
+        out[14] = (a31 * b01 - a30 * b03 - a32 * b00) * det;
+        out[15] = (a20 * b03 - a21 * b01 + a22 * b00) * det;
+
+        return out;
+    }
+
+    static lookAt(out, eye, center, up) {
+        let x0, x1, x2, y0, y1, y2, z0, z1, z2, len;
+        const eyex = eye[0];
+        const eyey = eye[1];
+        const eyez = eye[2];
+        const upx = up[0];
+        const upy = up[1];
+        const upz = up[2];
+        const centerx = center[0];
+        const centery = center[1];
+        const centerz = center[2];
+
+        if (
+            Math.abs(eyex - centerx) < 0.000001 &&
+            Math.abs(eyey - centery) < 0.000001 &&
+            Math.abs(eyez - centerz) < 0.000001
+        ) {
+            return Matrix4.identity(out);
+        }
+
+        z0 = eyex - centerx;
+        z1 = eyey - centery;
+        z2 = eyez - centerz;
+
+        len = 1 / Math.hypot(z0, z1, z2);
+        z0 *= len;
+        z1 *= len;
+        z2 *= len;
+
+        // Cross product of up and z
+        x0 = upy * z2 - upz * z1;
+        x1 = upz * z0 - upx * z2;
+        x2 = upx * z1 - upy * z0;
+        len = Math.hypot(x0, x1, x2);
+        
+        // Handle the case where up and z are colinear (or nearly so)
+        if (len < 0.000001) {
+            // Find a perpendicular vector to z
+            // Try cross product with (1,0,0) first
+            if (Math.abs(z0) < 0.9) {
+                // Cross with X axis
+                x0 = 0;
+                x1 = z2;
+                x2 = -z1;
+            } else {
+                // Cross with Z axis if Z is near X
+                x0 = z1;
+                x1 = -z0;
+                x2 = 0;
+            }
+            len = Math.hypot(x0, x1, x2);
+            len = 1 / len;
+            x0 *= len;
+            x1 *= len;
+            x2 *= len;
+        } else {
+            // Normal case - normalize the computed cross product
+            len = 1 / len;
+            x0 *= len;
+            x1 *= len;
+            x2 *= len;
+        }
+
+        y0 = z1 * x2 - z2 * x1;
+        y1 = z2 * x0 - z0 * x2;
+        y2 = z0 * x1 - z1 * x0;
+
+        len = Math.hypot(y0, y1, y2);
+        if (!len) {
+            y0 = 0;
+            y1 = 0;
+            y2 = 0;
+        } else {
+            len = 1 / len;
+            y0 *= len;
+            y1 *= len;
+            y2 *= len;
+        }
+
+        out[0] = x0;
+        out[1] = y0;
+        out[2] = z0;
+        out[3] = 0;
+        out[4] = x1;
+        out[5] = y1;
+        out[6] = z1;
+        out[7] = 0;
+        out[8] = x2;
+        out[9] = y2;
+        out[10] = z2;
+        out[11] = 0;
+        out[12] = -(x0 * eyex + x1 * eyey + x2 * eyez);
+        out[13] = -(y0 * eyex + y1 * eyey + y2 * eyez);
+        out[14] = -(z0 * eyex + z1 * eyey + z2 * eyez);
+        out[15] = 1;
+
+        return out;
+    }
+
+    static transpose(out, a) {
+        if (out === a) {
+            const a01 = a[1],
+                a02 = a[2],
+                a03 = a[3],
+                a12 = a[6],
+                a13 = a[7],
+                a23 = a[11];
+
+            out[1] = a[4];
+            out[2] = a[8];
+            out[3] = a[12];
+            out[4] = a01;
+            out[6] = a[9];
+            out[7] = a[13];
+            out[8] = a02;
+            out[9] = a12;
+            out[11] = a[14];
+            out[12] = a03;
+            out[13] = a13;
+            out[14] = a23;
+        } else {
+            out[0] = a[0];
+            out[1] = a[4];
+            out[2] = a[8];
+            out[3] = a[12];
+            out[4] = a[1];
+            out[5] = a[5];
+            out[6] = a[9];
+            out[7] = a[13];
+            out[8] = a[2];
+            out[9] = a[6];
+            out[10] = a[10];
+            out[11] = a[14];
+            out[12] = a[3];
+            out[13] = a[7];
+            out[14] = a[11];
+            out[15] = a[15];
+        }
+
+        return out;
+    }
+
+    static rotateX(out, a, rad) {
+        const s = Math.sin(rad);
+        const c = Math.cos(rad);
+        const a10 = a[4];
+        const a11 = a[5];
+        const a12 = a[6];
+        const a13 = a[7];
+        const a20 = a[8];
+        const a21 = a[9];
+        const a22 = a[10];
+        const a23 = a[11];
+
+        out[4] = a10 * c + a20 * s;
+        out[5] = a11 * c + a21 * s;
+        out[6] = a12 * c + a22 * s;
+        out[7] = a13 * c + a23 * s;
+        out[8] = a20 * c - a10 * s;
+        out[9] = a21 * c - a11 * s;
+        out[10] = a22 * c - a12 * s;
+        out[11] = a23 * c - a13 * s;
+
+        // If the source and destination differ, we need to copy the unchanged rows
+        if (a !== out) {
+            out[0] = a[0];
+            out[1] = a[1];
+            out[2] = a[2];
+            out[3] = a[3];
+            out[12] = a[12];
+            out[13] = a[13];
+            out[14] = a[14];
+            out[15] = a[15];
+        }
+
+        return out;
+    }
+    static rotateZ(out, a, rad) {
+        const s = Math.sin(rad);
+        const c = Math.cos(rad);
+        const a00 = a[0];
+        const a01 = a[1];
+        const a02 = a[2];
+        const a03 = a[3];
+        const a10 = a[4];
+        const a11 = a[5];
+        const a12 = a[6];
+        const a13 = a[7];
+
+        out[0] = a00 * c + a10 * s;
+        out[1] = a01 * c + a11 * s;
+        out[2] = a02 * c + a12 * s;
+        out[3] = a03 * c + a13 * s;
+        out[4] = a10 * c - a00 * s;
+        out[5] = a11 * c - a01 * s;
+        out[6] = a12 * c - a02 * s;
+        out[7] = a13 * c - a03 * s;
+
+        // If the source and destination differ, we need to copy the unchanged rows
+        if (a !== out) {
+            out[8] = a[8];
+            out[9] = a[9];
+            out[10] = a[10];
+            out[11] = a[11];
+            out[12] = a[12];
+            out[13] = a[13];
+            out[14] = a[14];
+            out[15] = a[15];
+        }
+
+        return out;
+    }
+
+    static rotateY(out, a, rad) {
+        const s = Math.sin(rad);
+        const c = Math.cos(rad);
+        const a00 = a[0];
+        const a01 = a[1];
+        const a02 = a[2];
+        const a03 = a[3];
+        const a20 = a[8];
+        const a21 = a[9];
+        const a22 = a[10];
+        const a23 = a[11];
+
+        out[0] = a00 * c - a20 * s;
+        out[1] = a01 * c - a21 * s;
+        out[2] = a02 * c - a22 * s;
+        out[3] = a03 * c - a23 * s;
+        out[8] = a00 * s + a20 * c;
+        out[9] = a01 * s + a21 * c;
+        out[10] = a02 * s + a22 * c;
+        out[11] = a03 * s + a23 * c;
+
+        // If the source and destination differ, we need to copy the unchanged rows
+        if (a !== out) {
+            out[4] = a[4];
+            out[5] = a[5];
+            out[6] = a[6];
+            out[7] = a[7];
+            out[12] = a[12];
+            out[13] = a[13];
+            out[14] = a[14];
+            out[15] = a[15];
+        }
+
+        return out;
+    }
+}