reze-engine 0.6.6 → 0.7.0

package/src/model.ts

@@ -1,8 +1,10 @@
-import { Mat4, Quat, Vec3, bezierInterpolate } from "./math"
+import { Mat4, Quat, Vec3 } from "./math"
 import { Rigidbody, Joint, Physics } from "./physics"
 import { IKSolverSystem } from "./ik-solver"
-import { VMDKeyFrame, VMDLoader, BoneFrame, MorphFrame } from "./vmd-loader"
+import { VMDLoader } from "./vmd-loader"
+import { AnimationData, BoneKeyframe, MorphKeyframe, BoneInterpolation, interpolateControlPoints, rawInterpolationToBoneInterpolation } from "./animation"
 
+const VMD_FPS = 30
 const VERTEX_STRIDE = 8
 
 export interface Texture {
@@ -181,9 +183,10 @@ export class Model {
   private tweenTimeMs: number = 0 // Time tracking for tweens (milliseconds)
 
   // Animation runtime
-  private animationData: VMDKeyFrame[] | null = null
-  private boneTracks: Map<string, Array<{ boneFrame: BoneFrame; time: number }>> = new Map()
-  private morphTracks: Map<string, Array<{ morphFrame: MorphFrame; time: number }>> = new Map()
+  private _hasAnimation: boolean = false
+  private _animationData: AnimationData | null = null
+  private boneTracks: Map<string, Array<{ boneName: string; frame: number; rotation: Quat; translation: Vec3; interpolation: BoneInterpolation; time: number }>> = new Map()
+  private morphTracks: Map<string, Array<{ morphName: string; frame: number; weight: number; time: number }>> = new Map()
   private animationDuration: number = 0
   private isPlaying: boolean = false
   private isPaused: boolean = false
@@ -792,11 +795,89 @@ export class Model {
    * Load VMD animation file
    */
   async loadVmd(vmdUrl: string): Promise<void> {
-    this.animationData = await VMDLoader.load(vmdUrl)
+    const vmdKeyFrames = await VMDLoader.load(vmdUrl)
+
+    // Convert VMDKeyFrame[] to AnimationData
+    const boneTracks: Record<string, BoneKeyframe[]> = {}
+    const morphTracks: Record<string, MorphKeyframe[]> = {}
+
+    for (const keyFrame of vmdKeyFrames) {
+      for (const bf of keyFrame.boneFrames) {
+        if (!boneTracks[bf.boneName]) boneTracks[bf.boneName] = []
+        boneTracks[bf.boneName].push({
+          frame: bf.frame,
+          rotation: bf.rotation,
+          translation: bf.translation,
+          interpolation: rawInterpolationToBoneInterpolation(bf.interpolation),
+        })
+      }
+      for (const mf of keyFrame.morphFrames) {
+        if (!morphTracks[mf.morphName]) morphTracks[mf.morphName] = []
+        morphTracks[mf.morphName].push({
+          frame: mf.frame,
+          weight: mf.weight,
+        })
+      }
+    }
+
+    this.loadAnimationData({ boneTracks, morphTracks })
+  }
+
+  /**
+   * Load animation from structured keyframe data.
+   * This is the primary way to set animation data — loadVmd delegates to this.
+   */
+  loadAnimationData(data: AnimationData): void {
+    this._animationData = data
     this.resetAllBones()
     this.resetAllMorphs()
-    this.processFrames()
-    // Apply initial pose at time 0
+
+    this.boneTracks = new Map()
+    for (const name in data.boneTracks) {
+      const keyframes = data.boneTracks[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,
+        }))
+      )
+    }
+
+    this.morphTracks = new Map()
+    for (const name in data.morphTracks) {
+      const keyframes = data.morphTracks[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)
 
@@ -847,71 +928,8 @@ export class Model {
     this.physicsEnabled = enabled
   }
 
-  /**
-   * Process frames into tracks
-   */
-  private processFrames(): void {
-    if (!this.animationData) return
-
-    // Helper to group frames by name and sort by time
-    const groupFrames = <T>(
-      items: Array<{ item: T; name: string; time: number }>
-    ): Map<string, Array<{ item: T; time: number }>> => {
-      const tracks = new Map<string, Array<{ item: T; time: number }>>()
-      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: Array<{ item: BoneFrame; name: string; time: number }> = []
-    const morphItems: Array<{ item: MorphFrame; name: string; time: number }> = []
-
-    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(): void {
-    if (!this.animationData) return
+    if (!this._hasAnimation) return
 
     this.isPaused = false
     this.isPlaying = true
@@ -934,7 +952,7 @@ export class Model {
   }
 
   seekAnimation(time: number): void {
-    if (!this.animationData) return
+    if (!this._hasAnimation) return
     const clampedTime = Math.max(0, Math.min(time, this.animationDuration))
     this.animationTime = clampedTime
   }
@@ -942,6 +960,10 @@ export class Model {
   /**
    * Get current animation progress
    */
+  getAnimationData(): AnimationData | null {
+    return this._animationData
+  }
+
   getAnimationProgress(): { current: number; duration: number; percentage: number } {
     const duration = this.animationDuration
     const percentage = duration > 0 ? (this.animationTime / duration) * 100 : 0
@@ -994,9 +1016,7 @@ export class Model {
    * Optimized for per-frame performance
    */
   private getPoseAtTime(time: number): void {
-    if (!this.animationData) return
-
-    const INV_127 = 1 / 127 // Pre-compute division constant
+    if (!this._hasAnimation) return
 
     // Process bone tracks
     for (const [boneName, keyFrames] of this.boneTracks.entries()) {
@@ -1008,11 +1028,10 @@ export class Model {
 
       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
@@ -1021,61 +1040,30 @@ export class Model {
       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: number) =>
-          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)
       }
@@ -1091,19 +1079,18 @@ export class Model {
 
       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
 
       const weight = frameB
         ? frameA.weight +
-          (frameB.weight - frameA.weight) *
-            ((clampedTime - keyFrames[idx].time) / (keyFrames[idx + 1].time - keyFrames[idx].time))
+        (frameB.weight - frameA.weight) *
+        ((clampedTime - keyFrames[idx].time) / (keyFrames[idx + 1].time - keyFrames[idx].time))
         : frameA.weight
 
       this.runtimeMorph.weights[morphIdx] = weight
@@ -1125,7 +1112,7 @@ export class Model {
     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
 
@@ -1177,7 +1164,7 @@ export class Model {
       // Recompute ALL world matrices before each solver starts
       // This ensures each solver sees the effects of previous solvers on localRotations
       this.computeWorldMatrices()
-      
+
       // Clear computed set for this solver's pass
       this.ikComputedSet.clear()
 
@@ -1242,9 +1229,9 @@ export class Model {
 
     // Handle append transformations (same logic as computeWorldMatrices)
     const appendParentIdx = b.appendParentIndex
-    const hasAppend = b.appendRotate && 
-      appendParentIdx !== undefined && 
-      appendParentIdx >= 0 && 
+    const hasAppend = b.appendRotate &&
+      appendParentIdx !== undefined &&
+      appendParentIdx >= 0 &&
       appendParentIdx < bones.length
 
     if (hasAppend) {
@@ -1261,7 +1248,7 @@ export class Model {
             // Compute append parent's world matrix for dependency order, but use base rotation for append
             this.computeSingleBoneWorldMatrix(appendParentIdx, applyIK)
           }
-          
+
           // Use append parent's base local rotation only (IK rotations are applied after solving)
           let appendRot = localRot[appendParentIdx]
 
@@ -1269,7 +1256,7 @@ export class Model {
           const aw = appendRot.w
           const absRatio = ratio < 0 ? -ratio : ratio
           if (ratio < 0) { ax = -ax; ay = -ay; az = -az }
-          
+
           const appendQuat = new Quat(ax, ay, az, aw)
           const result = Quat.slerp(Quat.identity(), appendQuat, absRatio)
           rotateM = Mat4.fromQuat(result.x, result.y, result.z, result.w).multiply(rotateM)

package/dist/runtime-bone.d.ts

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

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

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

package/dist/runtime-bone.js

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