reze-engine 0.6.4 → 0.6.6

package/dist/ik-solver.d.ts

@@ -5,6 +5,7 @@
  */
 import { Mat4, Quat, Vec3 } from "./math";
 import { Bone, IKSolver, IKChainInfo } from "./model";
+export type UpdateWorldMatrixFn = (boneIndex: number, applyIK: boolean) => void;
 /**
  * Solve IK chains for a model
  */
@@ -14,7 +15,7 @@ export declare class IKSolverSystem {
     /**
      * Solve all IK chains
      */
-    static solve(ikSolvers: IKSolver[], bones: Bone[], localRotations: Quat[], localTranslations: Vec3[], worldMatrices: Mat4[], ikChainInfo: IKChainInfo[]): void;
+    static solve(ikSolvers: IKSolver[], bones: Bone[], localRotations: Quat[], localTranslations: Vec3[], worldMatrices: Mat4[], ikChainInfo: IKChainInfo[], updateWorldMatrix?: UpdateWorldMatrixFn): void;
     private static solveIK;
     private static solveChain;
     private static limitAngle;

package/dist/ik-solver.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ik-solver.d.ts","sourceRoot":"","sources":["../src/ik-solver.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAA;AACzC,OAAO,EAAE,IAAI,EAAU,QAAQ,EAAE,WAAW,EAAE,MAAM,SAAS,CAAA;AAoE7D;;GAEG;AACH,qBAAa,cAAc;IACzB,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,OAAO,CAAS;IACxC,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,SAAS,CAAuB;IAExD;;OAEG;WACW,KAAK,CACjB,SAAS,EAAE,QAAQ,EAAE,EACrB,KAAK,EAAE,IAAI,EAAE,EACb,cAAc,EAAE,IAAI,EAAE,EACtB,iBAAiB,EAAE,IAAI,EAAE,EACzB,aAAa,EAAE,IAAI,EAAE,EACrB,WAAW,EAAE,WAAW,EAAE,GACzB,IAAI;IAMP,OAAO,CAAC,MAAM,CAAC,OAAO;IA2EtB,OAAO,CAAC,MAAM,CAAC,UAAU;IA4FzB,OAAO,CAAC,MAAM,CAAC,UAAU;IAYzB,OAAO,CAAC,MAAM,CAAC,WAAW;IAM1B,OAAO,CAAC,MAAM,CAAC,mBAAmB;IAKlC,OAAO,CAAC,MAAM,CAAC,kBAAkB;IAmCjC,OAAO,CAAC,MAAM,CAAC,gBAAgB;IAQ/B,OAAO,CAAC,MAAM,CAAC,wBAAwB;IAqBvC,OAAO,CAAC,MAAM,CAAC,4BAA4B;IAc3C,OAAO,CAAC,MAAM,CAAC,eAAe;IAS9B,OAAO,CAAC,MAAM,CAAC,iBAAiB;CAoCjC"}
+{"version":3,"file":"ik-solver.d.ts","sourceRoot":"","sources":["../src/ik-solver.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAA;AACzC,OAAO,EAAE,IAAI,EAAU,QAAQ,EAAE,WAAW,EAAE,MAAM,SAAS,CAAA;AAG7D,MAAM,MAAM,mBAAmB,GAAG,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,KAAK,IAAI,CAAA;AAoE/E;;GAEG;AACH,qBAAa,cAAc;IACzB,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,OAAO,CAAS;IACxC,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,SAAS,CAAuB;IAExD;;OAEG;WACW,KAAK,CACjB,SAAS,EAAE,QAAQ,EAAE,EACrB,KAAK,EAAE,IAAI,EAAE,EACb,cAAc,EAAE,IAAI,EAAE,EACtB,iBAAiB,EAAE,IAAI,EAAE,EACzB,aAAa,EAAE,IAAI,EAAE,EACrB,WAAW,EAAE,WAAW,EAAE,EAC1B,iBAAiB,CAAC,EAAE,mBAAmB,GACtC,IAAI;IAMP,OAAO,CAAC,MAAM,CAAC,OAAO;IAoFtB,OAAO,CAAC,MAAM,CAAC,UAAU;IAqGzB,OAAO,CAAC,MAAM,CAAC,UAAU;IAYzB,OAAO,CAAC,MAAM,CAAC,WAAW;IAM1B,OAAO,CAAC,MAAM,CAAC,mBAAmB;IAKlC,OAAO,CAAC,MAAM,CAAC,kBAAkB;IAmCjC,OAAO,CAAC,MAAM,CAAC,gBAAgB;IAQ/B,OAAO,CAAC,MAAM,CAAC,wBAAwB;IAqBvC,OAAO,CAAC,MAAM,CAAC,4BAA4B;IAc3C,OAAO,CAAC,MAAM,CAAC,eAAe;IAS9B,OAAO,CAAC,MAAM,CAAC,iBAAiB;CAoCjC"}

package/dist/ik-solver.js

@@ -74,12 +74,12 @@ export class IKSolverSystem {
     /**
      * Solve all IK chains
      */
-    static solve(ikSolvers, bones, localRotations, localTranslations, worldMatrices, ikChainInfo) {
+    static solve(ikSolvers, bones, localRotations, localTranslations, worldMatrices, ikChainInfo, updateWorldMatrix) {
         for (const solver of ikSolvers) {
-            this.solveIK(solver, bones, localRotations, localTranslations, worldMatrices, ikChainInfo);
+            this.solveIK(solver, bones, localRotations, localTranslations, worldMatrices, ikChainInfo, updateWorldMatrix);
         }
     }
-    static solveIK(solver, bones, localRotations, localTranslations, worldMatrices, ikChainInfo) {
+    static solveIK(solver, bones, localRotations, localTranslations, worldMatrices, ikChainInfo, updateWorldMatrix) {
         if (solver.links.length === 0)
             return;
         const ikBoneIndex = solver.ikBoneIndex;
@@ -99,10 +99,18 @@ export class IKSolverSystem {
             chains.push(new IKChain(link.boneIndex, link));
         }
         // Update chain bones and target bone world matrices (initial state, no IK yet)
-        for (let i = chains.length - 1; i >= 0; i--) {
-            this.updateWorldMatrix(chains[i].boneIndex, bones, localRotations, localTranslations, worldMatrices, undefined);
+        if (updateWorldMatrix) {
+            for (let i = chains.length - 1; i >= 0; i--) {
+                updateWorldMatrix(chains[i].boneIndex, false);
+            }
+            updateWorldMatrix(targetBoneIndex, false);
+        }
+        else {
+            for (let i = chains.length - 1; i >= 0; i--) {
+                this.updateWorldMatrix(chains[i].boneIndex, bones, localRotations, localTranslations, worldMatrices, undefined);
+            }
+            this.updateWorldMatrix(targetBoneIndex, bones, localRotations, localTranslations, worldMatrices, undefined);
         }
-        this.updateWorldMatrix(targetBoneIndex, bones, localRotations, localTranslations, worldMatrices, undefined);
         if (this.getDistance(ikBoneIndex, targetBoneIndex, worldMatrices) < this.EPSILON)
             return;
         // Solve iteratively
@@ -112,7 +120,7 @@ export class IKSolverSystem {
             for (let chainIndex = 0; chainIndex < chains.length; chainIndex++) {
                 const chain = chains[chainIndex];
                 if (chain.solveAxis !== InternalSolveAxis.Fixed) {
-                    this.solveChain(chain, chainIndex, solver, ikBoneIndex, targetBoneIndex, bones, localRotations, localTranslations, worldMatrices, ikChainInfo, i < halfIteration);
+                    this.solveChain(chain, chainIndex, solver, ikBoneIndex, targetBoneIndex, bones, localRotations, localTranslations, worldMatrices, ikChainInfo, i < halfIteration, updateWorldMatrix);
                 }
             }
             if (this.getDistance(ikBoneIndex, targetBoneIndex, worldMatrices) < this.EPSILON)
@@ -128,7 +136,7 @@ export class IKSolverSystem {
             }
         }
     }
-    static solveChain(chain, chainIndex, solver, ikBoneIndex, targetBoneIndex, bones, localRotations, localTranslations, worldMatrices, ikChainInfo, useAxis) {
+    static solveChain(chain, chainIndex, solver, ikBoneIndex, targetBoneIndex, bones, localRotations, localTranslations, worldMatrices, ikChainInfo, useAxis, updateWorldMatrix) {
         const chainBoneIndex = chain.boneIndex;
         const chainPosition = this.getWorldTranslation(chainBoneIndex, worldMatrices);
         const ikPosition = this.getWorldTranslation(ikBoneIndex, worldMatrices);
@@ -191,13 +199,22 @@ export class IKSolverSystem {
                 chainInfo.ikRotation = chainInfo.ikRotation.multiply(localRot.clone().conjugate().normalize());
             }
         }
-        // Update world matrices for affected bones (using IK-modified rotations)
-        for (let i = chainIndex; i >= 0; i--) {
-            const link = solver.links[i];
-            this.updateWorldMatrix(link.boneIndex, bones, localRotations, localTranslations, worldMatrices, ikChainInfo);
+        // Update world matrices for affected bones (using callback - handles append correctly)
+        if (updateWorldMatrix) {
+            for (let i = chainIndex; i >= 0; i--) {
+                const link = solver.links[i];
+                updateWorldMatrix(link.boneIndex, true); // applyIK = true
+            }
+            updateWorldMatrix(targetBoneIndex, false);
+        }
+        else {
+            for (let i = chainIndex; i >= 0; i--) {
+                const link = solver.links[i];
+                this.updateWorldMatrix(link.boneIndex, bones, localRotations, localTranslations, worldMatrices, ikChainInfo);
+            }
+            this.updateWorldMatrix(ikBoneIndex, bones, localRotations, localTranslations, worldMatrices, undefined);
+            this.updateWorldMatrix(targetBoneIndex, bones, localRotations, localTranslations, worldMatrices, undefined);
         }
-        this.updateWorldMatrix(ikBoneIndex, bones, localRotations, localTranslations, worldMatrices, undefined);
-        this.updateWorldMatrix(targetBoneIndex, bones, localRotations, localTranslations, worldMatrices, undefined);
     }
     static limitAngle(angle, min, max, useAxis) {
         if (angle < min) {

package/dist/model.d.ts

@@ -143,6 +143,15 @@ export declare class Model {
     getMorphWeights(): Float32Array;
     rotateBones(boneRotations: Record<string, Quat>, durationMs?: number): void;
     moveBones(boneTranslations: Record<string, Vec3>, durationMs?: number): void;
+    /**
+     * Convert VMD-style relative translation (relative to bind pose world position) to local translation
+     * This helper is used by both moveBones and getPoseAtTime to ensure consistent translation handling
+     * @param boneIdx - Bone index
+     * @param vmdRelativeTranslation - VMD relative translation
+     * @param rotation - Optional rotation to use for conversion. If not provided, uses current localRotation.
+     *                   Use animation rotation (from frame) to avoid conflicts when IK modifies rotation.
+     */
+    private convertVMDTranslationToLocal;
     getBoneWorldMatrices(): Float32Array;
     getBoneInverseBindMatrices(): Float32Array;
     getSkinMatrices(): Float32Array;
@@ -203,6 +212,8 @@ export declare class Model {
      */
     update(deltaTime: number): boolean;
     private solveIKChains;
+    private ikComputedSet;
+    private computeSingleBoneWorldMatrix;
     private computeWorldMatrices;
 }
 //# sourceMappingURL=model.d.ts.map

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

@@ -31,6 +31,8 @@ export class Model {
         // IK and Physics enable flags
         this.ikEnabled = true;
         this.physicsEnabled = true;
+        // Cached set to track which bones are being computed in current IK pass (to avoid infinite recursion)
+        this.ikComputedSet = new Set();
         // Store base vertex data (original positions before morphing)
         this.baseVertexData = new Float32Array(vertexData);
         this.vertexData = vertexData;
@@ -302,51 +304,13 @@ export class Model {
         const state = this.tweenState;
         const now = this.tweenTimeMs;
         const dur = durationMs && durationMs > 0 ? durationMs : 0;
-        // Compute bind pose world positions for all bones
-        const skeleton = this.skeleton;
-        const computeBindPoseWorldPosition = (idx) => {
-            const bone = skeleton.bones[idx];
-            const bindPos = new Vec3(bone.bindTranslation[0], bone.bindTranslation[1], bone.bindTranslation[2]);
-            if (bone.parentIndex >= 0 && bone.parentIndex < skeleton.bones.length) {
-                const parentWorldPos = computeBindPoseWorldPosition(bone.parentIndex);
-                return parentWorldPos.add(bindPos);
-            }
-            else {
-                return bindPos;
-            }
-        };
         for (const [name, vmdRelativeTranslation] of Object.entries(boneTranslations)) {
             const idx = this.runtimeSkeleton.nameIndex[name] ?? -1;
             if (idx < 0 || idx >= this.skeleton.bones.length)
                 continue;
-            const bone = this.skeleton.bones[idx];
             const translations = this.runtimeSkeleton.localTranslations;
-            const localRot = this.runtimeSkeleton.localRotations;
-            // VMD translation is relative to bind pose world position
-            // targetWorldPos = bindPoseWorldPos + vmdRelativeTranslation
-            const bindPoseWorldPos = computeBindPoseWorldPosition(idx);
-            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);
-            }
-            else {
-                parentBindPoseWorldPos = Vec3.zeros();
-            }
-            // 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
-            const localRotation = localRot[idx];
-            // 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);
+            // Convert VMD relative translation to local translation
+            const localTranslation = this.convertVMDTranslationToLocal(idx, vmdRelativeTranslation);
             const [tx, ty, tz] = [localTranslation.x, localTranslation.y, localTranslation.z];
             if (dur === 0) {
                 translations[idx].x = tx;
@@ -381,6 +345,60 @@ export class Model {
             state.transActive[idx] = 1;
         }
     }
+    /**
+     * Convert VMD-style relative translation (relative to bind pose world position) to local translation
+     * This helper is used by both moveBones and getPoseAtTime to ensure consistent translation handling
+     * @param boneIdx - Bone index
+     * @param vmdRelativeTranslation - VMD relative translation
+     * @param rotation - Optional rotation to use for conversion. If not provided, uses current localRotation.
+     *                   Use animation rotation (from frame) to avoid conflicts when IK modifies rotation.
+     */
+    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);
+        }
+        else {
+            parentBindPoseWorldPos = Vec3.zeros();
+        }
+        // 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;
+    }
     getBoneWorldMatrices() {
         // Convert Mat4[] to Float32Array for WebGPU compatibility
         const boneCount = this.skeleton.bones.length;
@@ -704,8 +722,13 @@ export class Model {
             const localTrans = this.runtimeSkeleton.localTranslations[boneIdx];
             if (!frameB) {
                 // No interpolation needed - direct assignment
-                localRot.set(frameA.rotation);
-                localTrans.set(frameA.translation);
+                // Use animation frame's rotation for translation conversion to ensure consistency
+                // This prevents conflicts when IK later modifies the rotation
+                const frameRotation = frameA.rotation;
+                localRot.set(frameRotation);
+                // Convert VMD relative translation to local translation using animation rotation
+                const localTranslation = this.convertVMDTranslationToLocal(boneIdx, frameA.translation, frameRotation);
+                localTrans.set(localTranslation);
             }
             else {
                 const timeA = keyFrames[idx].time;
@@ -717,17 +740,21 @@ export class Model {
                 const rotT = bezierInterpolate(interp[0] * INV_127, interp[1] * INV_127, interp[2] * INV_127, interp[3] * INV_127, gradient);
                 // Use Quat.slerp to interpolate rotation
                 const rotation = Quat.slerp(frameA.rotation, frameB.rotation, rotT);
-                // Interpolate translation using bezier for each component
+                // Interpolate VMD translation using bezier for each component
                 // Inline getWeight to avoid function call overhead
                 const getWeight = (offset) => bezierInterpolate(interp[offset] * INV_127, interp[offset + 8] * INV_127, interp[offset + 4] * INV_127, interp[offset + 12] * INV_127, gradient);
                 const txWeight = getWeight(0);
                 const tyWeight = getWeight(16);
                 const tzWeight = getWeight(32);
+                // Interpolate VMD relative translations (relative to bind pose world position)
+                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);
+                // Convert interpolated VMD translation to local translation using animation rotation
+                // This ensures translation is computed for the animation rotation, not the runtime rotation
+                // that will be modified by IK, preventing conflicts
+                const localTranslation = this.convertVMDTranslationToLocal(boneIdx, interpolatedVMDTranslation, rotation);
                 // Direct property writes to avoid object allocation
                 localRot.set(rotation);
-                localTrans.x = frameA.translation.x + (frameB.translation.x - frameA.translation.x) * txWeight;
-                localTrans.y = frameA.translation.y + (frameB.translation.y - frameA.translation.y) * tyWeight;
-                localTrans.z = frameA.translation.z + (frameB.translation.z - frameA.translation.z) * tzWeight;
+                localTrans.set(localTranslation);
             }
         }
         // Process morph tracks
@@ -807,7 +834,111 @@ export class Model {
         const ikChainInfo = this.runtimeSkeleton.ikChainInfo;
         if (!ikChainInfo)
             return;
-        IKSolverSystem.solve(ikSolvers, this.skeleton.bones, this.runtimeSkeleton.localRotations, this.runtimeSkeleton.localTranslations, this.runtimeSkeleton.worldMatrices, ikChainInfo);
+        // Solve each IK solver sequentially, ensuring consistent state between solvers
+        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();
+            // Clear computed set for this solver's pass
+            this.ikComputedSet.clear();
+            // Solve this IK chain
+            // Pass callback that uses model's world matrix computation (handles append correctly)
+            IKSolverSystem.solve([solver], // Solve one at a time
+            this.skeleton.bones, this.runtimeSkeleton.localRotations, this.runtimeSkeleton.localTranslations, this.runtimeSkeleton.worldMatrices, ikChainInfo, (boneIndex, applyIK) => {
+                // Clear computed set for each bone update to allow recomputation in same iteration
+                this.ikComputedSet.delete(boneIndex);
+                this.computeSingleBoneWorldMatrix(boneIndex, applyIK);
+            });
+        }
+    }
+    // Add this new method to compute a single bone's world matrix
+    // Recursively ensures parents are computed first to avoid using stale parent matrices
+    computeSingleBoneWorldMatrix(boneIndex, applyIK) {
+        const bones = this.skeleton.bones;
+        const localRot = this.runtimeSkeleton.localRotations;
+        const localTrans = this.runtimeSkeleton.localTranslations;
+        const worldMats = this.runtimeSkeleton.worldMatrices;
+        const ikChainInfo = this.runtimeSkeleton.ikChainInfo;
+        const b = bones[boneIndex];
+        // Prevent infinite recursion: if this bone is already being computed in this call chain, skip
+        if (this.ikComputedSet.has(boneIndex)) {
+            return;
+        }
+        // Mark this bone as being computed to prevent infinite recursion
+        this.ikComputedSet.add(boneIndex);
+        // Recursively compute parent first if it exists (ensures parent matrix is up-to-date)
+        if (b.parentIndex >= 0) {
+            this.computeSingleBoneWorldMatrix(b.parentIndex, applyIK);
+        }
+        // Get base rotation
+        let boneRot = localRot[boneIndex];
+        // Apply IK rotation if requested
+        if (applyIK && ikChainInfo) {
+            const chainInfo = ikChainInfo[boneIndex];
+            if (chainInfo?.ikRotation) {
+                boneRot = chainInfo.ikRotation.multiply(boneRot).normalize();
+            }
+        }
+        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;
+        const hasAppend = b.appendRotate &&
+            appendParentIdx !== undefined &&
+            appendParentIdx >= 0 &&
+            appendParentIdx < bones.length;
+        if (hasAppend) {
+            const ratio = b.appendRatio === undefined ? 1 : Math.max(-1, Math.min(1, b.appendRatio));
+            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
+                    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];
+                    let ax = appendRot.x, ay = appendRot.y, az = appendRot.z;
+                    const aw = appendRot.w;
+                    const absRatio = ratio < 0 ? -ratio : ratio;
+                    if (ratio < 0) {
+                        ax = -ax;
+                        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);
+                }
+                if (b.appendMove) {
+                    const appendTrans = localTrans[appendParentIdx];
+                    addLocalTx = appendTrans.x * ratio;
+                    addLocalTy = appendTrans.y * ratio;
+                    addLocalTz = appendTrans.z * ratio;
+                }
+            }
+        }
+        const boneTrans = localTrans[boneIndex];
+        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 worldMat = worldMats[boneIndex];
+        if (b.parentIndex >= 0) {
+            const parentMat = worldMats[b.parentIndex];
+            Mat4.multiplyArrays(parentMat.values, 0, localM.values, 0, worldMat.values, 0);
+        }
+        else {
+            worldMat.values.set(localM.values);
+        }
     }
     computeWorldMatrices() {
         const bones = this.skeleton.bones;

package/dist/runtime-bone.d.ts

@@ -0,0 +1,49 @@
+import { Quat, Vec3, Mat4 } from "./math";
+import type { Bone } from "./model";
+/**
+ * Runtime bone state - encapsulates bone pose and world matrix
+ * Similar to babylon-mmd's IMmdRuntimeBone approach
+ */
+export declare class RuntimeBone {
+    localRotation: Quat;
+    localTranslation: Vec3;
+    worldMatrix: Mat4;
+    readonly bone: Bone;
+    readonly index: number;
+    ikRotation?: Quat;
+    constructor(bone: Bone, index: number);
+    /**
+     * Set local rotation
+     */
+    setRotation(rotation: Quat): void;
+    /**
+     * Set local translation
+     */
+    setTranslation(translation: Vec3): void;
+    /**
+     * Get world position from world matrix
+     */
+    getWorldPosition(): Vec3;
+    /**
+     * Update world matrix based on local rotation, translation, and parent's world matrix
+     * Handles append rotations and translations
+     *
+     * @param parentWorldMatrix Parent's world matrix (null if root bone)
+     * @param allBones Array of all runtime bones (for append parent lookup)
+     * @param applyIK Whether to apply IK rotation (default: true). Set to false when computing initial world matrices before IK solving.
+     */
+    updateWorldMatrix(parentWorldMatrix: Mat4 | null, allBones: RuntimeBone[], applyIK?: boolean): void;
+    /**
+     * Reset IK rotation to identity
+     */
+    resetIKRotation(): void;
+    /**
+     * Set IK rotation delta (accumulated during IK solving)
+     */
+    setIKRotation(ikRotation: Quat): void;
+    /**
+     * Apply IK rotation to local rotation and clear IK rotation
+     */
+    applyIKRotation(): void;
+}
+//# sourceMappingURL=runtime-bone.d.ts.map

package/dist/runtime-bone.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime-bone.d.ts","sourceRoot":"","sources":["../src/runtime-bone.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAA;AACzC,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,SAAS,CAAA;AAEnC;;;GAGG;AACH,qBAAa,WAAW;IACf,aAAa,EAAE,IAAI,CAAA;IACnB,gBAAgB,EAAE,IAAI,CAAA;IACtB,WAAW,EAAE,IAAI,CAAA;IACxB,SAAgB,IAAI,EAAE,IAAI,CAAA;IAC1B,SAAgB,KAAK,EAAE,MAAM,CAAA;IAGtB,UAAU,CAAC,EAAE,IAAI,CAAA;gBAEZ,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM;IAQrC;;OAEG;IACH,WAAW,CAAC,QAAQ,EAAE,IAAI,GAAG,IAAI;IAIjC;;OAEG;IACH,cAAc,CAAC,WAAW,EAAE,IAAI,GAAG,IAAI;IAIvC;;OAEG;IACH,gBAAgB,IAAI,IAAI;IAKxB;;;;;;;OAOG;IACH,iBAAiB,CAAC,iBAAiB,EAAE,IAAI,GAAG,IAAI,EAAE,QAAQ,EAAE,WAAW,EAAE,EAAE,OAAO,GAAE,OAAc,GAAG,IAAI;IA2EzG;;OAEG;IACH,eAAe,IAAI,IAAI;IAIvB;;OAEG;IACH,aAAa,CAAC,UAAU,EAAE,IAAI,GAAG,IAAI;IAIrC;;OAEG;IACH,eAAe,IAAI,IAAI;CAMxB"}

package/dist/runtime-bone.js

@@ -0,0 +1,121 @@
+import { Quat, Vec3, Mat4 } from "./math";
+/**
+ * Runtime bone state - encapsulates bone pose and world matrix
+ * Similar to babylon-mmd's IMmdRuntimeBone approach
+ */
+export class RuntimeBone {
+    constructor(bone, index) {
+        this.bone = bone;
+        this.index = index;
+        this.localRotation = Quat.identity();
+        this.localTranslation = new Vec3(0, 0, 0);
+        this.worldMatrix = Mat4.identity();
+    }
+    /**
+     * Set local rotation
+     */
+    setRotation(rotation) {
+        this.localRotation.set(rotation);
+    }
+    /**
+     * Set local translation
+     */
+    setTranslation(translation) {
+        this.localTranslation.set(translation);
+    }
+    /**
+     * Get world position from world matrix
+     */
+    getWorldPosition() {
+        const m = this.worldMatrix.values;
+        return new Vec3(m[12], m[13], m[14]);
+    }
+    /**
+     * Update world matrix based on local rotation, translation, and parent's world matrix
+     * Handles append rotations and translations
+     *
+     * @param parentWorldMatrix Parent's world matrix (null if root bone)
+     * @param allBones Array of all runtime bones (for append parent lookup)
+     * @param applyIK Whether to apply IK rotation (default: true). Set to false when computing initial world matrices before IK solving.
+     */
+    updateWorldMatrix(parentWorldMatrix, allBones, applyIK = true) {
+        // Start with local rotation
+        let finalRot = this.localRotation;
+        // Apply IK rotation if present and applyIK is true
+        if (applyIK && this.ikRotation) {
+            finalRot = this.ikRotation.multiply(finalRot).normalize();
+        }
+        // Build rotation matrix
+        let rotateM = Mat4.fromQuat(finalRot.x, finalRot.y, finalRot.z, finalRot.w);
+        let addLocalTx = 0, addLocalTy = 0, addLocalTz = 0;
+        // Handle append rotation and translation
+        const appendParentIdx = this.bone.appendParentIndex;
+        const hasAppend = this.bone.appendRotate && appendParentIdx !== undefined && appendParentIdx >= 0 && appendParentIdx < allBones.length;
+        if (hasAppend) {
+            const ratio = this.bone.appendRatio === undefined ? 1 : Math.max(-1, Math.min(1, this.bone.appendRatio));
+            const hasRatio = Math.abs(ratio) > 1e-6;
+            if (hasRatio) {
+                if (this.bone.appendRotate) {
+                    const appendParent = allBones[appendParentIdx];
+                    const appendRot = appendParent.localRotation;
+                    let ax = appendRot.x;
+                    let ay = appendRot.y;
+                    let az = appendRot.z;
+                    const aw = appendRot.w;
+                    const absRatio = ratio < 0 ? -ratio : ratio;
+                    if (ratio < 0) {
+                        ax = -ax;
+                        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);
+                }
+                if (this.bone.appendMove) {
+                    const appendParent = allBones[appendParentIdx];
+                    const appendTrans = appendParent.localTranslation;
+                    const appendRatio = this.bone.appendRatio ?? 1;
+                    addLocalTx = appendTrans.x * appendRatio;
+                    addLocalTy = appendTrans.y * appendRatio;
+                    addLocalTz = appendTrans.z * appendRatio;
+                }
+            }
+        }
+        // Build local matrix: bind translation, then rotation, then local translation + append translation
+        const localTx = this.localTranslation.x + addLocalTx;
+        const localTy = this.localTranslation.y + addLocalTy;
+        const localTz = this.localTranslation.z + addLocalTz;
+        const bindMat = Mat4.identity().translateInPlace(this.bone.bindTranslation[0], this.bone.bindTranslation[1], this.bone.bindTranslation[2]);
+        const transMat = Mat4.identity().translateInPlace(localTx, localTy, localTz);
+        const localM = bindMat.multiply(rotateM).multiply(transMat);
+        // Compute world matrix
+        if (parentWorldMatrix) {
+            this.worldMatrix = parentWorldMatrix.multiply(localM);
+        }
+        else {
+            this.worldMatrix = localM;
+        }
+    }
+    /**
+     * Reset IK rotation to identity
+     */
+    resetIKRotation() {
+        this.ikRotation = undefined;
+    }
+    /**
+     * Set IK rotation delta (accumulated during IK solving)
+     */
+    setIKRotation(ikRotation) {
+        this.ikRotation = ikRotation;
+    }
+    /**
+     * Apply IK rotation to local rotation and clear IK rotation
+     */
+    applyIKRotation() {
+        if (this.ikRotation) {
+            this.localRotation = this.ikRotation.multiply(this.localRotation).normalize();
+            this.ikRotation = undefined;
+        }
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "reze-engine",
-    "version": "0.6.4",
+    "version": "0.6.6",
     "description": "A WebGPU-based MMD model renderer",
     "main": "./dist/index.js",
     "types": "./dist/index.d.ts",