reze-engine 0.2.18 → 0.3.0

package/dist/pmx-loader.js

@@ -1,4 +1,4 @@
-import { Model } from "./model";
+import { Model, } from "./model";
 import { Mat4, Vec3 } from "./math";
 export class PmxLoader {
     constructor(buffer) {
@@ -17,6 +17,8 @@ export class PmxLoader {
         this.inverseBindMatrices = null;
         this.joints0 = null;
         this.weights0 = null;
+        this.morphs = [];
+        this.vertexCount = 0;
         this.rigidbodies = [];
         this.joints = [];
         this.view = new DataView(buffer);
@@ -28,12 +30,13 @@ export class PmxLoader {
     parse() {
         this.parseHeader();
         const { positions, normals, uvs } = this.parseVertices();
+        this.vertexCount = positions.length / 3;
         const indices = this.parseIndices();
         this.parseTextures();
         this.parseMaterials();
         this.parseBones();
-        // Skip morphs and display frames before parsing rigidbodies
-        this.skipMorphs();
+        // Parse morphs and display frames before parsing rigidbodies
+        this.parseMorphs();
         this.skipDisplayFrames();
         this.parseRigidbodies();
         this.parseJoints();
@@ -333,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;
         }
@@ -390,114 +414,146 @@ export class PmxLoader {
             this.bones = [];
         }
     }
-    skipMorphs() {
+    parseMorphs() {
         try {
             // Check if we have enough bytes to read the count
             if (this.offset + 4 > this.view.buffer.byteLength) {
-                return false;
+                this.morphs = [];
+                return;
             }
             const count = this.getInt32();
             if (count < 0 || count > 100000) {
-                // Suspicious count, likely corrupted - restore offset
-                this.offset -= 4;
-                return false;
+                // Suspicious count, likely corrupted
+                console.warn(`Suspicious morph count: ${count}`);
+                this.morphs = [];
+                return;
             }
+            this.morphs = [];
             for (let i = 0; i < count; i++) {
                 // Check bounds before reading each morph
                 if (this.offset >= this.view.buffer.byteLength) {
-                    return false;
+                    break;
                 }
                 try {
-                    this.getText(); // name
-                    this.getText(); // englishName
-                    this.getUint8(); // panelType
+                    const name = this.getText();
+                    this.getText(); // englishName (skip)
+                    this.getUint8(); // panelType (skip)
                     const morphType = this.getUint8();
                     const offsetCount = this.getInt32();
-                    // Skip offsets based on morph type
-                    for (let j = 0; j < offsetCount; j++) {
-                        if (this.offset >= this.view.buffer.byteLength) {
-                            return false;
-                        }
-                        if (morphType === 0) {
-                            // Group morph
-                            this.getNonVertexIndex(this.morphIndexSize); // morphIndex
-                            this.getFloat32(); // ratio
-                        }
-                        else if (morphType === 1) {
-                            // Vertex morph
-                            this.getIndex(this.vertexIndexSize); // vertexIndex
-                            this.getFloat32(); // x
-                            this.getFloat32(); // y
-                            this.getFloat32(); // z
-                        }
-                        else if (morphType === 2) {
-                            // Bone morph
-                            this.getNonVertexIndex(this.boneIndexSize); // boneIndex
-                            this.getFloat32(); // x
-                            this.getFloat32(); // y
-                            this.getFloat32(); // z
-                            this.getFloat32(); // rx
-                            this.getFloat32(); // ry
-                            this.getFloat32(); // rz
-                        }
-                        else if (morphType === 3) {
-                            // UV morph
-                            this.getIndex(this.vertexIndexSize); // vertexIndex
-                            this.getFloat32(); // u
-                            this.getFloat32(); // v
+                    const morph = {
+                        name,
+                        type: morphType,
+                        vertexOffsets: [],
+                        groupReferences: [],
+                    };
+                    // Parse vertex morphs (type 1)
+                    if (morphType === 1) {
+                        for (let j = 0; j < offsetCount; j++) {
+                            if (this.offset >= this.view.buffer.byteLength) {
+                                break;
+                            }
+                            const vertexIndex = this.getIndex(this.vertexIndexSize);
+                            const x = this.getFloat32();
+                            const y = this.getFloat32();
+                            const z = this.getFloat32();
+                            if (vertexIndex >= 0 && vertexIndex < this.vertexCount) {
+                                morph.vertexOffsets.push({
+                                    vertexIndex,
+                                    positionOffset: [x, y, z],
+                                });
+                            }
                         }
-                        else if (morphType === 4 || morphType === 5 || morphType === 6 || morphType === 7) {
-                            // UV morph types 4-7 (additional UV channels)
-                            this.getIndex(this.vertexIndexSize); // vertexIndex
-                            this.getFloat32(); // u
-                            this.getFloat32(); // v
+                    }
+                    else if (morphType === 0) {
+                        // Parse group morphs
+                        for (let j = 0; j < offsetCount; j++) {
+                            if (this.offset >= this.view.buffer.byteLength) {
+                                break;
+                            }
+                            const morphIndex = this.getNonVertexIndex(this.morphIndexSize);
+                            const ratio = this.getFloat32();
+                            if (morphIndex >= 0) {
+                                morph.groupReferences.push({
+                                    morphIndex,
+                                    ratio,
+                                });
+                            }
                         }
-                        else if (morphType === 8) {
-                            // Material morph
-                            this.getNonVertexIndex(this.materialIndexSize); // materialIndex
-                            this.getUint8(); // offsetType
-                            this.getFloat32(); // diffuse r
-                            this.getFloat32(); // diffuse g
-                            this.getFloat32(); // diffuse b
-                            this.getFloat32(); // diffuse a
-                            this.getFloat32(); // specular r
-                            this.getFloat32(); // specular g
-                            this.getFloat32(); // specular b
-                            this.getFloat32(); // specular power
-                            this.getFloat32(); // ambient r
-                            this.getFloat32(); // ambient g
-                            this.getFloat32(); // ambient b
-                            this.getFloat32(); // edgeColor r
-                            this.getFloat32(); // edgeColor g
-                            this.getFloat32(); // edgeColor b
-                            this.getFloat32(); // edgeColor a
-                            this.getFloat32(); // edgeSize
-                            this.getFloat32(); // textureCoeff r
-                            this.getFloat32(); // textureCoeff g
-                            this.getFloat32(); // textureCoeff b
-                            this.getFloat32(); // textureCoeff a
-                            this.getFloat32(); // sphereCoeff r
-                            this.getFloat32(); // sphereCoeff g
-                            this.getFloat32(); // sphereCoeff b
-                            this.getFloat32(); // sphereCoeff a
-                            this.getFloat32(); // toonCoeff r
-                            this.getFloat32(); // toonCoeff g
-                            this.getFloat32(); // toonCoeff b
-                            this.getFloat32(); // toonCoeff a
+                    }
+                    else {
+                        // Skip other morph types for now
+                        for (let j = 0; j < offsetCount; j++) {
+                            if (this.offset >= this.view.buffer.byteLength) {
+                                break;
+                            }
+                            if (morphType === 2) {
+                                // Bone morph
+                                this.getNonVertexIndex(this.boneIndexSize); // boneIndex
+                                this.getFloat32(); // x
+                                this.getFloat32(); // y
+                                this.getFloat32(); // z
+                                this.getFloat32(); // rx
+                                this.getFloat32(); // ry
+                                this.getFloat32(); // rz
+                            }
+                            else if (morphType === 3) {
+                                // UV morph
+                                this.getIndex(this.vertexIndexSize); // vertexIndex
+                                this.getFloat32(); // u
+                                this.getFloat32(); // v
+                            }
+                            else if (morphType === 4 || morphType === 5 || morphType === 6 || morphType === 7) {
+                                // UV morph types 4-7 (additional UV channels)
+                                this.getIndex(this.vertexIndexSize); // vertexIndex
+                                this.getFloat32(); // u
+                                this.getFloat32(); // v
+                            }
+                            else if (morphType === 8) {
+                                // Material morph
+                                this.getNonVertexIndex(this.materialIndexSize); // materialIndex
+                                this.getUint8(); // offsetType
+                                this.getFloat32(); // diffuse r
+                                this.getFloat32(); // diffuse g
+                                this.getFloat32(); // diffuse b
+                                this.getFloat32(); // diffuse a
+                                this.getFloat32(); // specular r
+                                this.getFloat32(); // specular g
+                                this.getFloat32(); // specular b
+                                this.getFloat32(); // specular power
+                                this.getFloat32(); // ambient r
+                                this.getFloat32(); // ambient g
+                                this.getFloat32(); // ambient b
+                                this.getFloat32(); // edgeColor r
+                                this.getFloat32(); // edgeColor g
+                                this.getFloat32(); // edgeColor b
+                                this.getFloat32(); // edgeColor a
+                                this.getFloat32(); // edgeSize
+                                this.getFloat32(); // textureCoeff r
+                                this.getFloat32(); // textureCoeff g
+                                this.getFloat32(); // textureCoeff b
+                                this.getFloat32(); // textureCoeff a
+                                this.getFloat32(); // sphereCoeff r
+                                this.getFloat32(); // sphereCoeff g
+                                this.getFloat32(); // sphereCoeff b
+                                this.getFloat32(); // sphereCoeff a
+                                this.getFloat32(); // toonCoeff r
+                                this.getFloat32(); // toonCoeff g
+                                this.getFloat32(); // toonCoeff b
+                                this.getFloat32(); // toonCoeff a
+                            }
                         }
                     }
+                    this.morphs.push(morph);
                 }
                 catch (e) {
-                    // If we fail to read a morph, stop skipping
+                    // If we fail to read a morph, skip it
                     console.warn(`Error reading morph ${i}:`, e);
-                    return false;
                 }
             }
-            return true;
         }
         catch (e) {
-            console.warn("Error skipping morphs:", e);
-            return false;
+            console.warn("Error parsing morphs:", e);
+            this.morphs = [];
         }
     }
     skipDisplayFrames() {
@@ -748,9 +804,9 @@ export class PmxLoader {
     }
     toModel(positions, normals, uvs, indices) {
         // Create indexed vertex buffer
-        const vertexCount = positions.length / 3;
-        const vertexData = new Float32Array(vertexCount * 8);
-        for (let i = 0; i < vertexCount; i++) {
+        // Format: [x,y,z, nx,ny,nz, u,v, x,y,z, ...]
+        const vertexData = new Float32Array(this.vertexCount * 8);
+        for (let i = 0; i < this.vertexCount; i++) {
             const pi = i * 3;
             const ui = i * 2;
             const vi = i * 8;
@@ -862,16 +918,48 @@ export class PmxLoader {
         }
         else {
             // Create default skinning (single bone per vertex)
-            const vertexCount = positions.length / 3;
-            const joints = new Uint16Array(vertexCount * 4);
-            const weights = new Uint8Array(vertexCount * 4);
-            for (let i = 0; i < vertexCount; i++) {
+            const joints = new Uint16Array(this.vertexCount * 4);
+            const weights = new Uint8Array(this.vertexCount * 4);
+            for (let i = 0; i < this.vertexCount; i++) {
                 joints[i * 4] = 0;
                 weights[i * 4] = 255;
             }
             skinning = { joints, weights };
         }
-        return new Model(vertexData, indexData, this.textures, this.materials, skeleton, skinning, this.rigidbodies, this.joints);
+        // 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];
+                    }
+                }
+            }
+        }
+        const morphing = {
+            morphs: this.morphs,
+            offsetsBuffer,
+        };
+        return new Model(vertexData, indexData, this.textures, this.materials, skeleton, skinning, morphing, this.rigidbodies, this.joints);
     }
     getUint8() {
         if (this.offset >= this.view.buffer.byteLength) {

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.18",
+    "version": "0.3.0",
     "description": "A WebGPU-based MMD model renderer",
     "main": "./dist/index.js",
     "types": "./dist/index.d.ts",