reze-engine 0.15.0 → 0.16.0

package/dist/model.js

@@ -6,6 +6,13 @@ import { VMDLoader } from "./vmd-loader";
 import { VMDWriter } from "./vmd-writer";
 import { AnimationState, interpolateControlPoints, rawInterpolationToBoneInterpolation, } from "./animation";
 const VERTEX_STRIDE = 8;
+// Animation-sampling scratch (applyPoseFromClip → convertVMDTranslationToLocal). These
+// run sequentially and are not reentrant with the world-matrix scratch in math.ts, so
+// plain module singletons are safe and let the per-bone sample path allocate nothing.
+const _animSlerp = new Quat(0, 0, 0, 1);
+const _animInterpT = new Vec3(0, 0, 0);
+const _convOut = new Vec3(0, 0, 0);
+const _convMat = new Float32Array(16);
 export class Model {
     get name() {
         return this._name;
@@ -37,6 +44,15 @@ export class Model {
     }
     constructor(vertexData, indexData, textures, materials, skeleton, skinning, morphing, rigidbodies = [], joints = []) {
         this._name = "";
+        this.morphPrevMinVert = -1; // vertices touched by last applyMorphs (reset to base this pass)
+        this.morphPrevMaxVert = -1;
+        this.morphPendingMinVert = -1; // accumulated range awaiting a GPU upload
+        this.morphPendingMaxVert = -1;
+        this.morphUploadFull = true; // first upload after load pushes the whole buffer once
+        // GPU morph path: when enabled (engine set up the compute buffers), applyMorphs only
+        // resolves effective weights and flags them dirty — the compute pass does the vertex work.
+        this.gpuMorphEnabled = false;
+        this.morphWeightsDirty = false;
         this.textures = [];
         this.materials = [];
         // Physics data from PMX
@@ -141,6 +157,58 @@ export class Model {
         }
         this.runtimeSkeleton.ikChainInfo = ikChainInfo;
         this.runtimeSkeleton.ikSolvers = ikSolvers;
+        this.buildDeformOrder();
+    }
+    // Precompute the bone order that computeWorldMatrices iterates every frame: every
+    // bone appears after its parent. This is the exact finishing order the previous
+    // recursive computeWorld() produced (walk up the not-yet-emitted ancestor chain,
+    // then emit it top-down; ties broken by ascending index) — so behavior is identical,
+    // minus the per-frame closure + visited-array allocation and the recursion overhead.
+    buildDeformOrder() {
+        const bones = this.skeleton.bones;
+        const n = bones.length;
+        const order = new Int32Array(n);
+        const done = new Uint8Array(n);
+        const stack = [];
+        let k = 0;
+        for (let i = 0; i < n; i++) {
+            if (done[i])
+                continue;
+            stack.length = 0;
+            let cur = i;
+            // Collect the chain of not-yet-emitted ancestors up to the root (or a done one).
+            while (cur >= 0 && cur < n && !done[cur]) {
+                stack.push(cur);
+                cur = bones[cur].parentIndex;
+            }
+            // Emit from the topmost ancestor down so parents precede children.
+            for (let s = stack.length - 1; s >= 0; s--) {
+                const b = stack[s];
+                done[b] = 1;
+                order[k++] = b;
+            }
+        }
+        this.deformOrder = order;
+        // Accumulate bind-pose world positions in the same parent-before-child order and
+        // with the same add order as the old recursive computeBindPoseWorldPosition, so the
+        // downstream arithmetic stays bit-identical.
+        const bindWorld = new Float32Array(n * 3);
+        for (let idx = 0; idx < n; idx++) {
+            const i = order[idx];
+            const bt = bones[i].bindTranslation;
+            const p = bones[i].parentIndex;
+            if (p >= 0 && p < n) {
+                bindWorld[i * 3 + 0] = bindWorld[p * 3 + 0] + bt[0];
+                bindWorld[i * 3 + 1] = bindWorld[p * 3 + 1] + bt[1];
+                bindWorld[i * 3 + 2] = bindWorld[p * 3 + 2] + bt[2];
+            }
+            else {
+                bindWorld[i * 3 + 0] = bt[0];
+                bindWorld[i * 3 + 1] = bt[1];
+                bindWorld[i * 3 + 2] = bt[2];
+            }
+        }
+        this.bindWorldPos = bindWorld;
     }
     initializeTweenBuffers() {
         const boneCount = this.skeleton.bones.length;
@@ -411,51 +479,50 @@ export class Model {
         }
     }
     // VMD translation (world delta from bind pose) → bone local space; optional rotation for animation vs IK
+    // Returns a REUSED scratch Vec3 (_convOut) — callers must copy immediately (they do:
+    // .set() / destructure). Zero allocation; result is bit-identical to the previous
+    // recursive implementation (verified numerically).
     convertVMDTranslationToLocal(boneIdx, vmdRelativeTranslation, rotation) {
-        const skeleton = this.skeleton;
-        const bones = skeleton.bones;
-        const localRot = this.runtimeSkeleton.localRotations;
-        // Compute bind pose world positions for all bones
-        const computeBindPoseWorldPosition = (idx) => {
-            const bone = bones[idx];
-            const bindPos = new Vec3(bone.bindTranslation[0], bone.bindTranslation[1], bone.bindTranslation[2]);
-            if (bone.parentIndex >= 0 && bone.parentIndex < bones.length) {
-                const parentWorldPos = computeBindPoseWorldPosition(bone.parentIndex);
-                return parentWorldPos.add(bindPos);
-            }
-            else {
-                return bindPos;
-            }
-        };
-        const bone = bones[boneIdx];
-        // VMD translation is relative to bind pose world position
-        // targetWorldPos = bindPoseWorldPos + vmdRelativeTranslation
-        const bindPoseWorldPos = computeBindPoseWorldPosition(boneIdx);
-        const targetWorldPos = bindPoseWorldPos.add(vmdRelativeTranslation);
-        // Convert target world position to local translation
-        // We need parent's bind pose world position to transform to parent space
-        let parentBindPoseWorldPos;
-        if (bone.parentIndex >= 0) {
-            parentBindPoseWorldPos = computeBindPoseWorldPosition(bone.parentIndex);
+        const bone = this.skeleton.bones[boneIdx];
+        const bindWorld = this.bindWorldPos;
+        const bt = bone.bindTranslation;
+        const p = bone.parentIndex;
+        // afterBindTranslation = (bindWorld[bone] + vmd − bindWorld[parent]) − bindTranslation.
+        // (Algebraically this reduces to vmd, since bindWorld[bone] = bindWorld[parent] +
+        // bindTranslation, but the explicit form keeps the result bit-identical to before.)
+        const bi3 = boneIdx * 3;
+        const targetX = bindWorld[bi3 + 0] + vmdRelativeTranslation.x;
+        const targetY = bindWorld[bi3 + 1] + vmdRelativeTranslation.y;
+        const targetZ = bindWorld[bi3 + 2] + vmdRelativeTranslation.z;
+        const px = p >= 0 ? bindWorld[p * 3 + 0] : 0;
+        const py = p >= 0 ? bindWorld[p * 3 + 1] : 0;
+        const pz = p >= 0 ? bindWorld[p * 3 + 2] : 0;
+        const abx = targetX - px - bt[0];
+        const aby = targetY - py - bt[1];
+        const abz = targetZ - pz - bt[2];
+        // Inverse rotation = conjugate + normalize (matches localRotation.clone().conjugate()
+        // .normalize()), applied via a rotation matrix (matches Mat4.fromQuat). Uses animation
+        // rotation when provided so IK-modified localRot doesn't perturb the conversion.
+        const q = rotation ?? this.runtimeSkeleton.localRotations[boneIdx];
+        const qlen = Math.sqrt(q.x * q.x + q.y * q.y + q.z * q.z + q.w * q.w);
+        let ix, iy, iz, iw;
+        if (qlen === 0) {
+            ix = 0;
+            iy = 0;
+            iz = 0;
+            iw = 1;
         }
         else {
-            parentBindPoseWorldPos = Vec3.zeros();
+            const inv = 1 / qlen;
+            ix = -q.x * inv;
+            iy = -q.y * inv;
+            iz = -q.z * inv;
+            iw = q.w * inv;
         }
-        // Transform target world position to parent's local space
-        // In bind pose, parent's world matrix is just a translation
-        const parentSpacePos = targetWorldPos.subtract(parentBindPoseWorldPos);
-        // Subtract bindTranslation to get position after bind translation
-        const afterBindTranslation = parentSpacePos.subtract(new Vec3(bone.bindTranslation[0], bone.bindTranslation[1], bone.bindTranslation[2]));
-        // Apply inverse rotation to get local translation
-        // Use provided rotation (animation rotation) or fall back to current localRotation
-        // Using animation rotation prevents conflicts when IK modifies the rotation
-        const localRotation = rotation ?? localRot[boneIdx];
-        // Clone to avoid mutating, then conjugate and normalize
-        const invRotation = localRotation.clone().conjugate().normalize();
-        const rotationMat = Mat4.fromQuat(invRotation.x, invRotation.y, invRotation.z, invRotation.w);
-        const rm = rotationMat.values;
-        const localTranslation = new Vec3(rm[0] * afterBindTranslation.x + rm[4] * afterBindTranslation.y + rm[8] * afterBindTranslation.z, rm[1] * afterBindTranslation.x + rm[5] * afterBindTranslation.y + rm[9] * afterBindTranslation.z, rm[2] * afterBindTranslation.x + rm[6] * afterBindTranslation.y + rm[10] * afterBindTranslation.z);
-        return localTranslation;
+        Mat4.fromQuatInto(ix, iy, iz, iw, _convMat, 0);
+        const rm = _convMat;
+        _convOut.setXYZ(rm[0] * abx + rm[4] * aby + rm[8] * abz, rm[1] * abx + rm[5] * aby + rm[9] * abz, rm[2] * abx + rm[6] * aby + rm[10] * abz);
+        return _convOut;
     }
     getWorldMatrices() {
         return this.runtimeSkeleton.worldMatrices;
@@ -552,13 +619,15 @@ export class Model {
         this.applyMorphs();
     }
     applyMorphs() {
-        // Reset vertex data to base positions
-        this.vertexData.set(this.baseVertexData);
         const vertexCount = this.vertexCount;
         const morphCount = this.morphing.morphs.length;
         const weights = this.runtimeMorph.weights;
-        // First pass: Compute effective weights for all morphs (handling group morphs)
-        const effectiveWeights = new Float32Array(morphCount);
+        // Effective weights (group-morph resolution + clamp). Both paths need these: the GPU
+        // path uploads them for the compute pass; the CPU path applies them below. Reused buffer.
+        if (!this.morphEffectiveWeights || this.morphEffectiveWeights.length !== morphCount) {
+            this.morphEffectiveWeights = new Float32Array(morphCount);
+        }
+        const effectiveWeights = this.morphEffectiveWeights;
         effectiveWeights.set(weights); // Start with direct weights
         // Apply group morphs: group morph weight * ratio affects referenced morphs
         for (let morphIdx = 0; morphIdx < morphCount; morphIdx++) {
@@ -568,18 +637,30 @@ export class Model {
                 if (groupWeight > 0.0001) {
                     for (const ref of morph.groupReferences) {
                         if (ref.morphIndex >= 0 && ref.morphIndex < morphCount) {
-                            // Add group morph's contribution to the referenced morph
                             effectiveWeights[ref.morphIndex] += groupWeight * ref.ratio;
                         }
                     }
                 }
             }
         }
-        // Clamp effective weights to [0, 1]
         for (let i = 0; i < morphCount; i++) {
             effectiveWeights[i] = Math.max(0, Math.min(1, effectiveWeights[i]));
         }
-        // Second pass: Apply vertex morphs with their effective weights
+        // GPU path: the compute pass applies the vertex offsets from these weights.
+        if (this.gpuMorphEnabled) {
+            this.morphWeightsDirty = true;
+            return;
+        }
+        // ── CPU path ── Reset only the vertices morphed by the previous pass back to base
+        // (targeted reset; vertexData never diverges from base outside that range).
+        if (this.morphPrevMaxVert >= 0) {
+            const s = this.morphPrevMinVert * VERTEX_STRIDE;
+            const e = (this.morphPrevMaxVert + 1) * VERTEX_STRIDE;
+            this.vertexData.set(this.baseVertexData.subarray(s, e), s);
+        }
+        // Apply vertex morphs, tracking the touched vertex-index range for partial upload.
+        let curMinVert = -1;
+        let curMaxVert = -1;
         for (let morphIdx = 0; morphIdx < morphCount; morphIdx++) {
             const effectiveWeight = effectiveWeights[morphIdx];
             if (effectiveWeight === 0 || effectiveWeight < 0.0001)
@@ -587,26 +668,136 @@ export class Model {
             const morph = this.morphing.morphs[morphIdx];
             if (morph.type !== 1)
                 continue; // Only process vertex morphs
-            // For vertex morphs, iterate through vertices that have offsets
             for (const vertexOffset of morph.vertexOffsets) {
                 const vIdx = vertexOffset.vertexIndex;
                 if (vIdx < 0 || vIdx >= vertexCount)
                     continue;
-                // Get morph offset for this vertex
                 const offsetX = vertexOffset.positionOffset[0];
                 const offsetY = vertexOffset.positionOffset[1];
                 const offsetZ = vertexOffset.positionOffset[2];
-                // Skip if offset is zero
                 if (Math.abs(offsetX) < 0.0001 && Math.abs(offsetY) < 0.0001 && Math.abs(offsetZ) < 0.0001) {
                     continue;
                 }
-                // Apply weighted offset to vertex position (positions are at stride 0, 8, 16, ...)
                 const vertexIdx = vIdx * VERTEX_STRIDE;
                 this.vertexData[vertexIdx] += offsetX * effectiveWeight;
                 this.vertexData[vertexIdx + 1] += offsetY * effectiveWeight;
                 this.vertexData[vertexIdx + 2] += offsetZ * effectiveWeight;
+                if (curMinVert < 0 || vIdx < curMinVert)
+                    curMinVert = vIdx;
+                if (vIdx > curMaxVert)
+                    curMaxVert = vIdx;
+            }
+        }
+        let dirtyMin = curMinVert;
+        let dirtyMax = curMaxVert;
+        if (this.morphPrevMaxVert >= 0) {
+            if (dirtyMin < 0 || this.morphPrevMinVert < dirtyMin)
+                dirtyMin = this.morphPrevMinVert;
+            if (this.morphPrevMaxVert > dirtyMax)
+                dirtyMax = this.morphPrevMaxVert;
+        }
+        if (dirtyMin >= 0 && dirtyMax >= 0) {
+            this.morphPendingMinVert =
+                this.morphPendingMinVert < 0 ? dirtyMin : Math.min(this.morphPendingMinVert, dirtyMin);
+            this.morphPendingMaxVert =
+                this.morphPendingMaxVert < 0 ? dirtyMax : Math.max(this.morphPendingMaxVert, dirtyMax);
+        }
+        this.morphPrevMinVert = curMinVert;
+        this.morphPrevMaxVert = curMaxVert;
+    }
+    // ── GPU morph path support ──
+    // Called by the engine once it has created the compute buffers for this model; switches
+    // applyMorphs to the weights-only branch.
+    enableGpuMorphs() {
+        this.gpuMorphEnabled = true;
+    }
+    // True (once) when morph weights changed since the last check — the engine then uploads
+    // getEffectiveMorphWeights() and dispatches the compute pass.
+    consumeMorphWeightsDirty() {
+        const d = this.morphWeightsDirty;
+        this.morphWeightsDirty = false;
+        return d;
+    }
+    // Effective (group-resolved, clamped) morph weights for GPU upload. Ensures they're
+    // computed at least once even before the first weight change.
+    getEffectiveMorphWeights() {
+        if (!this.morphEffectiveWeights)
+            this.applyMorphs();
+        return this.morphEffectiveWeights ?? new Float32Array(0);
+    }
+    // Build the CSR inversion of vertex-morph offsets for the GPU compute pass. Returns null
+    // when the model has no vertex-morph offsets (no GPU path needed). Entries for each vertex
+    // are emitted in ascending morph-index order, matching the CPU accumulation order.
+    buildMorphComputeData() {
+        const V = this.vertexCount;
+        const M = this.morphing.morphs.length;
+        const morphs = this.morphing.morphs;
+        const EPS = 0.0001;
+        const isLive = (o) => o.vertexIndex >= 0 &&
+            o.vertexIndex < V &&
+            (Math.abs(o.positionOffset[0]) >= EPS ||
+                Math.abs(o.positionOffset[1]) >= EPS ||
+                Math.abs(o.positionOffset[2]) >= EPS);
+        const counts = new Uint32Array(V);
+        for (let m = 0; m < M; m++) {
+            const morph = morphs[m];
+            if (morph.type !== 1)
+                continue;
+            for (const o of morph.vertexOffsets)
+                if (isLive(o))
+                    counts[o.vertexIndex]++;
+        }
+        const rowStart = new Uint32Array(V + 1);
+        let acc = 0;
+        for (let v = 0; v < V; v++) {
+            rowStart[v] = acc;
+            acc += counts[v];
+        }
+        rowStart[V] = acc;
+        const E = acc;
+        if (E === 0)
+            return null;
+        const colMorph = new Uint32Array(E);
+        const colOffset = new Float32Array(E * 3);
+        const fill = new Uint32Array(V);
+        for (let m = 0; m < M; m++) {
+            const morph = morphs[m];
+            if (morph.type !== 1)
+                continue;
+            for (const o of morph.vertexOffsets) {
+                if (!isLive(o))
+                    continue;
+                const v = o.vertexIndex;
+                const p = rowStart[v] + fill[v]++;
+                colMorph[p] = m;
+                colOffset[p * 3] = o.positionOffset[0];
+                colOffset[p * 3 + 1] = o.positionOffset[1];
+                colOffset[p * 3 + 2] = o.positionOffset[2];
             }
         }
+        const basePositions = new Float32Array(V * 3);
+        for (let v = 0; v < V; v++) {
+            const vi = v * VERTEX_STRIDE;
+            basePositions[v * 3] = this.baseVertexData[vi];
+            basePositions[v * 3 + 1] = this.baseVertexData[vi + 1];
+            basePositions[v * 3 + 2] = this.baseVertexData[vi + 2];
+        }
+        return { basePositions, rowStart, colMorph, colOffset, morphCount: M, vertexCount: V, entryCount: E };
+    }
+    // Consume the pending morph vertex-upload range for the engine. Returns null when a
+    // full upload is needed (first time after load, or nothing tracked), else the inclusive
+    // [minVert, maxVert] slice that changed. Resets pending state.
+    consumeVertexUploadRange() {
+        if (this.morphUploadFull || this.morphPendingMaxVert < 0) {
+            this.morphUploadFull = false;
+            this.morphPendingMinVert = -1;
+            this.morphPendingMaxVert = -1;
+            return null;
+        }
+        const range = { minVert: this.morphPendingMinVert, maxVert: this.morphPendingMaxVert };
+        this.morphPendingMinVert = -1;
+        this.morphPendingMaxVert = -1;
+        return range;
     }
     buildClipFromVmdKeyFrames(vmdKeyFrames) {
         const boneTracksByBone = {};
@@ -835,11 +1026,11 @@ export class Model {
                 const gradient = frameDelta > 0 ? (clampedFrame - frameA.frame) / frameDelta : 0;
                 const interp = frameB.interpolation;
                 const rotT = interpolateControlPoints(interp.rotation, gradient);
-                const rotation = Quat.slerp(frameA.rotation, frameB.rotation, rotT);
+                const rotation = Quat.slerpInto(frameA.rotation, frameB.rotation, rotT, _animSlerp);
                 const txWeight = interpolateControlPoints(interp.translationX, gradient);
                 const tyWeight = interpolateControlPoints(interp.translationY, gradient);
                 const tzWeight = interpolateControlPoints(interp.translationZ, gradient);
-                const interpolatedVMDTranslation = new Vec3(frameA.translation.x + (frameB.translation.x - frameA.translation.x) * txWeight, frameA.translation.y + (frameB.translation.y - frameA.translation.y) * tyWeight, frameA.translation.z + (frameB.translation.z - frameA.translation.z) * tzWeight);
+                const interpolatedVMDTranslation = _animInterpT.setXYZ(frameA.translation.x + (frameB.translation.x - frameA.translation.x) * txWeight, frameA.translation.y + (frameB.translation.y - frameA.translation.y) * tyWeight, frameA.translation.z + (frameB.translation.z - frameA.translation.z) * tzWeight);
                 const localTranslation = this.convertVMDTranslationToLocal(boneIdx, interpolatedVMDTranslation, rotation);
                 localRot.set(rotation);
                 localTrans.set(localTranslation);
@@ -906,10 +1097,14 @@ export class Model {
         if (!ikChainInfo)
             return;
         // Solve each IK solver sequentially, ensuring consistent state between solvers
+        let firstSolver = true;
         for (const solver of ikSolvers) {
-            // Recompute ALL world matrices before each solver starts
-            // This ensures each solver sees the effects of previous solvers on localRotations
-            this.computeWorldMatrices();
+            // Each solver must see the effects of previous solvers on localRotations, so
+            // recompute world matrices between solvers. The first solver is skipped: the
+            // caller (update) already computed them and nothing has changed localRotations yet.
+            if (!firstSolver)
+                this.computeWorldMatrices();
+            firstSolver = false;
             // Clear computed set for this solver's pass
             this.ikComputedSet.clear();
             // Solve this IK chain
@@ -1033,20 +1228,13 @@ export class Model {
         const boneCount = bones.length;
         if (boneCount === 0)
             return;
-        // Local computed array (avoids instance field overhead)
-        const computed = new Array(boneCount).fill(false);
-        const computeWorld = (i) => {
-            if (computed[i])
-                return;
+        // Flat traversal in precomputed order: every bone's parent is already done, so no
+        // per-bone visited check, no recursion, and no per-call allocation. Same per-bone
+        // math as before. Scratch slots are safe to reuse since there's no reentrancy now.
+        const order = this.deformOrder;
+        for (let k = 0; k < boneCount; k++) {
+            const i = order[k];
             const b = bones[i];
-            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 fx = boneRot.x, fy = boneRot.y, fz = boneRot.z, fw = boneRot.w;
             let addLocalTx = 0, addLocalTy = 0, addLocalTz = 0;
@@ -1103,10 +1291,6 @@ export class Model {
             else {
                 worldMat.values.set(localMVals);
             }
-            computed[i] = true;
-        };
-        // Process all bones (recursion handles dependencies automatically)
-        for (let i = 0; i < boneCount; i++)
-            computeWorld(i);
+        }
     }
 }

package/dist/physics/body.d.ts

@@ -22,9 +22,11 @@ export declare class RigidBodyStore {
     readonly bodyOffsetMatrix: Float32Array;
     readonly bodyOffsetInverse: Float32Array;
     private boneOffsetsReady;
+    private collisionPairs;
     constructor(rigidbodies: Rigidbody[]);
     updateAabbs(margin?: number): void;
     computeBoneOffsets(boneInverseBindMatrices: Float32Array): void;
     isBoneOffsetsReady(): boolean;
+    getCollisionPairs(): Uint16Array;
 }
 //# sourceMappingURL=body.d.ts.map

package/dist/physics/body.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"body.d.ts","sourceRoot":"","sources":["../../src/physics/body.ts"],"names":[],"mappings":"AACA,OAAO,EAAiC,KAAK,SAAS,EAAE,MAAM,SAAS,CAAA;AAIvE,qBAAa,cAAc;IACzB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IAEtB,QAAQ,CAAC,SAAS,EAAE,YAAY,CAAA;IAChC,QAAQ,CAAC,YAAY,EAAE,YAAY,CAAA;IACnC,QAAQ,CAAC,gBAAgB,EAAE,YAAY,CAAA;IACvC,QAAQ,CAAC,iBAAiB,EAAE,YAAY,CAAA;IAExC,QAAQ,CAAC,OAAO,EAAE,YAAY,CAAA;IAI9B,QAAQ,CAAC,UAAU,EAAE,YAAY,CAAA;IACjC,QAAQ,CAAC,aAAa,EAAE,YAAY,CAAA;IACpC,QAAQ,CAAC,cAAc,EAAE,YAAY,CAAA;IACrC,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAA;IACzB,QAAQ,CAAC,SAAS,EAAE,UAAU,CAAA;IAC9B,QAAQ,CAAC,QAAQ,EAAE,YAAY,CAAA;IAC/B,QAAQ,CAAC,WAAW,EAAE,YAAY,CAAA;IAIlC,QAAQ,CAAC,cAAc,EAAE,WAAW,CAAA;IACpC,QAAQ,CAAC,eAAe,EAAE,WAAW,CAAA;IAErC,QAAQ,CAAC,KAAK,EAAE,UAAU,CAAA;IAC1B,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAA;IAE3B,QAAQ,CAAC,OAAO,EAAE,YAAY,CAAA;IAC9B,QAAQ,CAAC,OAAO,EAAE,YAAY,CAAA;IAI9B,QAAQ,CAAC,gBAAgB,EAAE,YAAY,CAAA;IACvC,QAAQ,CAAC,iBAAiB,EAAE,YAAY,CAAA;IACxC,OAAO,CAAC,gBAAgB,CAAQ;gBAEpB,WAAW,EAAE,SAAS,EAAE;IA4DpC,WAAW,CAAC,MAAM,SAAM,GAAG,IAAI;IA2F/B,kBAAkB,CAAC,uBAAuB,EAAE,YAAY,GAAG,IAAI;IAqD/D,kBAAkB,IAAI,OAAO;CAG9B"}
+{"version":3,"file":"body.d.ts","sourceRoot":"","sources":["../../src/physics/body.ts"],"names":[],"mappings":"AACA,OAAO,EAAiC,KAAK,SAAS,EAAE,MAAM,SAAS,CAAA;AAIvE,qBAAa,cAAc;IACzB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IAEtB,QAAQ,CAAC,SAAS,EAAE,YAAY,CAAA;IAChC,QAAQ,CAAC,YAAY,EAAE,YAAY,CAAA;IACnC,QAAQ,CAAC,gBAAgB,EAAE,YAAY,CAAA;IACvC,QAAQ,CAAC,iBAAiB,EAAE,YAAY,CAAA;IAExC,QAAQ,CAAC,OAAO,EAAE,YAAY,CAAA;IAI9B,QAAQ,CAAC,UAAU,EAAE,YAAY,CAAA;IACjC,QAAQ,CAAC,aAAa,EAAE,YAAY,CAAA;IACpC,QAAQ,CAAC,cAAc,EAAE,YAAY,CAAA;IACrC,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAA;IACzB,QAAQ,CAAC,SAAS,EAAE,UAAU,CAAA;IAC9B,QAAQ,CAAC,QAAQ,EAAE,YAAY,CAAA;IAC/B,QAAQ,CAAC,WAAW,EAAE,YAAY,CAAA;IAIlC,QAAQ,CAAC,cAAc,EAAE,WAAW,CAAA;IACpC,QAAQ,CAAC,eAAe,EAAE,WAAW,CAAA;IAErC,QAAQ,CAAC,KAAK,EAAE,UAAU,CAAA;IAC1B,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAA;IAE3B,QAAQ,CAAC,OAAO,EAAE,YAAY,CAAA;IAC9B,QAAQ,CAAC,OAAO,EAAE,YAAY,CAAA;IAI9B,QAAQ,CAAC,gBAAgB,EAAE,YAAY,CAAA;IACvC,QAAQ,CAAC,iBAAiB,EAAE,YAAY,CAAA;IACxC,OAAO,CAAC,gBAAgB,CAAQ;IAMhC,OAAO,CAAC,cAAc,CAA2B;gBAErC,WAAW,EAAE,SAAS,EAAE;IA4DpC,WAAW,CAAC,MAAM,SAAM,GAAG,IAAI;IA2F/B,kBAAkB,CAAC,uBAAuB,EAAE,YAAY,GAAG,IAAI;IAqD/D,kBAAkB,IAAI,OAAO;IAM7B,iBAAiB,IAAI,WAAW;CAoBjC"}

package/dist/physics/body.js

@@ -5,6 +5,11 @@ import { RigidbodyType, RigidbodyShape } from "./types";
 export class RigidBodyStore {
     constructor(rigidbodies) {
         this.boneOffsetsReady = false;
+        // Flat list of (i, j) pairs that survive the static-static + group/mask
+        // filter. None of those inputs change after construction, so building this
+        // once collapses 60k pair tests/step (349 bodies) down to a few thousand.
+        // Built lazily on first access.
+        this.collisionPairs = null;
         const N = rigidbodies.length;
         this.count = N;
         this.positions = new Float32Array(N * 3);
@@ -159,6 +164,31 @@ export class RigidBodyStore {
     isBoneOffsetsReady() {
         return this.boneOffsetsReady;
     }
+    // Pair-filter inputs (invMass, group, mask) are immutable post-construction,
+    // so build the candidate-pair list once and reuse every step.
+    getCollisionPairs() {
+        if (this.collisionPairs !== null)
+            return this.collisionPairs;
+        const N = this.count;
+        const invMass = this.invMass;
+        const group = this.collisionGroup;
+        const mask = this.willCollideMask;
+        const buf = [];
+        for (let i = 0; i < N; i++) {
+            const gi = group[i];
+            const mi = mask[i];
+            const dynA = invMass[i] > 0;
+            for (let j = i + 1; j < N; j++) {
+                if (!dynA && invMass[j] === 0)
+                    continue;
+                if ((mi & group[j]) === 0 || (mask[j] & gi) === 0)
+                    continue;
+                buf.push(i, j);
+            }
+        }
+        this.collisionPairs = new Uint16Array(buf);
+        return this.collisionPairs;
+    }
 }
 const _scratchA = new Float32Array(16);
 const _scratchB = new Float32Array(16);

package/dist/physics/constraint.d.ts

@@ -11,6 +11,19 @@ export interface SixDofSpringConstraint {
     springEnabled: Uint8Array;
     springStiffness: Float32Array;
     equilibriumPoint: Float32Array;
+    cacheSkip: boolean;
+    cacheLeverA: Float32Array;
+    cacheLeverB: Float32Array;
+    cacheLinAxes: Float32Array;
+    cacheLinCrossA: Float32Array;
+    cacheLinCrossB: Float32Array;
+    cacheLinJacInv: Float32Array;
+    cacheLinTargetVel: Float32Array;
+    cacheLinActive: Uint8Array;
+    cacheAngAxes: Float32Array;
+    cacheAngTargetVel: Float32Array;
+    cacheAngActive: Uint8Array;
+    cacheAngJacInv: number;
 }
 export declare const STOP_ERP = 0.475;
 export declare function buildConstraints(rigidbodies: Rigidbody[], joints: Joint[]): SixDofSpringConstraint[];

package/dist/physics/constraint.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"constraint.d.ts","sourceRoot":"","sources":["../../src/physics/constraint.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,SAAS,CAAA;AAW/C,MAAM,WAAW,sBAAsB;IACrC,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,MAAM,CAAA;IAEb,MAAM,EAAE,YAAY,CAAA;IACpB,MAAM,EAAE,YAAY,CAAA;IAGpB,SAAS,EAAE,YAAY,CAAA;IACvB,SAAS,EAAE,YAAY,CAAA;IACvB,UAAU,EAAE,YAAY,CAAA;IACxB,UAAU,EAAE,YAAY,CAAA;IAExB,aAAa,EAAE,UAAU,CAAA;IACzB,eAAe,EAAE,YAAY,CAAA;IAC7B,gBAAgB,EAAE,YAAY,CAAA;CAC/B;AAED,eAAO,MAAM,QAAQ,QAAQ,CAAA;AAM7B,wBAAgB,gBAAgB,CAC9B,WAAW,EAAE,SAAS,EAAE,EACxB,MAAM,EAAE,KAAK,EAAE,GACd,sBAAsB,EAAE,CAqE1B"}
+{"version":3,"file":"constraint.d.ts","sourceRoot":"","sources":["../../src/physics/constraint.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,SAAS,CAAA;AAW/C,MAAM,WAAW,sBAAsB;IACrC,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,MAAM,CAAA;IAEb,MAAM,EAAE,YAAY,CAAA;IACpB,MAAM,EAAE,YAAY,CAAA;IAGpB,SAAS,EAAE,YAAY,CAAA;IACvB,SAAS,EAAE,YAAY,CAAA;IACvB,UAAU,EAAE,YAAY,CAAA;IACxB,UAAU,EAAE,YAAY,CAAA;IAExB,aAAa,EAAE,UAAU,CAAA;IACzB,eAAe,EAAE,YAAY,CAAA;IAC7B,gBAAgB,EAAE,YAAY,CAAA;IAK9B,SAAS,EAAE,OAAO,CAAA;IAClB,WAAW,EAAE,YAAY,CAAA;IACzB,WAAW,EAAE,YAAY,CAAA;IACzB,YAAY,EAAE,YAAY,CAAA;IAC1B,cAAc,EAAE,YAAY,CAAA;IAC5B,cAAc,EAAE,YAAY,CAAA;IAC5B,cAAc,EAAE,YAAY,CAAA;IAC5B,iBAAiB,EAAE,YAAY,CAAA;IAC/B,cAAc,EAAE,UAAU,CAAA;IAC1B,YAAY,EAAE,YAAY,CAAA;IAC1B,iBAAiB,EAAE,YAAY,CAAA;IAC/B,cAAc,EAAE,UAAU,CAAA;IAC1B,cAAc,EAAE,MAAM,CAAA;CACvB;AAED,eAAO,MAAM,QAAQ,QAAQ,CAAA;AAM7B,wBAAgB,gBAAgB,CAC9B,WAAW,EAAE,SAAS,EAAE,EACxB,MAAM,EAAE,KAAK,EAAE,GACd,sBAAsB,EAAE,CAkF1B"}

package/dist/physics/constraint.js

@@ -64,6 +64,19 @@ export function buildConstraints(rigidbodies, joints) {
             springEnabled,
             springStiffness,
             equilibriumPoint: new Float32Array(6),
+            cacheSkip: false,
+            cacheLeverA: new Float32Array(3),
+            cacheLeverB: new Float32Array(3),
+            cacheLinAxes: new Float32Array(9),
+            cacheLinCrossA: new Float32Array(9),
+            cacheLinCrossB: new Float32Array(9),
+            cacheLinJacInv: new Float32Array(3),
+            cacheLinTargetVel: new Float32Array(3),
+            cacheLinActive: new Uint8Array(3),
+            cacheAngAxes: new Float32Array(9),
+            cacheAngTargetVel: new Float32Array(3),
+            cacheAngActive: new Uint8Array(3),
+            cacheAngJacInv: 0,
         });
     }
     return out;

package/dist/physics/contact.d.ts

@@ -18,6 +18,34 @@ export interface Contact {
     appliedNormalImpulse: number;
     appliedFrictionImpulse1: number;
     appliedFrictionImpulse2: number;
+    cAxN: number;
+    cAyN: number;
+    cAzN: number;
+    cBxN: number;
+    cByN: number;
+    cBzN: number;
+    jacInvN: number;
+    bounceVel: number;
+    t1x: number;
+    t1y: number;
+    t1z: number;
+    cAxT1: number;
+    cAyT1: number;
+    cAzT1: number;
+    cBxT1: number;
+    cByT1: number;
+    cBzT1: number;
+    jacInvT1: number;
+    t2x: number;
+    t2y: number;
+    t2z: number;
+    cAxT2: number;
+    cAyT2: number;
+    cAzT2: number;
+    cBxT2: number;
+    cByT2: number;
+    cBzT2: number;
+    jacInvT2: number;
 }
 export declare class ContactPool {
     private pool;

package/dist/physics/contact.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"contact.d.ts","sourceRoot":"","sources":["../../src/physics/contact.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,QAAQ,CAAA;AAO5C,eAAO,MAAM,cAAc,OAAO,CAAA;AAElC,MAAM,WAAW,OAAO;IACtB,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,MAAM,CAAA;IAEb,GAAG,EAAE,MAAM,CAAA;IACX,GAAG,EAAE,MAAM,CAAA;IACX,GAAG,EAAE,MAAM,CAAA;IACX,GAAG,EAAE,MAAM,CAAA;IACX,GAAG,EAAE,MAAM,CAAA;IACX,GAAG,EAAE,MAAM,CAAA;IAEX,EAAE,EAAE,MAAM,CAAA;IACV,EAAE,EAAE,MAAM,CAAA;IACV,EAAE,EAAE,MAAM,CAAA;IACV,KAAK,EAAE,MAAM,CAAA;IACb,QAAQ,EAAE,MAAM,CAAA;IAChB,WAAW,EAAE,MAAM,CAAA;IAEnB,oBAAoB,EAAE,MAAM,CAAA;IAC5B,uBAAuB,EAAE,MAAM,CAAA;IAC/B,uBAAuB,EAAE,MAAM,CAAA;CAChC;AAyBD,qBAAa,WAAW;IACtB,OAAO,CAAC,IAAI,CAAgB;IAC5B,KAAK,SAAI;IAET,OAAO,IAAI,OAAO;IAelB,KAAK,IAAI,IAAI;IAGb,GAAG,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO;CAGxB;AASD,wBAAgB,WAAW,CAAC,KAAK,EAAE,cAAc,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,OAAO,CAahF;AAkxBD,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,cAAc,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,IAAI,EAAE,WAAW,GAAG,IAAI,CAuCrG;AA4BD,wBAAgB,YAAY,CAAC,KAAK,EAAE,cAAc,EAAE,IAAI,EAAE,WAAW,GAAG,IAAI,CAkB3E"}
+{"version":3,"file":"contact.d.ts","sourceRoot":"","sources":["../../src/physics/contact.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,QAAQ,CAAA;AAO5C,eAAO,MAAM,cAAc,OAAO,CAAA;AAElC,MAAM,WAAW,OAAO;IACtB,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,MAAM,CAAA;IAEb,GAAG,EAAE,MAAM,CAAA;IACX,GAAG,EAAE,MAAM,CAAA;IACX,GAAG,EAAE,MAAM,CAAA;IACX,GAAG,EAAE,MAAM,CAAA;IACX,GAAG,EAAE,MAAM,CAAA;IACX,GAAG,EAAE,MAAM,CAAA;IAEX,EAAE,EAAE,MAAM,CAAA;IACV,EAAE,EAAE,MAAM,CAAA;IACV,EAAE,EAAE,MAAM,CAAA;IACV,KAAK,EAAE,MAAM,CAAA;IACb,QAAQ,EAAE,MAAM,CAAA;IAChB,WAAW,EAAE,MAAM,CAAA;IAEnB,oBAAoB,EAAE,MAAM,CAAA;IAC5B,uBAAuB,EAAE,MAAM,CAAA;IAC/B,uBAAuB,EAAE,MAAM,CAAA;IAI/B,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;IACxC,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;IACxC,OAAO,EAAE,MAAM,CAAA;IACf,SAAS,EAAE,MAAM,CAAA;IAEjB,GAAG,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;IACrC,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;IAC3C,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;IAC3C,QAAQ,EAAE,MAAM,CAAA;IAEhB,GAAG,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;IACrC,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;IAC3C,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;IAC3C,QAAQ,EAAE,MAAM,CAAA;CACjB;AA8BD,qBAAa,WAAW;IACtB,OAAO,CAAC,IAAI,CAAgB;IAC5B,KAAK,SAAI;IAET,OAAO,IAAI,OAAO;IAelB,KAAK,IAAI,IAAI;IAGb,GAAG,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO;CAGxB;AASD,wBAAgB,WAAW,CAAC,KAAK,EAAE,cAAc,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,OAAO,CAahF;AAkxBD,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,cAAc,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,IAAI,EAAE,WAAW,GAAG,IAAI,CAuCrG;AA4BD,wBAAgB,YAAY,CAAC,KAAK,EAAE,cAAc,EAAE,IAAI,EAAE,WAAW,GAAG,IAAI,CAS3E"}