reze-engine 0.12.3 → 0.13.1

package/dist/math.js

@@ -52,6 +52,48 @@ export class Vec3 {
         this.z = other.z;
         return this;
     }
+    setXYZ(x, y, z) {
+        this.x = x;
+        this.y = y;
+        this.z = z;
+        return this;
+    }
+    // out = a - b (no allocation)
+    static subtractInto(a, b, out) {
+        out.x = a.x - b.x;
+        out.y = a.y - b.y;
+        out.z = a.z - b.z;
+        return out;
+    }
+    // out = a × b (no allocation). Safe when out === a or out === b.
+    static crossInto(a, b, out) {
+        const ax = a.x, ay = a.y, az = a.z;
+        const bx = b.x, by = b.y, bz = b.z;
+        out.x = ay * bz - az * by;
+        out.y = az * bx - ax * bz;
+        out.z = ax * by - ay * bx;
+        return out;
+    }
+    // Read translation from Mat4 values array (column-major) into out.
+    static setFromMat4Translation(m, out) {
+        out.x = m[12];
+        out.y = m[13];
+        out.z = m[14];
+        return out;
+    }
+    // Transform normal by the upper-left 3x3 of a Mat4 (column-major) into out.
+    // Safe when out === normal.
+    static transformMat4RotationInto(normal, m, out) {
+        const nx = normal.x, ny = normal.y, nz = normal.z;
+        out.x = m[0] * nx + m[4] * ny + m[8] * nz;
+        out.y = m[1] * nx + m[5] * ny + m[9] * nz;
+        out.z = m[2] * nx + m[6] * ny + m[10] * nz;
+        return out;
+    }
+    // In-place normalize returning length squared info via Vec3. Alias for normalize() but explicit.
+    normalizeInPlace() {
+        return this.normalize();
+    }
 }
 export class Quat {
     constructor(x, y, z, w) {
@@ -158,6 +200,78 @@ export class Quat {
         const s1 = Math.sin(theta) / sinTheta0;
         return new Quat(s0 * a.x + s1 * bx, s0 * a.y + s1 * by, s0 * a.z + s1 * bz, s0 * a.w + s1 * bw);
     }
+    // out = a * b (quaternion multiplication, rotation composition).
+    // Safe when out === a or out === b.
+    static multiplyInto(a, b, out) {
+        const ax = a.x, ay = a.y, az = a.z, aw = a.w;
+        const bx = b.x, by = b.y, bz = b.z, bw = b.w;
+        out.x = aw * bx + ax * bw + ay * bz - az * by;
+        out.y = aw * by - ax * bz + ay * bw + az * bx;
+        out.z = aw * bz + ax * by - ay * bx + az * bw;
+        out.w = aw * bw - ax * bx - ay * by - az * bz;
+        return out;
+    }
+    // out = quat from axis (unnormalized) and angle.
+    static fromAxisAngleInto(ax, ay, az, angle, out) {
+        const len = Math.sqrt(ax * ax + ay * ay + az * az);
+        const invLen = len > 0 ? 1 / len : 0;
+        const nx = ax * invLen, ny = ay * invLen, nz = az * invLen;
+        const half = angle * 0.5;
+        const s = Math.sin(half), c = Math.cos(half);
+        out.x = nx * s;
+        out.y = ny * s;
+        out.z = nz * s;
+        out.w = c;
+        return out;
+    }
+    // out = slerp(a, b, t). Safe when out === a or out === b.
+    static slerpInto(a, b, t, out) {
+        let cos = a.x * b.x + a.y * b.y + a.z * b.z + a.w * b.w;
+        let bx = b.x, by = b.y, bz = b.z, bw = b.w;
+        if (cos < 0) {
+            cos = -cos;
+            bx = -bx;
+            by = -by;
+            bz = -bz;
+            bw = -bw;
+        }
+        if (cos > 0.9995) {
+            const x = a.x + t * (bx - a.x);
+            const y = a.y + t * (by - a.y);
+            const z = a.z + t * (bz - a.z);
+            const w = a.w + t * (bw - a.w);
+            const invLen = 1 / Math.hypot(x, y, z, w);
+            out.x = x * invLen;
+            out.y = y * invLen;
+            out.z = z * invLen;
+            out.w = w * invLen;
+            return out;
+        }
+        const theta0 = Math.acos(cos);
+        const sinTheta0 = Math.sin(theta0);
+        const theta = theta0 * t;
+        const s0 = Math.sin(theta0 - theta) / sinTheta0;
+        const s1 = Math.sin(theta) / sinTheta0;
+        out.x = s0 * a.x + s1 * bx;
+        out.y = s0 * a.y + s1 * by;
+        out.z = s0 * a.z + s1 * bz;
+        out.w = s0 * a.w + s1 * bw;
+        return out;
+    }
+    setXYZW(x, y, z, w) {
+        this.x = x;
+        this.y = y;
+        this.z = z;
+        this.w = w;
+        return this;
+    }
+    setIdentity() {
+        this.x = 0;
+        this.y = 0;
+        this.z = 0;
+        this.w = 1;
+        return this;
+    }
     // Convert Euler angles to quaternion (ZXY order, left-handed, PMX format)
     static fromEuler(rotX, rotY, rotZ) {
         const cx = Math.cos(rotX * 0.5);
@@ -297,6 +411,124 @@ export class Mat4 {
     clone() {
         return new Mat4(this.values.slice());
     }
+    // Write rotation matrix from quaternion into existing Float32Array (column-major).
+    static fromQuatInto(x, y, z, w, out, offset = 0) {
+        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[offset + 0] = 1 - (yy + zz);
+        out[offset + 1] = xy + wz;
+        out[offset + 2] = xz - wy;
+        out[offset + 3] = 0;
+        out[offset + 4] = xy - wz;
+        out[offset + 5] = 1 - (xx + zz);
+        out[offset + 6] = yz + wx;
+        out[offset + 7] = 0;
+        out[offset + 8] = xz + wy;
+        out[offset + 9] = yz - wx;
+        out[offset + 10] = 1 - (xx + yy);
+        out[offset + 11] = 0;
+        out[offset + 12] = 0;
+        out[offset + 13] = 0;
+        out[offset + 14] = 0;
+        out[offset + 15] = 1;
+    }
+    // Fused local transform: out = T(bindT) · R(quat) · T(localT).
+    // Result translation = bindT + R * localT; rotation column block = R.
+    // Column-major. Zero allocations.
+    static localTransformInto(bx, by, bz, qx, qy, qz, qw, lx, ly, lz, out) {
+        const x2 = qx + qx, y2 = qy + qy, z2 = qz + qz;
+        const xx = qx * x2, xy = qx * y2, xz = qx * z2;
+        const yy = qy * y2, yz = qy * z2, zz = qz * z2;
+        const wx = qw * x2, wy = qw * y2, wz = qw * z2;
+        const m00 = 1 - (yy + zz), m01 = xy + wz, m02 = xz - wy;
+        const m10 = xy - wz, m11 = 1 - (xx + zz), m12 = yz + wx;
+        const m20 = xz + wy, m21 = yz - wx, m22 = 1 - (xx + yy);
+        out[0] = m00;
+        out[1] = m01;
+        out[2] = m02;
+        out[3] = 0;
+        out[4] = m10;
+        out[5] = m11;
+        out[6] = m12;
+        out[7] = 0;
+        out[8] = m20;
+        out[9] = m21;
+        out[10] = m22;
+        out[11] = 0;
+        out[12] = bx + m00 * lx + m10 * ly + m20 * lz;
+        out[13] = by + m01 * lx + m11 * ly + m21 * lz;
+        out[14] = bz + m02 * lx + m12 * ly + m22 * lz;
+        out[15] = 1;
+    }
+    // Write position+rotation transform into existing Float32Array.
+    static fromPositionRotationInto(px, py, pz, qx, qy, qz, qw, out) {
+        Mat4.fromQuatInto(qx, qy, qz, qw, out, 0);
+        out[12] = px;
+        out[13] = py;
+        out[14] = pz;
+    }
+    // In-place 4x4 inverse into out array. Returns true on success, false if singular (out untouched).
+    static inverseInto(m, out) {
+        const a00 = m[0], a01 = m[1], a02 = m[2], a03 = m[3];
+        const a10 = m[4], a11 = m[5], a12 = m[6], a13 = m[7];
+        const a20 = m[8], a21 = m[9], a22 = m[10], a23 = m[11];
+        const a30 = m[12], a31 = m[13], a32 = m[14], a33 = m[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 (Math.abs(det) < 1e-10)
+            return false;
+        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 true;
+    }
+    // Copy only the rotation (upper-left 3x3) of src into dst, zero out translation, identity w.
+    // Column-major in both.
+    static copyRotationInto(src, dst) {
+        dst[0] = src[0];
+        dst[1] = src[1];
+        dst[2] = src[2];
+        dst[3] = 0;
+        dst[4] = src[4];
+        dst[5] = src[5];
+        dst[6] = src[6];
+        dst[7] = 0;
+        dst[8] = src[8];
+        dst[9] = src[9];
+        dst[10] = src[10];
+        dst[11] = 0;
+        dst[12] = 0;
+        dst[13] = 0;
+        dst[14] = 0;
+        dst[15] = 1;
+    }
     static fromQuat(x, y, z, w) {
         // Column-major rotation matrix from quaternion (matches glMatrix/WGSL)
         const out = new Float32Array(16);
@@ -338,6 +570,48 @@ export class Mat4 {
     toQuat() {
         return Mat4.toQuatFromArray(this.values, 0);
     }
+    // Extract quaternion from matrix array into an existing Quat (no allocation).
+    static toQuatFromArrayInto(m, offset, out) {
+        const m00 = m[offset + 0], m01 = m[offset + 4], m02 = m[offset + 8];
+        const m10 = m[offset + 1], m11 = m[offset + 5], m12 = m[offset + 9];
+        const m20 = m[offset + 2], m21 = m[offset + 6], m22 = m[offset + 10];
+        const trace = m00 + m11 + m22;
+        let x = 0, y = 0, z = 0, w = 1;
+        if (trace > 0) {
+            const s = Math.sqrt(trace + 1.0) * 2;
+            w = 0.25 * s;
+            x = (m21 - m12) / s;
+            y = (m02 - m20) / s;
+            z = (m10 - m01) / s;
+        }
+        else if (m00 > m11 && m00 > m22) {
+            const s = Math.sqrt(1.0 + m00 - m11 - m22) * 2;
+            w = (m21 - m12) / s;
+            x = 0.25 * s;
+            y = (m01 + m10) / s;
+            z = (m02 + m20) / s;
+        }
+        else if (m11 > m22) {
+            const s = Math.sqrt(1.0 + m11 - m00 - m22) * 2;
+            w = (m02 - m20) / s;
+            x = (m01 + m10) / s;
+            y = 0.25 * s;
+            z = (m12 + m21) / s;
+        }
+        else {
+            const s = Math.sqrt(1.0 + m22 - m00 - m11) * 2;
+            w = (m10 - m01) / s;
+            x = (m02 + m20) / s;
+            y = (m12 + m21) / s;
+            z = 0.25 * s;
+        }
+        const invLen = 1 / Math.hypot(x, y, z, w);
+        out.x = x * invLen;
+        out.y = y * invLen;
+        out.z = z * invLen;
+        out.w = w * invLen;
+        return out;
+    }
     // Static method to extract quaternion from matrix array (avoids creating Mat4 object)
     static toQuatFromArray(m, offset) {
         const m00 = m[offset + 0], m01 = m[offset + 4], m02 = m[offset + 8];
@@ -452,3 +726,29 @@ export class Mat4 {
         return new Mat4(out);
     }
 }
+// Preallocated scratch instances for hot paths. Each subsystem should use its own
+// slot to avoid cross-call stomping. Bump the count if more call sites need scratch.
+export const scratchMat4Values = [
+    new Float32Array(16),
+    new Float32Array(16),
+    new Float32Array(16),
+    new Float32Array(16),
+    new Float32Array(16),
+    new Float32Array(16),
+];
+export const scratchVec3 = [
+    new Vec3(0, 0, 0),
+    new Vec3(0, 0, 0),
+    new Vec3(0, 0, 0),
+    new Vec3(0, 0, 0),
+    new Vec3(0, 0, 0),
+    new Vec3(0, 0, 0),
+    new Vec3(0, 0, 0),
+    new Vec3(0, 0, 0),
+];
+export const scratchQuat = [
+    new Quat(0, 0, 0, 1),
+    new Quat(0, 0, 0, 1),
+    new Quat(0, 0, 0, 1),
+    new Quat(0, 0, 0, 1),
+];

package/dist/model.d.ts

@@ -110,8 +110,6 @@ export declare class Model {
     private runtimeSkeleton;
     private runtimeMorph;
     private morphsDirty;
-    private cachedIdentityMat1;
-    private cachedIdentityMat2;
     private skinMatricesArray?;
     private tweenState;
     private tweenTimeMs;

package/dist/model.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"model.d.ts","sourceRoot":"","sources":["../src/model.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"model.d.ts","sourceRoot":"","sources":["../src/model.ts"],"names":[],"mappings":"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"}

package/dist/model.js

@@ -1,4 +1,4 @@
-import { Mat4, Quat, Vec3 } from "./math";
+import { Mat4, Quat, Vec3, scratchMat4Values, scratchQuat } from "./math";
 import { Engine } from "./engine";
 import { joinAssetPath } from "./asset-reader";
 import { IKSolverSystem } from "./ik-solver";
@@ -26,9 +26,6 @@ export class Model {
         this.rigidbodies = [];
         this.joints = [];
         this.morphsDirty = false; // Flag indicating if morphs need to be applied
-        // Cached identity matrices to avoid allocations in computeWorldMatrices
-        this.cachedIdentityMat1 = Mat4.identity();
-        this.cachedIdentityMat2 = Mat4.identity();
         this.tweenTimeMs = 0; // Time tracking for tweens (milliseconds)
         // Animation: state and multiple slots (idle, walk, attack, etc.); commit/rollback for action-game style
         this.animationState = new AnimationState();
@@ -864,15 +861,25 @@ export class Model {
             this.computeSingleBoneWorldMatrix(b.parentIndex, applyIK);
         }
         // Get base rotation
-        let boneRot = localRot[boneIndex];
-        // Apply IK rotation if requested
+        const baseRot = localRot[boneIndex];
+        let fx = baseRot.x, fy = baseRot.y, fz = baseRot.z, fw = baseRot.w;
+        // Apply IK rotation if requested: finalRot = ik * base, then normalize
         if (applyIK && ikChainInfo) {
             const chainInfo = ikChainInfo[boneIndex];
             if (chainInfo?.ikRotation) {
-                boneRot = chainInfo.ikRotation.multiply(boneRot).normalize();
+                const ik = chainInfo.ikRotation;
+                const nx = ik.w * fx + ik.x * fw + ik.y * fz - ik.z * fy;
+                const ny = ik.w * fy - ik.x * fz + ik.y * fw + ik.z * fx;
+                const nz = ik.w * fz + ik.x * fy - ik.y * fx + ik.z * fw;
+                const nw = ik.w * fw - ik.x * fx - ik.y * fy - ik.z * fz;
+                const len = Math.sqrt(nx * nx + ny * ny + nz * nz + nw * nw);
+                const inv = len > 0 ? 1 / len : 0;
+                fx = nx * inv;
+                fy = ny * inv;
+                fz = nz * inv;
+                fw = nw * inv;
             }
         }
-        let rotateM = Mat4.fromQuat(boneRot.x, boneRot.y, boneRot.z, boneRot.w);
         let addLocalTx = 0, addLocalTy = 0, addLocalTz = 0;
         // Handle append transformations (same logic as computeWorldMatrices)
         const appendParentIdx = b.appendParentIndex;
@@ -885,16 +892,11 @@ export class Model {
             const hasRatio = Math.abs(ratio) > 1e-6;
             if (hasRatio) {
                 if (b.appendRotate) {
-                    // Get append parent's rotation
-                    // During IK solving, use only base local rotation (not IK rotations) to avoid
-                    // conflicts with IK rotations that are still being computed incrementally
-                    // IK rotations will be applied to localRotations after IK solving completes
+                    // Recurse first (may touch scratch); all scratch use below happens after it unwinds
                     if (appendParentIdx >= 0) {
-                        // Compute append parent's world matrix for dependency order, but use base rotation for append
                         this.computeSingleBoneWorldMatrix(appendParentIdx, applyIK);
                     }
-                    // Use append parent's base local rotation only (IK rotations are applied after solving)
-                    let appendRot = localRot[appendParentIdx];
+                    const appendRot = localRot[appendParentIdx];
                     let ax = appendRot.x, ay = appendRot.y, az = appendRot.z;
                     const aw = appendRot.w;
                     const absRatio = ratio < 0 ? -ratio : ratio;
@@ -903,9 +905,20 @@ export class Model {
                         ay = -ay;
                         az = -az;
                     }
-                    const appendQuat = new Quat(ax, ay, az, aw);
-                    const result = Quat.slerp(Quat.identity(), appendQuat, absRatio);
-                    rotateM = Mat4.fromQuat(result.x, result.y, result.z, result.w).multiply(rotateM);
+                    // slerp(identity, appendQuat, absRatio) into scratchQuat[1]
+                    scratchQuat[0].setXYZW(ax, ay, az, aw);
+                    scratchQuat[2].setIdentity();
+                    Quat.slerpInto(scratchQuat[2], scratchQuat[0], absRatio, scratchQuat[1]);
+                    // finalRot = slerpResult * finalRot (rotation composition as quat mul)
+                    const sx = scratchQuat[1].x, sy = scratchQuat[1].y, sz = scratchQuat[1].z, sw = scratchQuat[1].w;
+                    const nx = sw * fx + sx * fw + sy * fz - sz * fy;
+                    const ny = sw * fy - sx * fz + sy * fw + sz * fx;
+                    const nz = sw * fz + sx * fy - sy * fx + sz * fw;
+                    const nw = sw * fw - sx * fx - sy * fy - sz * fz;
+                    fx = nx;
+                    fy = ny;
+                    fz = nz;
+                    fw = nw;
                 }
                 if (b.appendMove) {
                     const appendTrans = localTrans[appendParentIdx];
@@ -919,18 +932,16 @@ export class Model {
         const localTx = boneTrans.x + addLocalTx;
         const localTy = boneTrans.y + addLocalTy;
         const localTz = boneTrans.z + addLocalTz;
-        this.cachedIdentityMat1
-            .setIdentity()
-            .translateInPlace(b.bindTranslation[0], b.bindTranslation[1], b.bindTranslation[2]);
-        this.cachedIdentityMat2.setIdentity().translateInPlace(localTx, localTy, localTz);
-        const localM = this.cachedIdentityMat1.multiply(rotateM).multiply(this.cachedIdentityMat2);
+        // Fused local transform: T_bind · R(finalRot) · T_local → scratchMat4Values[0]
+        const localMVals = scratchMat4Values[0];
+        Mat4.localTransformInto(b.bindTranslation[0], b.bindTranslation[1], b.bindTranslation[2], fx, fy, fz, fw, localTx, localTy, localTz, localMVals);
         const worldMat = worldMats[boneIndex];
         if (b.parentIndex >= 0) {
             const parentMat = worldMats[b.parentIndex];
-            Mat4.multiplyArrays(parentMat.values, 0, localM.values, 0, worldMat.values, 0);
+            Mat4.multiplyArrays(parentMat.values, 0, localMVals, 0, worldMat.values, 0);
         }
         else {
-            worldMat.values.set(localM.values);
+            worldMat.values.set(localMVals);
         }
     }
     computeWorldMatrices() {
@@ -950,10 +961,14 @@ export class Model {
             if (b.parentIndex >= boneCount) {
                 console.warn(`[RZM] bone ${i} parent out of range: ${b.parentIndex}`);
             }
+            // Ensure parent is computed FIRST, before we touch any scratch buffers.
+            // Recursion may itself use scratchMat4Values[0] / scratchQuat; doing it up
+            // front keeps the current frame's scratch slots untouched when we use them below.
+            if (b.parentIndex >= 0 && !computed[b.parentIndex])
+                computeWorld(b.parentIndex);
             const boneRot = localRot[i];
-            let rotateM = Mat4.fromQuat(boneRot.x, boneRot.y, boneRot.z, boneRot.w);
+            let fx = boneRot.x, fy = boneRot.y, fz = boneRot.z, fw = boneRot.w;
             let addLocalTx = 0, addLocalTy = 0, addLocalTz = 0;
-            // Optimized append rotation check - only check necessary conditions
             const appendParentIdx = b.appendParentIndex;
             const hasAppend = b.appendRotate && appendParentIdx !== undefined && appendParentIdx >= 0 && appendParentIdx < boneCount;
             if (hasAppend) {
@@ -962,9 +977,7 @@ export class Model {
                 if (hasRatio) {
                     if (b.appendRotate) {
                         const appendRot = localRot[appendParentIdx];
-                        let ax = appendRot.x;
-                        let ay = appendRot.y;
-                        let az = appendRot.z;
+                        let ax = appendRot.x, ay = appendRot.y, az = appendRot.z;
                         const aw = appendRot.w;
                         const absRatio = ratio < 0 ? -ratio : ratio;
                         if (ratio < 0) {
@@ -972,9 +985,19 @@ export class Model {
                             ay = -ay;
                             az = -az;
                         }
-                        const appendQuat = new Quat(ax, ay, az, aw);
-                        const result = Quat.slerp(Quat.identity(), appendQuat, absRatio);
-                        rotateM = Mat4.fromQuat(result.x, result.y, result.z, result.w).multiply(rotateM);
+                        scratchQuat[0].setXYZW(ax, ay, az, aw);
+                        scratchQuat[2].setIdentity();
+                        Quat.slerpInto(scratchQuat[2], scratchQuat[0], absRatio, scratchQuat[1]);
+                        // finalRot = slerpResult * finalRot (quat mul)
+                        const sx = scratchQuat[1].x, sy = scratchQuat[1].y, sz = scratchQuat[1].z, sw = scratchQuat[1].w;
+                        const nx = sw * fx + sx * fw + sy * fz - sz * fy;
+                        const ny = sw * fy - sx * fz + sy * fw + sz * fx;
+                        const nz = sw * fz + sx * fy - sy * fx + sz * fw;
+                        const nw = sw * fw - sx * fx - sy * fy - sz * fz;
+                        fx = nx;
+                        fy = ny;
+                        fz = nz;
+                        fw = nw;
                     }
                     if (b.appendMove) {
                         const appendTrans = localTrans[appendParentIdx];
@@ -985,27 +1008,19 @@ export class Model {
                     }
                 }
             }
-            // Build local matrix: identity + bind translation, then rotation, then local translation, then append translation
             const boneTrans = localTrans[i];
             const localTx = boneTrans.x + addLocalTx;
             const localTy = boneTrans.y + addLocalTy;
             const localTz = boneTrans.z + addLocalTz;
-            this.cachedIdentityMat1
-                .setIdentity()
-                .translateInPlace(b.bindTranslation[0], b.bindTranslation[1], b.bindTranslation[2]);
-            this.cachedIdentityMat2.setIdentity().translateInPlace(localTx, localTy, localTz);
-            const localM = this.cachedIdentityMat1.multiply(rotateM).multiply(this.cachedIdentityMat2);
+            const localMVals = scratchMat4Values[0];
+            Mat4.localTransformInto(b.bindTranslation[0], b.bindTranslation[1], b.bindTranslation[2], fx, fy, fz, fw, localTx, localTy, localTz, localMVals);
             const worldMat = worldMats[i];
             if (b.parentIndex >= 0) {
-                const p = b.parentIndex;
-                if (!computed[p])
-                    computeWorld(p);
-                const parentMat = worldMats[p];
-                // Multiply parent world matrix by local matrix
-                Mat4.multiplyArrays(parentMat.values, 0, localM.values, 0, worldMat.values, 0);
+                const parentMat = worldMats[b.parentIndex];
+                Mat4.multiplyArrays(parentMat.values, 0, localMVals, 0, worldMat.values, 0);
             }
             else {
-                worldMat.values.set(localM.values);
+                worldMat.values.set(localMVals);
             }
             computed[i] = true;
         };

package/dist/physics.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"physics.d.ts","sourceRoot":"","sources":["../src/physics.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"physics.d.ts","sourceRoot":"","sources":["../src/physics.ts"],"names":[],"mappings":"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"}

package/dist/physics.js

@@ -1,4 +1,10 @@
 import { Quat, Vec3, Mat4 } from "./math";
+// Physics-local scratch pool for per-frame sync (syncFromBones, applyAmmoRigidbodiesToBones).
+// Each method uses only these slots and completes synchronously before the next is called.
+const _physMat = [
+    new Float32Array(16), new Float32Array(16), new Float32Array(16),
+];
+const _physQuat = new Quat(0, 0, 0, 1);
 import { loadAmmo } from "./ammo-loader";
 export var RigidbodyShape;
 (function (RigidbodyShape) {
@@ -358,9 +364,9 @@ export class Physics {
             this.firstFrame = false;
         }
         // Step order: 1) Sync Static/Kinematic from bones, 2) Step physics, 3) Apply dynamic to bones
-        this.syncFromBones(boneWorldMatrices, boneInverseBindMatrices, boneCount);
+        this.syncFromBones(boneWorldMatrices, boneCount);
         this.stepAmmoPhysics(dt);
-        this.applyAmmoRigidbodiesToBones(boneWorldMatrices, boneInverseBindMatrices, boneCount);
+        this.applyAmmoRigidbodiesToBones(boneWorldMatrices, boneCount);
     }
     // Compute bodyOffsetMatrixInverse for all rigidbodies (called once during initialization)
     computeBodyOffsets(boneInverseBindMatrices, boneCount) {
@@ -425,7 +431,7 @@ export class Physics {
         }
     }
     // Sync Static (FollowBone) and Kinematic rigidbodies to follow bone transforms
-    syncFromBones(boneWorldMatrices, boneInverseBindMatrices, boneCount) {
+    syncFromBones(boneWorldMatrices, boneCount) {
         if (!this.ammo || !this.dynamicsWorld)
             return;
         const Ammo = this.ammo;
@@ -440,14 +446,17 @@ export class Physics {
                 rb.boneIndex < boneCount) {
                 const boneIdx = rb.boneIndex;
                 const boneWorldMat = boneWorldMatrices[boneIdx];
-                // nodeWorld = boneWorld × shapeLocal (not shapeLocal × boneWorld)
-                const bodyOffsetMatrix = rb.bodyOffsetMatrix || rb.bodyOffsetMatrixInverse.inverse();
-                const nodeWorldMatrix = boneWorldMat.multiply(bodyOffsetMatrix);
-                const worldPos = nodeWorldMatrix.getPosition();
-                const worldRot = nodeWorldMatrix.toQuat();
+                // Lazy-cache bodyOffsetMatrix on first hit (cold path).
+                if (!rb.bodyOffsetMatrix)
+                    rb.bodyOffsetMatrix = rb.bodyOffsetMatrixInverse.inverse();
+                // nodeWorld = boneWorld × bodyOffsetMatrix → _physMat[0]
+                Mat4.multiplyArrays(boneWorldMat.values, 0, rb.bodyOffsetMatrix.values, 0, _physMat[0], 0);
+                const nodeVals = _physMat[0];
+                const wx = nodeVals[12], wy = nodeVals[13], wz = nodeVals[14];
+                Mat4.toQuatFromArrayInto(nodeVals, 0, _physQuat);
                 const transform = new Ammo.btTransform();
-                const pos = new Ammo.btVector3(worldPos.x, worldPos.y, worldPos.z);
-                const quat = new Ammo.btQuaternion(worldRot.x, worldRot.y, worldRot.z, worldRot.w);
+                const pos = new Ammo.btVector3(wx, wy, wz);
+                const quat = new Ammo.btQuaternion(_physQuat.x, _physQuat.y, _physQuat.z, _physQuat.w);
                 transform.setOrigin(pos);
                 transform.setRotation(quat);
                 ammoBody.setWorldTransform(transform);
@@ -472,7 +481,7 @@ export class Physics {
         this.dynamicsWorld.stepSimulation(dt, maxSubSteps, fixedTimeStep);
     }
     // Apply dynamic rigidbody world transforms to bone world matrices in-place
-    applyAmmoRigidbodiesToBones(boneWorldMatrices, boneInverseBindMatrices, boneCount) {
+    applyAmmoRigidbodiesToBones(boneWorldMatrices, boneCount) {
         if (!this.ammo || !this.dynamicsWorld)
             return;
         for (let i = 0; i < this.rigidbodies.length; i++) {
@@ -486,14 +495,13 @@ export class Physics {
                 const transform = ammoBody.getWorldTransform();
                 const origin = transform.getOrigin();
                 const rotation = transform.getRotation();
-                const nodePos = new Vec3(origin.x(), origin.y(), origin.z());
-                const nodeRot = new Quat(rotation.x(), rotation.y(), rotation.z(), rotation.w());
-                const nodeWorldMatrix = Mat4.fromPositionRotation(nodePos, nodeRot);
-                // boneWorld = nodeWorld × bodyOffsetMatrixInverse (not bodyOffsetMatrixInverse × nodeWorld)
-                const boneWorldMat = nodeWorldMatrix.multiply(rb.bodyOffsetMatrixInverse);
-                const values = boneWorldMat.values;
-                if (!isNaN(values[0]) && !isNaN(values[15]) && Math.abs(values[0]) < 1e6 && Math.abs(values[15]) < 1e6) {
-                    boneWorldMatrices[boneIdx].values.set(values);
+                // nodeWorldMatrix → _physMat[0] (from ammo position/rotation directly)
+                Mat4.fromPositionRotationInto(origin.x(), origin.y(), origin.z(), rotation.x(), rotation.y(), rotation.z(), rotation.w(), _physMat[0]);
+                // boneWorld = nodeWorld × bodyOffsetMatrixInverse → _physMat[1]
+                const boneVals = _physMat[1];
+                Mat4.multiplyArrays(_physMat[0], 0, rb.bodyOffsetMatrixInverse.values, 0, boneVals, 0);
+                if (!isNaN(boneVals[0]) && !isNaN(boneVals[15]) && Math.abs(boneVals[0]) < 1e6 && Math.abs(boneVals[15]) < 1e6) {
+                    boneWorldMatrices[boneIdx].values.set(boneVals);
                 }
                 else {
                     console.warn(`[Physics] Invalid bone world matrix for rigidbody ${i} (${rb.name}), skipping update`);