reze-engine 0.2.19 → 0.3.0

package/dist/model.js

@@ -1,5 +1,22 @@
-import { Mat4, Quat, easeInOut } from "./math";
+import { Mat4, Quat, Vec3, easeInOut } from "./math";
+import { IKSolverSystem } from "./ik-solver";
 const VERTEX_STRIDE = 8;
+// Euler rotation order for angle constraints
+export var EulerRotationOrder;
+(function (EulerRotationOrder) {
+    EulerRotationOrder[EulerRotationOrder["YXZ"] = 0] = "YXZ";
+    EulerRotationOrder[EulerRotationOrder["ZYX"] = 1] = "ZYX";
+    EulerRotationOrder[EulerRotationOrder["XZY"] = 2] = "XZY";
+})(EulerRotationOrder || (EulerRotationOrder = {}));
+// Solve axis optimization
+export var SolveAxis;
+(function (SolveAxis) {
+    SolveAxis[SolveAxis["None"] = 0] = "None";
+    SolveAxis[SolveAxis["Fixed"] = 1] = "Fixed";
+    SolveAxis[SolveAxis["X"] = 2] = "X";
+    SolveAxis[SolveAxis["Y"] = 3] = "Y";
+    SolveAxis[SolveAxis["Z"] = 4] = "Z";
+})(SolveAxis || (SolveAxis = {}));
 export class Model {
     constructor(vertexData, indexData, textures, materials, skeleton, skinning, morphing, rigidbodies = [], joints = []) {
         this.textures = [];
@@ -27,6 +44,7 @@ export class Model {
         }
         this.initializeRuntimeSkeleton();
         this.initializeRotTweenBuffers();
+        this.initializeTransTweenBuffers();
         this.initializeRuntimeMorph();
         this.initializeMorphTweenBuffers();
         this.applyMorphs(); // Apply initial morphs (all weights are 0, so no change)
@@ -53,6 +71,51 @@ export class Model {
                 rotations[qi + 3] = 1;
             }
         }
+        // Initialize IK runtime state
+        this.initializeIKRuntime();
+    }
+    initializeIKRuntime() {
+        const boneCount = this.skeleton.bones.length;
+        const bones = this.skeleton.bones;
+        // Initialize IK chain info for all bones (will be populated for IK chain bones)
+        const ikChainInfo = new Array(boneCount);
+        for (let i = 0; i < boneCount; i++) {
+            ikChainInfo[i] = {
+                ikRotation: new Quat(0, 0, 0, 1),
+                localRotation: new Quat(0, 0, 0, 1),
+            };
+        }
+        // Build IK solvers from bone data
+        const ikSolvers = [];
+        let solverIndex = 0;
+        for (let i = 0; i < boneCount; i++) {
+            const bone = bones[i];
+            if (bone.ikTargetIndex !== undefined && bone.ikLinks && bone.ikLinks.length > 0) {
+                // Check if all links are affected by physics (for optimization)
+                let canSkipWhenPhysicsEnabled = true;
+                for (const link of bone.ikLinks) {
+                    // For now, assume no bones are physics-controlled (can be enhanced later)
+                    // If a bone has a rigidbody attached, it's physics-controlled
+                    const hasPhysics = this.rigidbodies.some((rb) => rb.boneIndex === link.boneIndex);
+                    if (!hasPhysics) {
+                        canSkipWhenPhysicsEnabled = false;
+                        break;
+                    }
+                }
+                const solver = {
+                    index: solverIndex++,
+                    ikBoneIndex: i,
+                    targetBoneIndex: bone.ikTargetIndex,
+                    iterationCount: bone.ikIteration ?? 1,
+                    limitAngle: bone.ikLimitAngle ?? Math.PI,
+                    links: bone.ikLinks,
+                    canSkipWhenPhysicsEnabled,
+                };
+                ikSolvers.push(solver);
+            }
+        }
+        this.runtimeSkeleton.ikChainInfo = ikChainInfo;
+        this.runtimeSkeleton.ikSolvers = ikSolvers;
     }
     initializeRotTweenBuffers() {
         const n = this.skeleton.bones.length;
@@ -64,6 +127,16 @@ export class Model {
             durationMs: new Float32Array(n),
         };
     }
+    initializeTransTweenBuffers() {
+        const n = this.skeleton.bones.length;
+        this.transTweenState = {
+            active: new Uint8Array(n),
+            startVec: new Float32Array(n * 3),
+            targetVec: new Float32Array(n * 3),
+            startTimeMs: new Float32Array(n),
+            durationMs: new Float32Array(n),
+        };
+    }
     initializeMorphTweenBuffers() {
         const n = this.morphing.morphs.length;
         this.morphTweenState = {
@@ -108,6 +181,26 @@ export class Model {
                 state.active[i] = 0;
         }
     }
+    updateTranslationTweens() {
+        const state = this.transTweenState;
+        const now = performance.now();
+        const translations = this.runtimeSkeleton.localTranslations;
+        const boneCount = this.skeleton.bones.length;
+        for (let i = 0; i < boneCount; i++) {
+            if (state.active[i] !== 1)
+                continue;
+            const startMs = state.startTimeMs[i];
+            const durMs = Math.max(1, state.durationMs[i]);
+            const t = Math.max(0, Math.min(1, (now - startMs) / durMs));
+            const e = easeInOut(t);
+            const ti = i * 3;
+            translations[ti] = state.startVec[ti] + (state.targetVec[ti] - state.startVec[ti]) * e;
+            translations[ti + 1] = state.startVec[ti + 1] + (state.targetVec[ti + 1] - state.startVec[ti + 1]) * e;
+            translations[ti + 2] = state.startVec[ti + 2] + (state.targetVec[ti + 2] - state.startVec[ti + 2]) * e;
+            if (t >= 1)
+                state.active[i] = 0;
+        }
+    }
     updateMorphWeightTweens() {
         const state = this.morphTweenState;
         const now = performance.now();
@@ -231,6 +324,91 @@ export class Model {
             state.active[idx] = 1;
         }
     }
+    // Move bones using VMD-style relative translations (relative to bind pose world position)
+    // This is the default behavior for VMD animations
+    moveBones(names, relativeTranslations, durationMs) {
+        const state = this.transTweenState;
+        const now = performance.now();
+        const dur = durationMs && durationMs > 0 ? durationMs : 0;
+        const localRot = this.runtimeSkeleton.localRotations;
+        // 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 (let i = 0; i < names.length; i++) {
+            const name = names[i];
+            const idx = this.runtimeSkeleton.nameIndex[name] ?? -1;
+            if (idx < 0 || idx >= this.skeleton.bones.length)
+                continue;
+            const bone = this.skeleton.bones[idx];
+            const ti = idx * 3;
+            const qi = idx * 4;
+            const translations = this.runtimeSkeleton.localTranslations;
+            const vmdRelativeTranslation = relativeTranslations[i];
+            // 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 = new Vec3(0, 0, 0);
+            }
+            // 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 = new Quat(localRot[qi], localRot[qi + 1], localRot[qi + 2], localRot[qi + 3]);
+            const invRotation = localRotation.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);
+            const [tx, ty, tz] = [localTranslation.x, localTranslation.y, localTranslation.z];
+            if (dur === 0) {
+                translations[ti] = tx;
+                translations[ti + 1] = ty;
+                translations[ti + 2] = tz;
+                state.active[idx] = 0;
+                continue;
+            }
+            let sx = translations[ti];
+            let sy = translations[ti + 1];
+            let sz = translations[ti + 2];
+            if (state.active[idx] === 1) {
+                const startMs = state.startTimeMs[idx];
+                const prevDur = Math.max(1, state.durationMs[idx]);
+                const t = Math.max(0, Math.min(1, (now - startMs) / prevDur));
+                const e = easeInOut(t);
+                sx = state.startVec[ti] + (state.targetVec[ti] - state.startVec[ti]) * e;
+                sy = state.startVec[ti + 1] + (state.targetVec[ti + 1] - state.startVec[ti + 1]) * e;
+                sz = state.startVec[ti + 2] + (state.targetVec[ti + 2] - state.startVec[ti + 2]) * e;
+            }
+            state.startVec[ti] = sx;
+            state.startVec[ti + 1] = sy;
+            state.startVec[ti + 2] = sz;
+            state.targetVec[ti] = tx;
+            state.targetVec[ti + 1] = ty;
+            state.targetVec[ti + 2] = tz;
+            state.startTimeMs[idx] = now;
+            state.durationMs[idx] = dur;
+            state.active[idx] = 1;
+        }
+    }
     getBoneWorldMatrices() {
         return this.runtimeSkeleton.worldMatrices;
     }
@@ -334,13 +512,29 @@ export class Model {
     }
     evaluatePose() {
         this.updateRotationTweens();
+        this.updateTranslationTweens();
         const hasActiveMorphTweens = this.updateMorphWeightTweens();
         if (hasActiveMorphTweens) {
             this.applyMorphs();
         }
+        // Compute initial world matrices (needed for IK solving)
+        this.computeWorldMatrices();
+        // Solve IK chains (modifies localRotations)
+        this.solveIKChains();
+        // Recompute world matrices with IK rotations applied
         this.computeWorldMatrices();
         return hasActiveMorphTweens;
     }
+    solveIKChains() {
+        const ikSolvers = this.runtimeSkeleton.ikSolvers;
+        if (!ikSolvers || ikSolvers.length === 0)
+            return;
+        const ikChainInfo = this.runtimeSkeleton.ikChainInfo;
+        if (!ikChainInfo)
+            return;
+        IKSolverSystem.solve(ikSolvers, this.skeleton.bones, this.runtimeSkeleton.localRotations, this.runtimeSkeleton.localTranslations, this.runtimeSkeleton.worldMatrices, ikChainInfo, false // usePhysics - can be enhanced later
+        );
+    }
     computeWorldMatrices() {
         const bones = this.skeleton.bones;
         const localRot = this.runtimeSkeleton.localRotations;
@@ -397,11 +591,15 @@ export class Model {
                     }
                 }
             }
-            // Build local matrix: identity + bind translation, then rotation, then append translation
+            // Build local matrix: identity + bind translation, then rotation, then local translation, then append translation
+            const ti = i * 3;
+            const localTx = localTrans[ti] + addLocalTx;
+            const localTy = localTrans[ti + 1] + addLocalTy;
+            const localTz = localTrans[ti + 2] + addLocalTz;
             this.cachedIdentityMat1
                 .setIdentity()
                 .translateInPlace(b.bindTranslation[0], b.bindTranslation[1], b.bindTranslation[2]);
-            this.cachedIdentityMat2.setIdentity().translateInPlace(addLocalTx, addLocalTy, addLocalTz);
+            this.cachedIdentityMat2.setIdentity().translateInPlace(localTx, localTy, localTz);
             const localM = this.cachedIdentityMat1.multiply(rotateM).multiply(this.cachedIdentityMat2);
             const worldOffset = i * 16;
             if (b.parentIndex >= 0) {

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,EAUN,MAAM,SAAS,CAAA;AAIhB,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;IAK9C,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;IAyFtB,OAAO,CAAC,UAAU;IA2IlB,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;AAIhB,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;IAK9C,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;IAyFtB,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"}

package/dist/pmx-loader.js

@@ -336,55 +336,76 @@ export class PmxLoader {
                     this.getInt32();
                 }
                 // IK block
+                let ikTargetIndex = undefined;
+                let ikIteration = undefined;
+                let ikLimitAngle = undefined;
+                let ikLinks = undefined;
                 if ((flags & FLAG_IK) !== 0) {
-                    this.getNonVertexIndex(this.boneIndexSize); // target
-                    this.getInt32(); // iteration
-                    this.getFloat32(); // rotationConstraint
+                    ikTargetIndex = this.getNonVertexIndex(this.boneIndexSize); // target
+                    ikIteration = this.getInt32(); // iteration
+                    ikLimitAngle = this.getFloat32(); // rotationConstraint
                     const linksCount = this.getInt32();
+                    ikLinks = [];
                     for (let li = 0; li < linksCount; li++) {
-                        this.getNonVertexIndex(this.boneIndexSize); // link target
+                        const linkBoneIndex = this.getNonVertexIndex(this.boneIndexSize); // link target
                         const hasLimit = this.getUint8() === 1;
+                        let minAngle = undefined;
+                        let maxAngle = undefined;
                         if (hasLimit) {
                             // min and max angles (vec3 each)
-                            this.getFloat32();
-                            this.getFloat32();
-                            this.getFloat32();
-                            this.getFloat32();
-                            this.getFloat32();
-                            this.getFloat32();
+                            const minX = this.getFloat32();
+                            const minY = this.getFloat32();
+                            const minZ = this.getFloat32();
+                            const maxX = this.getFloat32();
+                            const maxY = this.getFloat32();
+                            const maxZ = this.getFloat32();
+                            minAngle = new Vec3(minX, minY, minZ);
+                            maxAngle = new Vec3(maxX, maxY, maxZ);
                         }
+                        ikLinks.push({
+                            boneIndex: linkBoneIndex,
+                            hasLimit,
+                            minAngle,
+                            maxAngle,
+                        });
                     }
                 }
                 // Stash minimal bone info; append data will be merged later
-                abs[i] = { name, parent: parentIndex, x, y, z, appendParent, appendRatio, appendRotate, appendMove };
+                abs[i] = {
+                    name,
+                    parent: parentIndex,
+                    x,
+                    y,
+                    z,
+                    appendParent,
+                    appendRatio,
+                    appendRotate,
+                    appendMove,
+                    ikTargetIndex,
+                    ikIteration,
+                    ikLimitAngle,
+                    ikLinks,
+                };
             }
             for (let i = 0; i < count; i++) {
                 const a = abs[i];
-                if (a.parent >= 0 && a.parent < count) {
-                    const p = abs[a.parent];
-                    bones.push({
-                        name: a.name,
-                        parentIndex: a.parent,
-                        bindTranslation: [a.x - p.x, a.y - p.y, a.z - p.z],
-                        children: [], // Will be populated later when building skeleton
-                        appendParentIndex: a.appendParent,
-                        appendRatio: a.appendRatio,
-                        appendRotate: a.appendRotate,
-                        appendMove: a.appendMove,
-                    });
-                }
-                else {
-                    bones.push({
-                        name: a.name,
-                        parentIndex: a.parent,
-                        bindTranslation: [a.x, a.y, a.z],
-                        children: [], // Will be populated later when building skeleton
-                        appendParentIndex: a.appendParent,
-                        appendRatio: a.appendRatio,
-                        appendRotate: a.appendRotate,
-                        appendMove: a.appendMove,
-                    });
-                }
+                const boneData = {
+                    name: a.name,
+                    parentIndex: a.parent,
+                    bindTranslation: a.parent >= 0 && a.parent < count
+                        ? [a.x - abs[a.parent].x, a.y - abs[a.parent].y, a.z - abs[a.parent].z]
+                        : [a.x, a.y, a.z],
+                    children: [], // Will be populated later when building skeleton
+                    appendParentIndex: a.appendParent,
+                    appendRatio: a.appendRatio,
+                    appendRotate: a.appendRotate,
+                    appendMove: a.appendMove,
+                    ikTargetIndex: a.ikTargetIndex,
+                    ikIteration: a.ikIteration,
+                    ikLimitAngle: a.ikLimitAngle,
+                    ikLinks: a.ikLinks,
+                };
+                bones.push(boneData);
             }
             this.bones = bones;
         }

package/dist/vmd-loader.d.ts

@@ -1,12 +1,20 @@
-import { Quat } from "./math";
+import { Quat, Vec3 } from "./math";
 export interface BoneFrame {
     boneName: string;
     frame: number;
     rotation: Quat;
+    translation: Vec3;
+    interpolation: Uint8Array;
+}
+export interface MorphFrame {
+    morphName: string;
+    frame: number;
+    weight: number;
 }
 export interface VMDKeyFrame {
     time: number;
     boneFrames: BoneFrame[];
+    morphFrames: MorphFrame[];
 }
 export declare class VMDLoader {
     private view;
@@ -17,6 +25,8 @@ export declare class VMDLoader {
     static loadFromBuffer(buffer: ArrayBuffer): VMDKeyFrame[];
     private parse;
     private readBoneFrame;
+    private readMorphFrame;
+    private getUint8;
     private getUint32;
     private getFloat32;
     private getString;

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

@@ -1 +1 @@
-{"version":3,"file":"vmd-loader.d.ts","sourceRoot":"","sources":["../src/vmd-loader.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAA;AAE7B,MAAM,WAAW,SAAS;IACxB,QAAQ,EAAE,MAAM,CAAA;IAChB,KAAK,EAAE,MAAM,CAAA;IACb,QAAQ,EAAE,IAAI,CAAA;CACf;AAED,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,MAAM,CAAA;IACZ,UAAU,EAAE,SAAS,EAAE,CAAA;CACxB;AAED,qBAAa,SAAS;IACpB,OAAO,CAAC,IAAI,CAAU;IACtB,OAAO,CAAC,MAAM,CAAI;IAClB,OAAO,CAAC,OAAO,CAAa;IAE5B,OAAO;WAWM,IAAI,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,EAAE,CAAC;IAKtD,MAAM,CAAC,cAAc,CAAC,MAAM,EAAE,WAAW,GAAG,WAAW,EAAE;IAKzD,OAAO,CAAC,KAAK;IA8Db,OAAO,CAAC,aAAa;IA+CrB,OAAO,CAAC,SAAS;IASjB,OAAO,CAAC,UAAU;IASlB,OAAO,CAAC,SAAS;IAMjB,OAAO,CAAC,IAAI;CAMb"}
+{"version":3,"file":"vmd-loader.d.ts","sourceRoot":"","sources":["../src/vmd-loader.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAA;AAEnC,MAAM,WAAW,SAAS;IACxB,QAAQ,EAAE,MAAM,CAAA;IAChB,KAAK,EAAE,MAAM,CAAA;IACb,QAAQ,EAAE,IAAI,CAAA;IACd,WAAW,EAAE,IAAI,CAAA;IACjB,aAAa,EAAE,UAAU,CAAA;CAC1B;AAED,MAAM,WAAW,UAAU;IACzB,SAAS,EAAE,MAAM,CAAA;IACjB,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,MAAM,CAAA;CACf;AAED,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,MAAM,CAAA;IACZ,UAAU,EAAE,SAAS,EAAE,CAAA;IACvB,WAAW,EAAE,UAAU,EAAE,CAAA;CAC1B;AAED,qBAAa,SAAS;IACpB,OAAO,CAAC,IAAI,CAAU;IACtB,OAAO,CAAC,MAAM,CAAI;IAClB,OAAO,CAAC,OAAO,CAAa;IAE5B,OAAO;WAWM,IAAI,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,EAAE,CAAC;IAKtD,MAAM,CAAC,cAAc,CAAC,MAAM,EAAE,WAAW,GAAG,WAAW,EAAE;IAKzD,OAAO,CAAC,KAAK;IAgGb,OAAO,CAAC,aAAa;IAuDrB,OAAO,CAAC,cAAc;IAqCtB,OAAO,CAAC,QAAQ;IAShB,OAAO,CAAC,SAAS;IASjB,OAAO,CAAC,UAAU;IASlB,OAAO,CAAC,SAAS;IAMjB,OAAO,CAAC,IAAI;CAMb"}

package/dist/vmd-loader.js

@@ -1,4 +1,4 @@
-import { Quat } from "./math";
+import { Quat, Vec3 } from "./math";
 export class VMDLoader {
     constructor(buffer) {
         this.offset = 0;
@@ -34,39 +34,67 @@ export class VMDLoader {
         const allBoneFrames = [];
         for (let i = 0; i < boneFrameCount; i++) {
             const boneFrame = this.readBoneFrame();
-            // Convert frame number to time (assuming 30 FPS like the Rust code)
+            // Convert frame number to time (30 FPS)
             const FRAME_RATE = 30.0;
             const time = boneFrame.frame / FRAME_RATE;
             allBoneFrames.push({ time, boneFrame });
         }
+        // Read morph frame count (4 bytes, u32 little endian)
+        const morphFrameCount = this.getUint32();
+        // Read all morph frames
+        const allMorphFrames = [];
+        for (let i = 0; i < morphFrameCount; i++) {
+            const morphFrame = this.readMorphFrame();
+            // Convert frame number to time (30 FPS)
+            const FRAME_RATE = 30.0;
+            const time = morphFrame.frame / FRAME_RATE;
+            allMorphFrames.push({ time, morphFrame });
+        }
+        // Combine all frames and group by time
+        const allFrames = [];
+        for (const { time, boneFrame } of allBoneFrames) {
+            allFrames.push({ time, boneFrame });
+        }
+        for (const { time, morphFrame } of allMorphFrames) {
+            allFrames.push({ time, morphFrame });
+        }
+        // Sort by time
+        allFrames.sort((a, b) => a.time - b.time);
         // Group by time and convert to VMDKeyFrame format
-        // Sort by time first
-        allBoneFrames.sort((a, b) => a.time - b.time);
         const keyFrames = [];
         let currentTime = -1.0;
         let currentBoneFrames = [];
-        for (const { time, boneFrame } of allBoneFrames) {
-            if (Math.abs(time - currentTime) > 0.001) {
+        let currentMorphFrames = [];
+        for (const frame of allFrames) {
+            if (Math.abs(frame.time - currentTime) > 0.001) {
                 // New time frame
-                if (currentBoneFrames.length > 0) {
+                if (currentBoneFrames.length > 0 || currentMorphFrames.length > 0) {
                     keyFrames.push({
                         time: currentTime,
                         boneFrames: currentBoneFrames,
+                        morphFrames: currentMorphFrames,
                     });
                 }
-                currentTime = time;
-                currentBoneFrames = [boneFrame];
+                currentTime = frame.time;
+                currentBoneFrames = frame.boneFrame ? [frame.boneFrame] : [];
+                currentMorphFrames = frame.morphFrame ? [frame.morphFrame] : [];
             }
             else {
                 // Same time frame
-                currentBoneFrames.push(boneFrame);
+                if (frame.boneFrame) {
+                    currentBoneFrames.push(frame.boneFrame);
+                }
+                if (frame.morphFrame) {
+                    currentMorphFrames.push(frame.morphFrame);
+                }
             }
         }
         // Add the last frame
-        if (currentBoneFrames.length > 0) {
+        if (currentBoneFrames.length > 0 || currentMorphFrames.length > 0) {
             keyFrames.push({
                 time: currentTime,
                 boneFrames: currentBoneFrames,
+                morphFrames: currentMorphFrames,
             });
         }
         return keyFrames;
@@ -95,22 +123,70 @@ export class VMDLoader {
         }
         // Read frame number (4 bytes, little endian)
         const frame = this.getUint32();
-        // Skip position (12 bytes: 3 x f32, little endian)
-        this.skip(12);
+        // Read position/translation (12 bytes: 3 x f32, little endian)
+        const posX = this.getFloat32();
+        const posY = this.getFloat32();
+        const posZ = this.getFloat32();
+        const translation = new Vec3(posX, posY, posZ);
         // Read rotation quaternion (16 bytes: 4 x f32, little endian)
         const rotX = this.getFloat32();
         const rotY = this.getFloat32();
         const rotZ = this.getFloat32();
         const rotW = this.getFloat32();
         const rotation = new Quat(rotX, rotY, rotZ, rotW);
-        // Skip interpolation parameters (64 bytes)
-        this.skip(64);
+        // Read interpolation parameters (64 bytes)
+        const interpolation = new Uint8Array(64);
+        for (let i = 0; i < 64; i++) {
+            interpolation[i] = this.getUint8();
+        }
         return {
             boneName,
             frame,
             rotation,
+            translation,
+            interpolation,
         };
     }
+    readMorphFrame() {
+        // Read morph name (15 bytes)
+        const nameBuffer = new Uint8Array(this.view.buffer, this.offset, 15);
+        this.offset += 15;
+        // Find the actual length of the morph name (stop at first null byte)
+        let nameLength = 15;
+        for (let i = 0; i < 15; i++) {
+            if (nameBuffer[i] === 0) {
+                nameLength = i;
+                break;
+            }
+        }
+        // Decode Shift-JIS morph name
+        let morphName;
+        try {
+            const nameSlice = nameBuffer.slice(0, nameLength);
+            morphName = this.decoder.decode(nameSlice);
+        }
+        catch {
+            // Fallback to lossy decoding if there were encoding errors
+            morphName = String.fromCharCode(...nameBuffer.slice(0, nameLength));
+        }
+        // Read frame number (4 bytes, little endian)
+        const frame = this.getUint32();
+        // Read weight (4 bytes, f32, little endian)
+        const weight = this.getFloat32();
+        return {
+            morphName,
+            frame,
+            weight,
+        };
+    }
+    getUint8() {
+        if (this.offset + 1 > this.view.buffer.byteLength) {
+            throw new RangeError(`Offset ${this.offset} + 1 exceeds buffer bounds ${this.view.buffer.byteLength}`);
+        }
+        const v = this.view.getUint8(this.offset);
+        this.offset += 1;
+        return v;
+    }
     getUint32() {
         if (this.offset + 4 > this.view.buffer.byteLength) {
             throw new RangeError(`Offset ${this.offset} + 4 exceeds buffer bounds ${this.view.buffer.byteLength}`);

package/package.json

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

package/src/bezier-interpolate.ts

@@ -0,0 +1,47 @@
+/**
+ * Bezier interpolation for VMD animations
+ * Based on the reference implementation from babylon-mmd
+ */
+
+/**
+ * Bezier interpolation function
+ * @param x1 First control point X (0-127, normalized to 0-1)
+ * @param x2 Second control point X (0-127, normalized to 0-1)
+ * @param y1 First control point Y (0-127, normalized to 0-1)
+ * @param y2 Second control point Y (0-127, normalized to 0-1)
+ * @param t Interpolation parameter (0-1)
+ * @returns Interpolated value (0-1)
+ */
+export function bezierInterpolate(x1: number, x2: number, y1: number, y2: number, t: number): number {
+  // Clamp t to [0, 1]
+  t = Math.max(0, Math.min(1, t))
+
+  // Binary search for the t value that gives us the desired x
+  // We're solving for t in the Bezier curve: x(t) = 3*(1-t)^2*t*x1 + 3*(1-t)*t^2*x2 + t^3
+  let start = 0
+  let end = 1
+  let mid = 0.5
+
+  // Iterate until we find the t value that gives us the desired x
+  for (let i = 0; i < 15; i++) {
+    // Evaluate Bezier curve at mid point
+    const x = 3 * (1 - mid) * (1 - mid) * mid * x1 + 3 * (1 - mid) * mid * mid * x2 + mid * mid * mid
+
+    if (Math.abs(x - t) < 0.0001) {
+      break
+    }
+
+    if (x < t) {
+      start = mid
+    } else {
+      end = mid
+    }
+
+    mid = (start + end) / 2
+  }
+
+  // Now evaluate the y value at this t
+  const y = 3 * (1 - mid) * (1 - mid) * mid * y1 + 3 * (1 - mid) * mid * mid * y2 + mid * mid * mid
+
+  return y
+}