reze-engine 0.8.1 → 0.8.3

package/src/model.ts

@@ -3,8 +3,16 @@ import { Engine } from "./engine"
 import { PmxLoader } from "./pmx-loader"
 import { Rigidbody, Joint } from "./physics"
 import { IKSolverSystem } from "./ik-solver"
-import { VMDLoader } from "./vmd-loader"
-import { BoneInterpolation, interpolateControlPoints, rawInterpolationToBoneInterpolation } from "./animation"
+import { VMDLoader, type VMDKeyFrame } from "./vmd-loader"
+import {
+  AnimationClip,
+  AnimationState,
+  BoneInterpolation,
+  BoneKeyframe,
+  MorphKeyframe,
+  interpolateControlPoints,
+  rawInterpolationToBoneInterpolation,
+} from "./animation"
 
 const VMD_FPS = 30
 const VERTEX_STRIDE = 8
@@ -155,10 +163,14 @@ export class Model {
     return "model_" + Model._nextId++
   }
 
-  static async loadPmx(path: string, name?: string): Promise<Model> {
-    const model = await PmxLoader.load(path)
-    model.setName(name ?? Model.nextDefaultName())
-    await Engine.getInstance().registerModel(model, path)
+  static async loadFrom(path: string): Promise<Model>
+  static async loadFrom(name: string, path: string): Promise<Model>
+  static async loadFrom(nameOrPath: string, path?: string): Promise<Model> {
+    const name = path === undefined ? Model.nextDefaultName() : nameOrPath
+    const pmxPath = path === undefined ? nameOrPath : path
+    const model = await PmxLoader.load(pmxPath)
+    model.setName(name)
+    await Engine.getInstance().registerModel(model, pmxPath)
     return model
   }
 
@@ -206,18 +218,11 @@ export class Model {
   private tweenState!: TweenState
   private tweenTimeMs: number = 0 // Time tracking for tweens (milliseconds)
 
-  // Animation runtime
-  private _hasAnimation: boolean = false
-  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
-  private animationTime: number = 0 // Current time in animation (seconds)
-
-  // Cached keyframe indices for faster lookup (per track)
+  // Animation: state and multiple slots (idle, walk, attack, etc.); commit/rollback for action-game style
+  private readonly animationState = new AnimationState()
   private boneTrackIndices: Map<string, number> = new Map()
   private morphTrackIndices: Map<string, number> = new Map()
+  private lastAppliedClip: AnimationClip | null = null
 
   // IK and Physics enable flags
   private ikEnabled = true
@@ -720,7 +725,7 @@ export class Model {
       try {
         Engine.getInstance().markVertexBufferDirty(this)
       } catch {
-        /* not registered yet */
+        // not registered yet
       }
       return
     }
@@ -815,13 +820,7 @@ export class Model {
     }
   }
 
-  async loadVmd(vmdUrl: string): Promise<void> {
-    const vmdKeyFrames = await VMDLoader.load(vmdUrl)
-
-    this.resetAllBones()
-    this.resetAllMorphs()
-
-    // Build bone tracks: Map<boneName, Array<{boneName, frame, rotation, translation, interpolation, time}>>
+  private buildClipFromVmdKeyFrames(vmdKeyFrames: VMDKeyFrame[]): AnimationClip {
     const boneTracksByBone: Record<string, Array<{ frame: number; rotation: Quat; translation: Vec3; interpolation: BoneInterpolation }>> = {}
     for (const keyFrame of vmdKeyFrames) {
       for (const bf of keyFrame.boneFrames) {
@@ -834,12 +833,11 @@ export class Model {
         })
       }
     }
-
-    this.boneTracks = new Map()
+    const boneTracks = new Map<string, BoneKeyframe[]>()
     for (const name in boneTracksByBone) {
       const keyframes = boneTracksByBone[name]
       const sorted = [...keyframes].sort((a, b) => a.frame - b.frame)
-      this.boneTracks.set(
+      boneTracks.set(
         name,
         sorted.map((kf) => ({
           boneName: name,
@@ -851,8 +849,6 @@ export class Model {
         }))
       )
     }
-
-    // Build morph tracks: Map<morphName, Array<{morphName, frame, weight, time}>>
     const morphTracksByMorph: Record<string, Array<{ frame: number; weight: number }>> = {}
     for (const keyFrame of vmdKeyFrames) {
       for (const mf of keyFrame.morphFrames) {
@@ -860,12 +856,11 @@ export class Model {
         morphTracksByMorph[mf.morphName].push({ frame: mf.frame, weight: mf.weight })
       }
     }
-
-    this.morphTracks = new Map()
+    const morphTracks = new Map<string, MorphKeyframe[]>()
     for (const name in morphTracksByMorph) {
       const keyframes = morphTracksByMorph[name]
       const sorted = [...keyframes].sort((a, b) => a.frame - b.frame)
-      this.morphTracks.set(
+      morphTracks.set(
         name,
         sorted.map((kf) => ({
           morphName: name,
@@ -875,24 +870,20 @@ export class Model {
         }))
       )
     }
-
-    this.boneTrackIndices.clear()
-    this.morphTrackIndices.clear()
-
-    // Calculate duration
     let maxTime = 0
-    for (const frames of this.boneTracks.values()) {
+    for (const frames of boneTracks.values()) {
       if (frames.length > 0) maxTime = Math.max(maxTime, frames[frames.length - 1].time)
     }
-    for (const frames of this.morphTracks.values()) {
+    for (const frames of 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)
+    return { boneTracks, morphTracks, duration: maxTime }
+  }
 
+  async loadAnimation(animationName: string, vmdUrl: string): Promise<void> {
+    const vmdKeyFrames = await VMDLoader.load(vmdUrl)
+    const clip = this.buildClipFromVmdKeyFrames(vmdKeyFrames)
+    this.animationState.loadAnimation(animationName, clip)
   }
 
   public resetAllBones(): void {
@@ -900,7 +891,6 @@ export class Model {
       const localRot = this.runtimeSkeleton.localRotations[boneIdx]
       const localTrans = this.runtimeSkeleton.localTranslations[boneIdx]
 
-      // Reset to default pose: identity rotation and zero translation (like initial PMX state)
       localRot.set(Quat.identity())
       localTrans.set(Vec3.zeros())
     }
@@ -928,39 +918,59 @@ export class Model {
     return this.physicsEnabled
   }
 
-  playAnimation(): void {
-    if (!this._hasAnimation) return
+  getAnimationState(): AnimationState {
+    return this.animationState
+  }
+
+  play(): void
+  play(name: string): boolean
+  play(name?: string): void | boolean {
+    if (name === undefined) {
+      this.animationState.play()
+      return
+    }
+    return this.animationState.play(name)
+  }
+
+  show(name: string): void {
+    this.animationState.show(name)
+  }
 
-    this.isPaused = false
-    this.isPlaying = true
+  // @deprecated Use model.play()
+  playAnimation(): void {
+    this.animationState.play()
+  }
 
+  pause(): void {
+    this.animationState.pause()
   }
 
+  // @deprecated Use model.pause()
   pauseAnimation(): void {
-    if (!this.isPlaying || this.isPaused) return
-    this.isPaused = true
+    this.animationState.pause()
   }
 
+  stop(): void {
+    this.animationState.stop()
+  }
+
+  // @deprecated Use model.stop()
   stopAnimation(): void {
-    this.isPlaying = false
-    this.isPaused = false
-    this.animationTime = 0
+    this.animationState.stop()
+  }
+
+  seek(time: number): void {
+    this.animationState.seek(time)
   }
 
+  // @deprecated Use model.seek()
   seekAnimation(time: number): void {
-    if (!this._hasAnimation) return
-    const clampedTime = Math.max(0, Math.min(time, this.animationDuration))
-    this.animationTime = clampedTime
+    this.animationState.seek(time)
   }
 
-  getAnimationProgress(): { current: number; duration: number; percentage: number } {
-    const duration = this.animationDuration
-    const percentage = duration > 0 ? (this.animationTime / duration) * 100 : 0
-    return {
-      current: this.animationTime,
-      duration,
-      percentage,
-    }
+  getAnimationProgress(): { current: number; duration: number; percentage: number; animationName: string | null } {
+    const p = this.animationState.getProgress()
+    return { current: p.current, duration: p.duration, percentage: p.percentage, animationName: p.animationName }
   }
 
   private static upperBound<T extends { time: number }>(time: number, keyFrames: T[], startIdx: number = 0): number {
@@ -977,27 +987,26 @@ export class Model {
   private findKeyframeIndex<T extends { time: number }>(time: number, keyFrames: T[], cachedIdx: number): number {
     if (keyFrames.length === 0) return -1
 
-    // Check if cached index is still valid (time is within the cached frame range)
     if (cachedIdx >= 0 && cachedIdx < keyFrames.length) {
       const frameTime = keyFrames[cachedIdx].time
       const nextFrameTime = cachedIdx + 1 < keyFrames.length ? keyFrames[cachedIdx + 1].time : Infinity
-
-      // If time is within [frameTime, nextFrameTime), use cached index
       if (time >= frameTime && time < nextFrameTime) {
         return cachedIdx
       }
     }
-
-    // Fall back to binary search
     const idx = Model.upperBound(time, keyFrames, 0) - 1
     return idx
   }
 
-  private getPoseAtTime(time: number): void {
-    if (!this._hasAnimation) return
+  private applyPoseFromClip(clip: AnimationClip | null, time: number): void {
+    if (!clip) return
+    if (clip !== this.lastAppliedClip) {
+      this.boneTrackIndices.clear()
+      this.morphTrackIndices.clear()
+      this.lastAppliedClip = clip
+    }
 
-    // Process bone tracks
-    for (const [boneName, keyFrames] of this.boneTracks.entries()) {
+    for (const [boneName, keyFrames] of clip.boneTracks.entries()) {
       if (keyFrames.length === 0) continue
 
       const cachedIdx = this.boneTrackIndices.get(boneName) ?? -1
@@ -1047,8 +1056,7 @@ export class Model {
       }
     }
 
-    // Process morph tracks
-    for (const [morphName, keyFrames] of this.morphTracks.entries()) {
+    for (const [morphName, keyFrames] of clip.morphTracks.entries()) {
       if (keyFrames.length === 0) continue
 
       const cachedIdx = this.morphTrackIndices.get(morphName) ?? -1
@@ -1084,21 +1092,11 @@ export class Model {
     // 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._hasAnimation) {
-      if (this.isPlaying && !this.isPaused) {
-        this.animationTime += deltaTime
-
-        if (this.animationTime >= this.animationDuration) {
-          this.animationTime = this.animationDuration
-          this.pauseAnimation() // Auto-pause at end
-        }
-
-        this.getPoseAtTime(this.animationTime)
-      } else if (this.isPaused || (!this.isPlaying && this.animationTime >= 0)) {
-        // Apply pose at paused time or if we have a seeked time but not playing
-        this.getPoseAtTime(this.animationTime)
-      }
+    this.animationState.update(deltaTime)
+    const clip = this.animationState.getCurrentClip()
+    const time = this.animationState.getCurrentTime()
+    if (clip !== null) {
+      this.applyPoseFromClip(clip, time)
     }
 
     // Apply morphs if tweens changed morphs or animation changed morphs