reze-engine 0.6.7 → 0.8.0

package/dist/model.js

@@ -1,9 +1,19 @@
-import { Mat4, Quat, Vec3, bezierInterpolate } from "./math";
+import { Mat4, Quat, Vec3 } from "./math";
+import { Engine } from "./engine";
+import { PmxLoader } from "./pmx-loader";
 import { Physics } from "./physics";
 import { IKSolverSystem } from "./ik-solver";
 import { VMDLoader } from "./vmd-loader";
+import { interpolateControlPoints, rawInterpolationToBoneInterpolation } from "./animation";
+const VMD_FPS = 30;
 const VERTEX_STRIDE = 8;
 export class Model {
+    // loadPmx: fetch PMX + register with Engine.getInstance() (init engine first)
+    static async loadPmx(path) {
+        const model = await PmxLoader.load(path);
+        await Engine.getInstance().registerModel(model, path);
+        return model;
+    }
     constructor(vertexData, indexData, textures, materials, skeleton, skinning, morphing, rigidbodies = [], joints = []) {
         this.textures = [];
         this.materials = [];
@@ -16,7 +26,7 @@ export class Model {
         this.cachedIdentityMat2 = Mat4.identity();
         this.tweenTimeMs = 0; // Time tracking for tweens (milliseconds)
         // Animation runtime
-        this.animationData = null;
+        this._hasAnimation = false;
         this.boneTracks = new Map();
         this.morphTracks = new Map();
         this.animationDuration = 0;
@@ -239,6 +249,13 @@ export class Model {
     getSkeleton() {
         return this.skeleton;
     }
+    // World bone origin (world matrix col3); unknown name → null
+    getBoneWorldPosition(boneName) {
+        const idx = this.runtimeSkeleton.nameIndex[boneName];
+        if (idx === undefined || idx < 0)
+            return null;
+        return this.runtimeSkeleton.worldMatrices[idx].getPosition();
+    }
     getSkinning() {
         return this.skinning;
     }
@@ -345,14 +362,7 @@ 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.
-     */
+    // VMD translation (world delta from bind pose) → bone local space; optional rotation for animation vs IK
     convertVMDTranslationToLocal(boneIdx, vmdRelativeTranslation, rotation) {
         const skeleton = this.skeleton;
         const bones = skeleton.bones;
@@ -441,6 +451,12 @@ export class Model {
             this.runtimeMorph.weights[idx] = clampedWeight;
             this.tweenState.morphActive[idx] = 0;
             this.applyMorphs();
+            try {
+                Engine.getInstance().markVertexBufferDirty();
+            }
+            catch {
+                /* not registered yet */
+            }
             return;
         }
         // Animated change
@@ -464,49 +480,6 @@ export class Model {
         this.runtimeMorph.weights[idx] = startWeight;
         this.applyMorphs();
     }
-    /**
-     * Atomic pose setter for external animation editors.
-     * Sets bone rotations, translations, and morph weights in a single pass,
-     * identical to how getPoseAtTime applies VMD poses during playback.
-     * Cancels any active tweens on affected bones/morphs.
-     */
-    setPose(rotations, translations, morphs) {
-        const state = this.tweenState;
-        if (rotations) {
-            for (const [name, quat] of Object.entries(rotations)) {
-                const idx = this.runtimeSkeleton.nameIndex[name] ?? -1;
-                if (idx < 0 || idx >= this.skeleton.bones.length)
-                    continue;
-                this.runtimeSkeleton.localRotations[idx].set(quat.clone().normalize());
-                state.rotActive[idx] = 0;
-            }
-        }
-        if (translations) {
-            for (const [name, vec] of Object.entries(translations)) {
-                const idx = this.runtimeSkeleton.nameIndex[name] ?? -1;
-                if (idx < 0 || idx >= this.skeleton.bones.length)
-                    continue;
-                const rotation = rotations?.[name]?.clone().normalize();
-                const localTranslation = this.convertVMDTranslationToLocal(idx, vec, rotation);
-                this.runtimeSkeleton.localTranslations[idx].set(localTranslation);
-                state.transActive[idx] = 0;
-            }
-        }
-        if (morphs) {
-            let morphChanged = false;
-            for (const [name, weight] of Object.entries(morphs)) {
-                const idx = this.runtimeMorph.nameIndex[name] ?? -1;
-                if (idx < 0 || idx >= this.runtimeMorph.weights.length)
-                    continue;
-                this.runtimeMorph.weights[idx] = Math.max(0, Math.min(1, weight));
-                state.morphActive[idx] = 0;
-                morphChanged = true;
-            }
-            if (morphChanged) {
-                this.applyMorphs();
-            }
-        }
-    }
     applyMorphs() {
         // Reset vertex data to base positions
         this.vertexData.set(this.baseVertexData);
@@ -564,15 +537,71 @@ export class Model {
             }
         }
     }
-    /**
-     * Load VMD animation file
-     */
     async loadVmd(vmdUrl) {
-        this.animationData = await VMDLoader.load(vmdUrl);
+        const vmdKeyFrames = await VMDLoader.load(vmdUrl);
         this.resetAllBones();
         this.resetAllMorphs();
-        this.processFrames();
-        // Apply initial pose at time 0
+        // Build bone tracks: Map<boneName, Array<{boneName, frame, rotation, translation, interpolation, time}>>
+        const boneTracksByBone = {};
+        for (const keyFrame of vmdKeyFrames) {
+            for (const bf of keyFrame.boneFrames) {
+                if (!boneTracksByBone[bf.boneName])
+                    boneTracksByBone[bf.boneName] = [];
+                boneTracksByBone[bf.boneName].push({
+                    frame: bf.frame,
+                    rotation: bf.rotation,
+                    translation: bf.translation,
+                    interpolation: rawInterpolationToBoneInterpolation(bf.interpolation),
+                });
+            }
+        }
+        this.boneTracks = new Map();
+        for (const name in boneTracksByBone) {
+            const keyframes = boneTracksByBone[name];
+            const sorted = [...keyframes].sort((a, b) => a.frame - b.frame);
+            this.boneTracks.set(name, sorted.map((kf) => ({
+                boneName: name,
+                frame: kf.frame,
+                rotation: kf.rotation,
+                translation: kf.translation,
+                interpolation: kf.interpolation,
+                time: kf.frame / VMD_FPS,
+            })));
+        }
+        // Build morph tracks: Map<morphName, Array<{morphName, frame, weight, time}>>
+        const morphTracksByMorph = {};
+        for (const keyFrame of vmdKeyFrames) {
+            for (const mf of keyFrame.morphFrames) {
+                if (!morphTracksByMorph[mf.morphName])
+                    morphTracksByMorph[mf.morphName] = [];
+                morphTracksByMorph[mf.morphName].push({ frame: mf.frame, weight: mf.weight });
+            }
+        }
+        this.morphTracks = new Map();
+        for (const name in morphTracksByMorph) {
+            const keyframes = morphTracksByMorph[name];
+            const sorted = [...keyframes].sort((a, b) => a.frame - b.frame);
+            this.morphTracks.set(name, sorted.map((kf) => ({
+                morphName: name,
+                frame: kf.frame,
+                weight: kf.weight,
+                time: kf.frame / VMD_FPS,
+            })));
+        }
+        this.boneTrackIndices.clear();
+        this.morphTrackIndices.clear();
+        // Calculate duration
+        let maxTime = 0;
+        for (const frames of this.boneTracks.values()) {
+            if (frames.length > 0)
+                maxTime = Math.max(maxTime, frames[frames.length - 1].time);
+        }
+        for (const frames of this.morphTracks.values()) {
+            if (frames.length > 0)
+                maxTime = Math.max(maxTime, frames[frames.length - 1].time);
+        }
+        this.animationDuration = maxTime;
+        this._hasAnimation = true;
         this.animationTime = 0;
         this.getPoseAtTime(0);
         if (this.physics) {
@@ -580,9 +609,6 @@ export class Model {
             this.physics.reset(this.runtimeSkeleton.worldMatrices, this.skeleton.inverseBindMatrices);
         }
     }
-    /**
-     * Reset all bones to their default pose
-     */
     resetAllBones() {
         for (let boneIdx = 0; boneIdx < this.skeleton.bones.length; boneIdx++) {
             const localRot = this.runtimeSkeleton.localRotations[boneIdx];
@@ -604,69 +630,14 @@ export class Model {
         this.morphsDirty = true;
         this.applyMorphs();
     }
-    /**
-     * Enable or disable IK solving
-     */
     setIKEnabled(enabled) {
         this.ikEnabled = enabled;
     }
-    /**
-     * Enable or disable physics simulation
-     */
     setPhysicsEnabled(enabled) {
         this.physicsEnabled = enabled;
     }
-    /**
-     * Process frames into tracks
-     */
-    processFrames() {
-        if (!this.animationData)
-            return;
-        // Helper to group frames by name and sort by time
-        const groupFrames = (items) => {
-            const tracks = new Map();
-            for (const { item, name, time } of items) {
-                if (!tracks.has(name))
-                    tracks.set(name, []);
-                tracks.get(name).push({ item, time });
-            }
-            for (const keyFrames of tracks.values()) {
-                keyFrames.sort((a, b) => a.time - b.time);
-            }
-            return tracks;
-        };
-        // Collect all bone and morph frames
-        const boneItems = [];
-        const morphItems = [];
-        for (const keyFrame of this.animationData) {
-            for (const boneFrame of keyFrame.boneFrames) {
-                boneItems.push({ item: boneFrame, name: boneFrame.boneName, time: keyFrame.time });
-            }
-            for (const morphFrame of keyFrame.morphFrames) {
-                morphItems.push({ item: morphFrame, name: morphFrame.morphName, time: keyFrame.time });
-            }
-        }
-        // Transform to expected format
-        this.boneTracks = new Map();
-        for (const [name, frames] of groupFrames(boneItems).entries()) {
-            this.boneTracks.set(name, frames.map((f) => ({ boneFrame: f.item, time: f.time })));
-        }
-        this.morphTracks = new Map();
-        for (const [name, frames] of groupFrames(morphItems).entries()) {
-            this.morphTracks.set(name, frames.map((f) => ({ morphFrame: f.item, time: f.time })));
-        }
-        // Reset cached indices when tracks change
-        this.boneTrackIndices.clear();
-        this.morphTrackIndices.clear();
-        // Calculate duration from all tracks
-        const allTracks = [...this.boneTracks.values(), ...this.morphTracks.values()];
-        this.animationDuration = allTracks.reduce((max, keyFrames) => {
-            const lastTime = keyFrames[keyFrames.length - 1]?.time ?? 0;
-            return Math.max(max, lastTime);
-        }, 0);
-    }
     playAnimation() {
-        if (!this.animationData)
+        if (!this._hasAnimation)
             return;
         this.isPaused = false;
         this.isPlaying = true;
@@ -686,14 +657,11 @@ export class Model {
         this.animationTime = 0;
     }
     seekAnimation(time) {
-        if (!this.animationData)
+        if (!this._hasAnimation)
             return;
         const clampedTime = Math.max(0, Math.min(time, this.animationDuration));
         this.animationTime = clampedTime;
     }
-    /**
-     * Get current animation progress
-     */
     getAnimationProgress() {
         const duration = this.animationDuration;
         const percentage = duration > 0 ? (this.animationTime / duration) * 100 : 0;
@@ -703,9 +671,6 @@ export class Model {
             percentage,
         };
     }
-    /**
-     * Binary search upper bound helper (static to avoid recreation)
-     */
     static upperBound(time, keyFrames, startIdx = 0) {
         let left = startIdx, right = keyFrames.length;
         while (left < right) {
@@ -717,10 +682,6 @@ export class Model {
         }
         return left;
     }
-    /**
-     * Find keyframe index with caching optimization
-     * Uses cached index as starting point for faster lookup when time is close
-     */
     findKeyframeIndex(time, keyFrames, cachedIdx) {
         if (keyFrames.length === 0)
             return -1;
@@ -737,14 +698,9 @@ export class Model {
         const idx = Model.upperBound(time, keyFrames, 0) - 1;
         return idx;
     }
-    /**
-     * Get pose at specific time (internal helper)
-     * Optimized for per-frame performance
-     */
     getPoseAtTime(time) {
-        if (!this.animationData)
+        if (!this._hasAnimation)
             return;
-        const INV_127 = 1 / 127; // Pre-compute division constant
         // Process bone tracks
         for (const [boneName, keyFrames] of this.boneTracks.entries()) {
             if (keyFrames.length === 0)
@@ -754,48 +710,31 @@ export class Model {
             const idx = this.findKeyframeIndex(clampedTime, keyFrames, cachedIdx);
             if (idx < 0)
                 continue;
-            // Update cache
             this.boneTrackIndices.set(boneName, idx);
-            const frameA = keyFrames[idx].boneFrame;
-            const frameB = keyFrames[idx + 1]?.boneFrame;
+            const frameA = keyFrames[idx];
+            const frameB = keyFrames[idx + 1];
             const boneIdx = this.runtimeSkeleton.nameIndex[boneName];
             if (boneIdx === undefined)
                 continue;
             const localRot = this.runtimeSkeleton.localRotations[boneIdx];
             const localTrans = this.runtimeSkeleton.localTranslations[boneIdx];
             if (!frameB) {
-                // No interpolation needed - direct assignment
-                // 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;
-                const timeB = keyFrames[idx + 1].time;
-                const timeDelta = timeB - timeA;
-                const gradient = (clampedTime - timeA) / timeDelta;
+                const timeDelta = frameB.time - frameA.time;
+                const gradient = (clampedTime - frameA.time) / timeDelta;
                 const interp = frameB.interpolation;
-                // Pre-normalize interpolation values (avoid division in bezierInterpolate)
-                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 rotT = interpolateControlPoints(interp.rotation, gradient);
                 const rotation = Quat.slerp(frameA.rotation, frameB.rotation, rotT);
-                // 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 txWeight = interpolateControlPoints(interp.translationX, gradient);
+                const tyWeight = interpolateControlPoints(interp.translationY, gradient);
+                const tzWeight = interpolateControlPoints(interp.translationZ, gradient);
                 const interpolatedVMDTranslation = new Vec3(frameA.translation.x + (frameB.translation.x - frameA.translation.x) * txWeight, frameA.translation.y + (frameB.translation.y - frameA.translation.y) * tyWeight, frameA.translation.z + (frameB.translation.z - frameA.translation.z) * tzWeight);
-                // 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.set(localTranslation);
             }
@@ -809,10 +748,9 @@ export class Model {
             const idx = this.findKeyframeIndex(clampedTime, keyFrames, cachedIdx);
             if (idx < 0)
                 continue;
-            // Update cache
             this.morphTrackIndices.set(morphName, idx);
-            const frameA = keyFrames[idx].morphFrame;
-            const frameB = keyFrames[idx + 1]?.morphFrame;
+            const frameA = keyFrames[idx];
+            const frameB = keyFrames[idx + 1];
             const morphIdx = this.runtimeMorph.nameIndex[morphName];
             if (morphIdx === undefined)
                 continue;
@@ -825,19 +763,14 @@ export class Model {
             this.morphsDirty = true; // Mark as dirty when animation sets morph weights
         }
     }
-    /**
-     * Updates the model pose by recomputing all matrices.
-     * If animation is playing, applies animation pose first.
-     * deltaTime: Time elapsed since last update in seconds
-     * Returns true if vertices were modified (morphs changed)
-     */
+    // Returns true when morphs changed (vertex buffer may need upload)
     update(deltaTime) {
         // Update tween time (in milliseconds)
         this.tweenTimeMs += deltaTime * 1000;
         // Update all active tweens (rotations, translations, morphs)
         const tweensChangedMorphs = this.updateTweens();
         // Apply animation if playing or paused (always apply pose if animation data exists and we have a time set)
-        if (this.animationData) {
+        if (this._hasAnimation) {
             if (this.isPlaying && !this.isPaused) {
                 this.animationTime += deltaTime;
                 if (this.animationTime >= this.animationDuration) {

package/dist/pmx-loader.js

@@ -218,7 +218,7 @@ export class PmxLoader {
                     this.getFloat32(),
                 ];
                 // edgeSize float
-                const edgeSize = this.getFloat32();
+                const edgeSize = this.getFloat32() * 2; // double the size for better visibility
                 const textureIndex = this.getNonVertexIndex(this.textureIndexSize);
                 const sphereTextureIndex = this.getNonVertexIndex(this.textureIndexSize);
                 const sphereTextureMode = this.getUint8();

package/package.json

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

package/src/animation.ts

@@ -0,0 +1,75 @@
+export interface ControlPoint {
+  x: number
+  y: number
+}
+
+export interface BoneInterpolation {
+  rotation: ControlPoint[]
+  translationX: ControlPoint[]
+  translationY: ControlPoint[]
+  translationZ: ControlPoint[]
+}
+
+// Cubic bezier in normalized 0–1 space (binary search on x)
+export function bezierInterpolate(x1: number, x2: number, y1: number, y2: number, t: number): number {
+  t = Math.max(0, Math.min(1, t))
+
+  let start = 0
+  let end = 1
+  let mid = 0.5
+
+  for (let i = 0; i < 15; i++) {
+    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
+  }
+
+  const y = 3 * (1 - mid) * (1 - mid) * mid * y1 + 3 * (1 - mid) * mid * mid * y2 + mid * mid * mid
+
+  return y
+}
+
+const INV_127 = 1 / 127
+
+// VMD 64-byte interpolation blob → BoneInterpolation
+export function rawInterpolationToBoneInterpolation(raw: Uint8Array): BoneInterpolation {
+  return {
+    rotation: [
+      { x: raw[0], y: raw[2] },
+      { x: raw[1], y: raw[3] },
+    ],
+    translationX: [
+      { x: raw[0], y: raw[4] },
+      { x: raw[8], y: raw[12] },
+    ],
+    translationY: [
+      { x: raw[16], y: raw[20] },
+      { x: raw[24], y: raw[28] },
+    ],
+    translationZ: [
+      { x: raw[32], y: raw[36] },
+      { x: raw[40], y: raw[44] },
+    ],
+  }
+}
+
+// Control points are 0–127 VMD bytes
+export function interpolateControlPoints(cp: ControlPoint[], t: number): number {
+  return bezierInterpolate(
+    cp[0].x * INV_127,
+    cp[1].x * INV_127,
+    cp[0].y * INV_127,
+    cp[1].y * INV_127,
+    t
+  )
+}

package/src/camera.ts

@@ -1,6 +1,6 @@
 import { Mat4, Vec3 } from "./math"
 
-const FAR = 1000
+const FAR = 2000
 
 export class Camera {
   alpha: number
@@ -29,7 +29,7 @@ export class Camera {
   panSensitivity: number = 0.0002 // Sensitivity for right-click panning
   wheelPrecision: number = 0.01
   pinchPrecision: number = 0.05
-  minZ: number = 0.1
+  minZ: number = 0.05
   maxZ: number = FAR
   lowerBetaLimit: number = 0.001
   upperBetaLimit: number = Math.PI - 0.001