reze-engine 0.2.19 → 0.3.1

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.1",
     "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
+}