reze-engine 0.15.1 → 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/physics.d.ts

@@ -12,7 +12,10 @@ export declare class RezePhysics {
     private timeAccum;
     private readonly fixedTimeStep;
     private readonly maxSubSteps;
+    private prevPositions;
+    private prevOrientations;
     constructor(rigidbodies: Rigidbody[], joints?: Joint[]);
+    private savePrevState;
     setGravity(gravity: Vec3): void;
     getGravity(): Vec3;
     getRigidbodies(): Rigidbody[];

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

@@ -1 +1 @@
-{"version":3,"file":"physics.d.ts","sourceRoot":"","sources":["../../src/physics/physics.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,SAAS,CAAA;AAC1C,OAAO,KAAK,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,SAAS,CAAA;AAE/C,OAAO,EAAE,cAAc,EAAE,MAAM,QAAQ,CAAA;AAYvC,qBAAa,WAAW;IACtB,OAAO,CAAC,WAAW,CAAa;IAChC,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,KAAK,CAAgB;IAC7B,OAAO,CAAC,KAAK,CAAO;IACpB,OAAO,CAAC,WAAW,CAA0B;IAC7C,OAAO,CAAC,QAAQ,CAAa;IAC7B,OAAO,CAAC,UAAU,CAAO;IACzB,OAAO,CAAC,SAAS,CAAI;IACrB,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAS;IACvC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAI;gBAEpB,WAAW,EAAE,SAAS,EAAE,EAAE,MAAM,GAAE,KAAK,EAAO;IAS1D,UAAU,CAAC,OAAO,EAAE,IAAI,GAAG,IAAI;IAG/B,UAAU,IAAI,IAAI;IAGlB,cAAc,IAAI,SAAS,EAAE;IAG7B,SAAS,IAAI,KAAK,EAAE;IAGpB,QAAQ,IAAI,cAAc;IAI1B,sBAAsB,IAAI,KAAK,CAAC;QAAE,QAAQ,EAAE,IAAI,CAAC;QAAC,QAAQ,EAAE,IAAI,CAAA;KAAE,CAAC;IAiBnE,KAAK,CAAC,iBAAiB,EAAE,IAAI,EAAE,GAAG,IAAI;IAKtC,IAAI,CAAC,EAAE,EAAE,MAAM,EAAE,iBAAiB,EAAE,IAAI,EAAE,EAAE,uBAAuB,EAAE,YAAY,GAAG,IAAI;IA6BxF,OAAO,CAAC,iBAAiB;IAuCzB,OAAO,CAAC,aAAa;IA6ErB,OAAO,CAAC,oBAAoB;CAiC7B"}
+{"version":3,"file":"physics.d.ts","sourceRoot":"","sources":["../../src/physics/physics.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,SAAS,CAAA;AAC1C,OAAO,KAAK,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,SAAS,CAAA;AAE/C,OAAO,EAAE,cAAc,EAAE,MAAM,QAAQ,CAAA;AAYvC,qBAAa,WAAW;IACtB,OAAO,CAAC,WAAW,CAAa;IAChC,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,KAAK,CAAgB;IAC7B,OAAO,CAAC,KAAK,CAAO;IACpB,OAAO,CAAC,WAAW,CAA0B;IAC7C,OAAO,CAAC,QAAQ,CAAa;IAC7B,OAAO,CAAC,UAAU,CAAO;IACzB,OAAO,CAAC,SAAS,CAAI;IACrB,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAS;IACvC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAI;IAMhC,OAAO,CAAC,aAAa,CAAc;IACnC,OAAO,CAAC,gBAAgB,CAAc;gBAE1B,WAAW,EAAE,SAAS,EAAE,EAAE,MAAM,GAAE,KAAK,EAAO;IAY1D,OAAO,CAAC,aAAa;IAKrB,UAAU,CAAC,OAAO,EAAE,IAAI,GAAG,IAAI;IAG/B,UAAU,IAAI,IAAI;IAGlB,cAAc,IAAI,SAAS,EAAE;IAG7B,SAAS,IAAI,KAAK,EAAE;IAGpB,QAAQ,IAAI,cAAc;IAI1B,sBAAsB,IAAI,KAAK,CAAC;QAAE,QAAQ,EAAE,IAAI,CAAC;QAAC,QAAQ,EAAE,IAAI,CAAA;KAAE,CAAC;IAiBnE,KAAK,CAAC,iBAAiB,EAAE,IAAI,EAAE,GAAG,IAAI;IAOtC,IAAI,CAAC,EAAE,EAAE,MAAM,EAAE,iBAAiB,EAAE,IAAI,EAAE,EAAE,uBAAuB,EAAE,YAAY,GAAG,IAAI;IAkCxF,OAAO,CAAC,iBAAiB;IAuCzB,OAAO,CAAC,aAAa;IA+ErB,OAAO,CAAC,oBAAoB;CAoD7B"}

package/dist/physics/physics.js

@@ -22,6 +22,13 @@ export class RezePhysics {
         this.world = new World(new Vec3(0, -98, 0));
         this.constraints = buildConstraints(rigidbodies, joints);
         this.contacts = new ContactPool();
+        this.prevPositions = new Float32Array(this.store.count * 3);
+        this.prevOrientations = new Float32Array(this.store.count * 4);
+    }
+    // Snapshot the current body pose as the interpolation "previous" state.
+    savePrevState() {
+        this.prevPositions.set(this.store.positions);
+        this.prevOrientations.set(this.store.orientations);
     }
     setGravity(gravity) {
         this.world.setGravity(gravity);
@@ -58,6 +65,8 @@ export class RezePhysics {
         if (this.firstFrame)
             return;
         this.snapBodiesToBones(boneWorldMatrices);
+        this.savePrevState(); // prev == curr after a snap, so no interpolation jump
+        this.timeAccum = 0;
     }
     step(dt, boneWorldMatrices, boneInverseBindMatrices) {
         if (this.firstFrame) {
@@ -65,6 +74,7 @@ export class RezePhysics {
             // Start at current bone pose, not the PMX bind pose, so animations
             // that skip frame 0 don't pop bodies on first step.
             this.snapBodiesToBones(boneWorldMatrices);
+            this.savePrevState();
             this.firstFrame = false;
         }
         // Sync once per render frame; kinematic targets don't change between
@@ -72,17 +82,21 @@ export class RezePhysics {
         // bone-pose delta so joints feel the kinematic motion.
         this.syncFromBones(boneWorldMatrices, dt);
         // Fixed-timestep substeps. The maxSubSteps cap prevents runaway after
-        // a long stall (tab backgrounded, etc.).
+        // a long stall (tab backgrounded, etc.). Snapshot the pose before each step so
+        // after the loop prevState is one substep behind the live (current) state.
         this.timeAccum += dt;
         let sub = 0;
         while (this.timeAccum >= this.fixedTimeStep && sub < this.maxSubSteps) {
+            this.savePrevState();
             this.world.step(this.store, this.constraints, this.contacts, this.fixedTimeStep);
             this.timeAccum -= this.fixedTimeStep;
             sub++;
         }
         if (sub === this.maxSubSteps)
             this.timeAccum = 0;
-        this.applyDynamicsToBones(boneWorldMatrices);
+        // Fraction into the next (not-yet-taken) step; always in [0, 1).
+        const alpha = this.fixedTimeStep > 0 ? this.timeAccum / this.fixedTimeStep : 0;
+        this.applyDynamicsToBones(boneWorldMatrices, alpha);
     }
     // Snap all bone-bound bodies to boneWorld × bodyOffset, zero velocities.
     snapBodiesToBones(boneWorldMatrices) {
@@ -183,13 +197,18 @@ export class RezePhysics {
     }
     // Dynamic bodies write their transform back to the bone matrix:
     //   boneWorld = bodyWorld × bodyOffsetInverse.
-    applyDynamicsToBones(boneWorldMatrices) {
+    // The body pose is the render-interpolated pose between the previous and current
+    // substep states (alpha = fraction into the next step), which removes fixed-step judder.
+    applyDynamicsToBones(boneWorldMatrices, alpha) {
         const N = this.store.count;
         const inv = this.store.bodyOffsetInverse;
         const positions = this.store.positions;
         const orientations = this.store.orientations;
+        const prevPos = this.prevPositions;
+        const prevOri = this.prevOrientations;
         const types = this.store.type;
         const boneIdx = this.store.boneIndex;
+        const oneMinus = 1 - alpha;
         for (let i = 0; i < N; i++) {
             if (types[i] !== RigidbodyType.Dynamic)
                 continue;
@@ -198,7 +217,39 @@ export class RezePhysics {
                 continue;
             const i3 = i * 3;
             const i4 = i * 4;
-            Mat4.fromPositionRotationInto(positions[i3 + 0], positions[i3 + 1], positions[i3 + 2], orientations[i4 + 0], orientations[i4 + 1], orientations[i4 + 2], orientations[i4 + 3], _bodyMat);
+            // Position: straight lerp.
+            const px = prevPos[i3 + 0] * oneMinus + positions[i3 + 0] * alpha;
+            const py = prevPos[i3 + 1] * oneMinus + positions[i3 + 1] * alpha;
+            const pz = prevPos[i3 + 2] * oneMinus + positions[i3 + 2] * alpha;
+            // Orientation: shortest-arc nlerp (bodies rotate little per fixed step, so nlerp
+            // tracks slerp closely and avoids the trig).
+            const ax = prevOri[i4 + 0], ay = prevOri[i4 + 1], az = prevOri[i4 + 2], aw = prevOri[i4 + 3];
+            let bx = orientations[i4 + 0], by = orientations[i4 + 1], bz = orientations[i4 + 2], bw = orientations[i4 + 3];
+            if (ax * bx + ay * by + az * bz + aw * bw < 0) {
+                bx = -bx;
+                by = -by;
+                bz = -bz;
+                bw = -bw;
+            }
+            let qx = ax * oneMinus + bx * alpha;
+            let qy = ay * oneMinus + by * alpha;
+            let qz = az * oneMinus + bz * alpha;
+            let qw = aw * oneMinus + bw * alpha;
+            const ql = Math.sqrt(qx * qx + qy * qy + qz * qz + qw * qw);
+            if (ql > 0) {
+                const invL = 1 / ql;
+                qx *= invL;
+                qy *= invL;
+                qz *= invL;
+                qw *= invL;
+            }
+            else {
+                qx = 0;
+                qy = 0;
+                qz = 0;
+                qw = 1;
+            }
+            Mat4.fromPositionRotationInto(px, py, pz, qx, qy, qz, qw, _bodyMat);
             Mat4.multiplyArrays(_bodyMat, 0, inv, i * 16, _boneMat, 0);
             // Sanity gate against NaN / extreme values — silently drop the update.
             if (Number.isFinite(_boneMat[0]) && Math.abs(_boneMat[0]) < 1e6) {

package/dist/pmx-loader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pmx-loader.d.ts","sourceRoot":"","sources":["../src/pmx-loader.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,EAWN,MAAM,SAAS,CAAA;AAGhB,OAAO,EAA0B,KAAK,WAAW,EAAE,MAAM,gBAAgB,CAAA;AAEzE,qBAAa,SAAS;IACpB,OAAO,CAAC,IAAI,CAAU;IACtB,OAAO,CAAC,MAAM,CAAI;IAClB,OAAO,CAAC,OAAO,CAAc;IAC7B,OAAO,CAAC,QAAQ,CAAI;IACpB,OAAO,CAAC,mBAAmB,CAAI;IAC/B,OAAO,CAAC,eAAe,CAAI;IAC3B,OAAO,CAAC,gBAAgB,CAAI;IAC5B,OAAO,CAAC,iBAAiB,CAAI;IAC7B,OAAO,CAAC,aAAa,CAAI;IACzB,OAAO,CAAC,cAAc,CAAI;IAC1B,OAAO,CAAC,kBAAkB,CAAI;IAC9B,OAAO,CAAC,QAAQ,CAAgB;IAChC,OAAO,CAAC,SAAS,CAAiB;IAClC,OAAO,CAAC,KAAK,CAAa;IAC1B,OAAO,CAAC,mBAAmB,CAA4B;IACvD,OAAO,CAAC,OAAO,CAA2B;IAC1C,OAAO,CAAC,QAAQ,CAA0B;IAC1C,OAAO,CAAC,MAAM,CAAc;IAC5B,OAAO,CAAC,WAAW,CAAY;IAC/B,OAAO,CAAC,WAAW,CAAkB;IACrC,OAAO,CAAC,MAAM,CAAc;IAE5B,OAAO;WAIM,IAAI,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,KAAK,CAAC;IAI9C,MAAM,CAAC,cAAc,CAAC,MAAM,EAAE,WAAW,GAAG,KAAK;WAIpC,cAAc,CAAC,MAAM,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,GAAG,OAAO,CAAC,KAAK,CAAC;IAKxF,OAAO,CAAC,KAAK;IAiBb,OAAO,CAAC,WAAW;IA+CnB,OAAO,CAAC,aAAa;IA+FrB,OAAO,CAAC,YAAY;IAWpB,OAAO,CAAC,aAAa;IAkBrB,OAAO,CAAC,cAAc;IAoEtB,OAAO,CAAC,UAAU;IAsKlB,OAAO,CAAC,WAAW;IA+InB,OAAO,CAAC,iBAAiB;IAgDzB,OAAO,CAAC,gBAAgB;IAyFxB,OAAO,CAAC,WAAW;IAmGnB,OAAO,CAAC,kBAAkB;IAmC1B,OAAO,CAAC,OAAO;IAkLf,OAAO,CAAC,QAAQ;IAOhB,OAAO,CAAC,SAAS;IAUjB,OAAO,CAAC,cAAc;IAWtB,OAAO,CAAC,iBAAiB;IAczB,OAAO,CAAC,QAAQ;IAShB,OAAO,CAAC,UAAU;IASlB,OAAO,CAAC,SAAS;IAMjB,OAAO,CAAC,OAAO;IAmBf,OAAO,CAAC,QAAQ;CAIjB"}
+{"version":3,"file":"pmx-loader.d.ts","sourceRoot":"","sources":["../src/pmx-loader.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,EAWN,MAAM,SAAS,CAAA;AAGhB,OAAO,EAA0B,KAAK,WAAW,EAAE,MAAM,gBAAgB,CAAA;AAEzE,qBAAa,SAAS;IACpB,OAAO,CAAC,IAAI,CAAU;IACtB,OAAO,CAAC,MAAM,CAAI;IAClB,OAAO,CAAC,OAAO,CAAc;IAC7B,OAAO,CAAC,QAAQ,CAAI;IACpB,OAAO,CAAC,mBAAmB,CAAI;IAC/B,OAAO,CAAC,eAAe,CAAI;IAC3B,OAAO,CAAC,gBAAgB,CAAI;IAC5B,OAAO,CAAC,iBAAiB,CAAI;IAC7B,OAAO,CAAC,aAAa,CAAI;IACzB,OAAO,CAAC,cAAc,CAAI;IAC1B,OAAO,CAAC,kBAAkB,CAAI;IAC9B,OAAO,CAAC,QAAQ,CAAgB;IAChC,OAAO,CAAC,SAAS,CAAiB;IAClC,OAAO,CAAC,KAAK,CAAa;IAC1B,OAAO,CAAC,mBAAmB,CAA4B;IACvD,OAAO,CAAC,OAAO,CAA2B;IAC1C,OAAO,CAAC,QAAQ,CAA0B;IAC1C,OAAO,CAAC,MAAM,CAAc;IAC5B,OAAO,CAAC,WAAW,CAAY;IAC/B,OAAO,CAAC,WAAW,CAAkB;IACrC,OAAO,CAAC,MAAM,CAAc;IAE5B,OAAO;WAIM,IAAI,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,KAAK,CAAC;IAI9C,MAAM,CAAC,cAAc,CAAC,MAAM,EAAE,WAAW,GAAG,KAAK;WAIpC,cAAc,CAAC,MAAM,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,GAAG,OAAO,CAAC,KAAK,CAAC;IAKxF,OAAO,CAAC,KAAK;IAiBb,OAAO,CAAC,WAAW;IA+CnB,OAAO,CAAC,aAAa;IA+FrB,OAAO,CAAC,YAAY;IAWpB,OAAO,CAAC,aAAa;IAkBrB,OAAO,CAAC,cAAc;IAoEtB,OAAO,CAAC,UAAU;IAsKlB,OAAO,CAAC,WAAW;IA+InB,OAAO,CAAC,iBAAiB;IAgDzB,OAAO,CAAC,gBAAgB;IAyFxB,OAAO,CAAC,WAAW;IAmGnB,OAAO,CAAC,kBAAkB;IAmC1B,OAAO,CAAC,OAAO;IAiJf,OAAO,CAAC,QAAQ;IAOhB,OAAO,CAAC,SAAS;IAUjB,OAAO,CAAC,cAAc;IAWtB,OAAO,CAAC,iBAAiB;IAczB,OAAO,CAAC,QAAQ;IAShB,OAAO,CAAC,UAAU;IASlB,OAAO,CAAC,SAAS;IAMjB,OAAO,CAAC,OAAO;IAmBf,OAAO,CAAC,QAAQ;CAIjB"}

package/dist/pmx-loader.js

@@ -916,38 +916,10 @@ export class PmxLoader {
             }
             skinning = { joints, weights };
         }
-        // Create morphing data structure
-        const morphCount = this.morphs.length;
-        // Dense buffer: morphCount * vertexCount * 3 floats (one vec3 per morph per vertex)
-        const offsetsBuffer = new Float32Array(morphCount * this.vertexCount * 3);
-        // Initialize all offsets to zero
-        offsetsBuffer.fill(0);
-        // Fill in actual offsets for vertex morphs
-        for (let morphIdx = 0; morphIdx < morphCount; morphIdx++) {
-            const morph = this.morphs[morphIdx];
-            if (morph.type === 1) {
-                // Vertex morph
-                // Store offsets in dense buffer: [morph0_v0, morph0_v1, ..., morph1_v0, ...]
-                // Each vec3 is 3 consecutive floats
-                for (const offset of morph.vertexOffsets) {
-                    // Calculate index in the dense buffer
-                    // Layout: morphIdx * (vertexCount * 3) + vertexIndex * 3
-                    // This gives us the starting float index for this morph's vertex offset
-                    const bufferIdx = morphIdx * this.vertexCount * 3 + offset.vertexIndex * 3;
-                    if (bufferIdx >= 0 &&
-                        bufferIdx + 2 < offsetsBuffer.length &&
-                        offset.vertexIndex >= 0 &&
-                        offset.vertexIndex < this.vertexCount) {
-                        offsetsBuffer[bufferIdx] = offset.positionOffset[0];
-                        offsetsBuffer[bufferIdx + 1] = offset.positionOffset[1];
-                        offsetsBuffer[bufferIdx + 2] = offset.positionOffset[2];
-                    }
-                }
-            }
-        }
+        // Morphs are applied from the sparse per-morph vertexOffsets lists (see
+        // Model.applyMorphs); no dense morphCount*vertexCount buffer is needed.
         const morphing = {
             morphs: this.morphs,
-            offsetsBuffer,
         };
         return new Model(vertexData, indexData, this.textures, this.materials, skeleton, skinning, morphing, this.rigidbodies, this.joints);
     }