reze-engine 0.9.5 → 0.10.0

package/src/engine.ts

@@ -81,7 +81,7 @@ interface ModelInstance {
 export class Engine {
   private static instance: Engine | null = null
 
-  public static getInstance(): Engine {
+  static getInstance(): Engine {
     if (!Engine.instance) {
       throw new Error("Engine not ready: create Engine, await init(), then load models via engine.loadModel().")
     }
@@ -199,7 +199,7 @@ export class Engine {
   }
 
   // Step 1: Get WebGPU device and context
-  public async init() {
+  async init() {
     const adapter = await navigator.gpu?.requestAdapter()
     const device = await adapter?.requestDevice()
     if (!device) {
@@ -747,7 +747,7 @@ export class Engine {
           // Screen-stable edgeline: extrusion ∝ camera distance (same idea as MMD viewers / babylon-mmd-style scaling)
           let camDist = max(length(camera.viewPos - worldPos), 0.25);
           let refDist = 30.0;
-          let edgeScale = 0.032;
+          let edgeScale = 0.025;
           let expandedPos = worldPos + worldNormal * material.edgeSize * edgeScale * (camDist / refDist);
           output.position = camera.projection * camera.view * vec4f(expandedPos, 1.0);
           return output;
@@ -972,10 +972,10 @@ export class Engine {
   }
 
   /** Set static camera look-at / orbit center. Clears any model follow binding. */
-  public setCameraTarget(v: Vec3): void
+  setCameraTarget(v: Vec3): void
   /** Bind camera orbit center to a model's bone (Souls-style follow cam). Pass null to unbind. */
-  public setCameraTarget(model: Model | null, boneName: string, offset?: Vec3): void
-  public setCameraTarget(modelOrVec: Model | Vec3 | null, boneName?: string, offset?: Vec3): void {
+  setCameraTarget(model: Model | null, boneName: string, offset?: Vec3): void
+  setCameraTarget(modelOrVec: Model | Vec3 | null, boneName?: string, offset?: Vec3): void {
     if (modelOrVec === null) {
       this.cameraTargetModel = null
       return
@@ -995,7 +995,7 @@ export class Engine {
   }
 
   /** Souls-style follow cam: orbit center tracks a model bone each frame. Shorthand for setCameraTarget(model, boneName, offset). */
-  public setCameraFollow(model: Model | null, boneName?: string, offset?: Vec3): void {
+  setCameraFollow(model: Model | null, boneName?: string, offset?: Vec3): void {
     if (model === null) {
       this.cameraTargetModel = null
       return
@@ -1007,12 +1007,12 @@ export class Engine {
     this.cameraTargetOffset.z = offset?.z ?? 0
   }
 
-  public getCameraDistance(): number { return this.camera.radius }
-  public setCameraDistance(d: number): void { this.camera.radius = d }
-  public getCameraAlpha(): number { return this.camera.alpha }
-  public setCameraAlpha(a: number): void { this.camera.alpha = a }
-  public getCameraBeta(): number { return this.camera.beta }
-  public setCameraBeta(b: number): void { this.camera.beta = b }
+  getCameraDistance(): number { return this.camera.radius }
+  setCameraDistance(d: number): void { this.camera.radius = d }
+  getCameraAlpha(): number { return this.camera.alpha }
+  setCameraAlpha(a: number): void { this.camera.alpha = a }
+  getCameraBeta(): number { return this.camera.beta }
+  setCameraBeta(b: number): void { this.camera.beta = b }
 
   // Step 5: Create lighting buffers
   private setupLighting() {
@@ -1039,16 +1039,6 @@ export class Engine {
     this.updateLightBuffer()
   }
 
-  public clearLights() {
-    this.lightCount = 0
-    // Clear all light data by setting intensity to 0
-    for (let i = 0; i < 4; i++) {
-      const baseIndex = 4 + i * 8
-      this.lightData[baseIndex + 7] = 0 // color.w / intensity
-    }
-    this.updateLightBuffer()
-  }
-
   private addLight(direction: Vec3, color: Vec3, intensity: number = 1.0): boolean {
     if (this.lightCount >= 4) return false
 
@@ -1068,7 +1058,7 @@ export class Engine {
     return true
   }
 
-  public addGround(options?: {
+  addGround(options?: {
     width?: number
     height?: number
     diffuseColor?: Vec3
@@ -1113,11 +1103,11 @@ export class Engine {
     this.device.queue.writeBuffer(this.lightUniformBuffer, 0, this.lightData)
   }
 
-  public getStats(): EngineStats {
+  getStats(): EngineStats {
     return { ...this.stats }
   }
 
-  public runRenderLoop(callback?: () => void) {
+  runRenderLoop(callback?: () => void) {
     this.renderLoopCallback = callback || null
 
     const loop = () => {
@@ -1133,7 +1123,7 @@ export class Engine {
     this.animationFrameId = requestAnimationFrame(loop)
   }
 
-  public stopRenderLoop() {
+  stopRenderLoop() {
     if (this.animationFrameId !== null) {
       cancelAnimationFrame(this.animationFrameId)
       this.animationFrameId = null
@@ -1141,7 +1131,7 @@ export class Engine {
     this.renderLoopCallback = null
   }
 
-  public dispose() {
+  dispose() {
     this.stopRenderLoop()
     this.forEachInstance((inst) => inst.model.stopAnimation())
     if (Engine.instance === this) Engine.instance = null
@@ -1159,9 +1149,9 @@ export class Engine {
     }
   }
 
-  public async loadModel(path: string): Promise<Model>
-  public async loadModel(name: string, path: string): Promise<Model>
-  public async loadModel(nameOrPath: string, path?: string): Promise<Model> {
+  async loadModel(path: string): Promise<Model>
+  async loadModel(name: string, path: string): Promise<Model>
+  async loadModel(nameOrPath: string, path?: string): Promise<Model> {
     const pmxPath = path === undefined ? nameOrPath : path
     const name = path === undefined ? "model_" + (this._nextDefaultModelId++) : nameOrPath
     const model = await PmxLoader.load(pmxPath)
@@ -1170,7 +1160,7 @@ export class Engine {
     return model
   }
 
-  public async addModel(model: Model, pmxPath: string, name?: string): Promise<string> {
+  async addModel(model: Model, pmxPath: string, name?: string): Promise<string> {
     const requested = name ?? model.name
     let key = requested
     let n = 1
@@ -1184,19 +1174,19 @@ export class Engine {
     return key
   }
 
-  public removeModel(name: string): void {
+  removeModel(name: string): void {
     this.modelInstances.delete(name)
   }
 
-  public getModelNames(): string[] {
+  getModelNames(): string[] {
     return Array.from(this.modelInstances.keys())
   }
 
-  public getModel(name: string): Model | null {
+  getModel(name: string): Model | null {
     return this.modelInstances.get(name)?.model ?? null
   }
 
-  public markVertexBufferDirty(modelNameOrModel?: string | Model): void {
+  markVertexBufferDirty(modelNameOrModel?: string | Model): void {
     if (modelNameOrModel === undefined) return
     if (typeof modelNameOrModel === "string") {
       const inst = this.modelInstances.get(modelNameOrModel)
@@ -1211,38 +1201,38 @@ export class Engine {
     }
   }
 
-  public setMaterialVisible(modelName: string, materialName: string, visible: boolean): void {
+  setMaterialVisible(modelName: string, materialName: string, visible: boolean): void {
     const inst = this.modelInstances.get(modelName)
     if (!inst) return
     if (visible) inst.hiddenMaterials.delete(materialName)
     else inst.hiddenMaterials.add(materialName)
   }
 
-  public toggleMaterialVisible(modelName: string, materialName: string): void {
+  toggleMaterialVisible(modelName: string, materialName: string): void {
     const inst = this.modelInstances.get(modelName)
     if (!inst) return
     if (inst.hiddenMaterials.has(materialName)) inst.hiddenMaterials.delete(materialName)
     else inst.hiddenMaterials.add(materialName)
   }
 
-  public isMaterialVisible(modelName: string, materialName: string): boolean {
+  isMaterialVisible(modelName: string, materialName: string): boolean {
     const inst = this.modelInstances.get(modelName)
     return inst ? !inst.hiddenMaterials.has(materialName) : false
   }
 
-  public setIKEnabled(enabled: boolean): void {
+  setIKEnabled(enabled: boolean): void {
     this.ikEnabled = enabled
   }
 
-  public getIKEnabled(): boolean {
+  getIKEnabled(): boolean {
     return this.ikEnabled
   }
 
-  public setPhysicsEnabled(enabled: boolean): void {
+  setPhysicsEnabled(enabled: boolean): void {
     this.physicsEnabled = enabled
   }
 
-  public getPhysicsEnabled(): boolean {
+  getPhysicsEnabled(): boolean {
     return this.physicsEnabled
   }
 
@@ -1803,7 +1793,7 @@ export class Engine {
     this.onRaycast(hitModel, hitMaterial, screenX, screenY)
   }
 
-  public render() {
+  render() {
     if (!this.multisampleTexture || !this.camera || !this.device) return
 
     const currentTime = performance.now()

package/src/ik-solver.ts

@@ -21,13 +21,13 @@ const enum InternalSolveAxis {
 }
 
 class IKChain {
-  public readonly boneIndex: number
-  public readonly minimumAngle: Vec3 | null
-  public readonly maximumAngle: Vec3 | null
-  public readonly rotationOrder: InternalEulerRotationOrder
-  public readonly solveAxis: InternalSolveAxis
+  readonly boneIndex: number
+  readonly minimumAngle: Vec3 | null
+  readonly maximumAngle: Vec3 | null
+  readonly rotationOrder: InternalEulerRotationOrder
+  readonly solveAxis: InternalSolveAxis
 
-  public constructor(boneIndex: number, link: IKLink) {
+  constructor(boneIndex: number, link: IKLink) {
     this.boneIndex = boneIndex
 
     if (link.hasLimit && link.minAngle && link.maxAngle) {
@@ -76,7 +76,7 @@ export class IKSolverSystem {
   private static readonly EPSILON = 1.0e-8
   private static readonly THRESHOLD = (88 * Math.PI) / 180
 
-  public static solve(
+  static solve(
     ikSolvers: IKSolver[],
     bones: Bone[],
     localRotations: Quat[],

package/src/index.ts

@@ -1,10 +1,14 @@
 export { Engine, type EngineStats } from "./engine"
 export { Model } from "./model"
 export { Vec3, Quat, Mat4 } from "./math"
-export {
-  AnimationState,
-  type AnimationClip,
-  type BoneKeyframe,
-  type MorphKeyframe,
+export type {
+  AnimationClip,
+  AnimationPlayOptions,
+  AnimationProgress,
+  BoneKeyframe,
+  MorphKeyframe,
+  BoneInterpolation,
+  ControlPoint,
 } from "./animation"
+export { FPS } from "./animation"
 export { Physics, type PhysicsOptions } from "./physics"

package/src/model.ts

@@ -5,6 +5,8 @@ import { IKSolverSystem } from "./ik-solver"
 import { VMDLoader, type VMDKeyFrame } from "./vmd-loader"
 import {
   AnimationClip,
+  AnimationPlayOptions,
+  AnimationProgress,
   AnimationState,
   BoneInterpolation,
   BoneKeyframe,
@@ -13,7 +15,6 @@ import {
   rawInterpolationToBoneInterpolation,
 } from "./animation"
 
-const VMD_FPS = 30
 const VERTEX_STRIDE = 8
 
 export interface Texture {
@@ -480,7 +481,7 @@ export class Model {
     return this.runtimeMorph.weights
   }
 
-  // ------- Bone helpers (public API) -------
+  // ------- Bone helpers (API) -------
 
   rotateBones(boneRotations: Record<string, Quat>, durationMs?: number): void {
     const state = this.tweenState
@@ -822,7 +823,6 @@ export class Model {
           rotation: kf.rotation,
           translation: kf.translation,
           interpolation: kf.interpolation,
-          time: kf.frame / VMD_FPS,
         }))
       )
     }
@@ -843,27 +843,33 @@ export class Model {
           morphName: name,
           frame: kf.frame,
           weight: kf.weight,
-          time: kf.frame / VMD_FPS,
         }))
       )
     }
-    let maxTime = 0
+    let maxFrame = 0
     for (const frames of boneTracks.values()) {
-      if (frames.length > 0) maxTime = Math.max(maxTime, frames[frames.length - 1].time)
+      if (frames.length > 0) maxFrame = Math.max(maxFrame, frames[frames.length - 1].frame)
     }
     for (const frames of morphTracks.values()) {
-      if (frames.length > 0) maxTime = Math.max(maxTime, frames[frames.length - 1].time)
+      if (frames.length > 0) maxFrame = Math.max(maxFrame, frames[frames.length - 1].frame)
     }
-    return { boneTracks, morphTracks, duration: maxTime }
+    return { boneTracks, morphTracks, frameCount: maxFrame }
   }
 
-  async loadAnimation(animationName: string, vmdUrl: string): Promise<void> {
-    const vmdKeyFrames = await VMDLoader.load(vmdUrl)
-    const clip = this.buildClipFromVmdKeyFrames(vmdKeyFrames)
-    this.animationState.loadAnimation(animationName, clip)
+  loadAnimation(animationName: string, source: string): Promise<void>
+  loadAnimation(animationName: string, source: AnimationClip): void
+  loadAnimation(animationName: string, source: string | AnimationClip): Promise<void> | void {
+    if (typeof source !== "string") {
+      this.animationState.loadAnimation(animationName, source)
+      return
+    }
+    return VMDLoader.load(source).then((vmdKeyFrames) => {
+      const clip = this.buildClipFromVmdKeyFrames(vmdKeyFrames)
+      this.animationState.loadAnimation(animationName, clip)
+    })
   }
 
-  public resetAllBones(): void {
+  resetAllBones(): void {
     for (let boneIdx = 0; boneIdx < this.skeleton.bones.length; boneIdx++) {
       const localRot = this.runtimeSkeleton.localRotations[boneIdx]
       const localTrans = this.runtimeSkeleton.localTranslations[boneIdx]
@@ -874,7 +880,7 @@ export class Model {
     this.computeWorldMatrices()
   }
 
-  public resetAllMorphs(): void {
+  resetAllMorphs(): void {
     for (let morphIdx = 0; morphIdx < this.morphing.morphs.length; morphIdx++) {
       const morphName = this.morphing.morphs[morphIdx].name
       this.setMorphWeight(morphName, 0)
@@ -883,21 +889,26 @@ export class Model {
     this.applyMorphs()
   }
 
-  getAnimationState(): AnimationState {
-    return this.animationState
+  getAnimationClip(name: string): AnimationClip | null {
+    return this.animationState.getAnimationClip(name)
   }
 
   play(): void
   play(name: string): boolean
-  play(name?: string): void | boolean {
+  play(name: string, options?: AnimationPlayOptions): boolean
+  play(name?: string, options?: AnimationPlayOptions): void | boolean {
     if (name === undefined) {
       this.animationState.play()
       return
     }
-    return this.animationState.play(name)
+    this.resetAllBones()
+    this.resetAllMorphs()
+    return this.animationState.play(name, options)
   }
 
   show(name: string): void {
+    this.resetAllBones()
+    this.resetAllMorphs()
     this.animationState.show(name)
   }
 
@@ -924,46 +935,55 @@ export class Model {
     this.animationState.stop()
   }
 
-  seek(time: number): void {
-    this.animationState.seek(time)
+  // Seek by absolute timeline seconds, not frame index.
+  seek(seconds: number): void {
+    this.animationState.seek(seconds)
   }
 
   // @deprecated Use model.seek()
-  seekAnimation(time: number): void {
-    this.animationState.seek(time)
+  seekAnimation(seconds: number): void {
+    this.animationState.seek(seconds)
   }
 
-  getAnimationProgress(): { current: number; duration: number; percentage: number; animationName: string | null } {
+  getAnimationProgress(): AnimationProgress {
     const p = this.animationState.getProgress()
-    return { current: p.current, duration: p.duration, percentage: p.percentage, animationName: p.animationName }
+    return {
+      current: p.current,
+      duration: p.duration,
+      percentage: p.percentage,
+      animationName: p.animationName,
+      looping: p.looping,
+      playing: p.playing,
+      paused: p.paused,
+    }
   }
 
-  private static upperBound<T extends { time: number }>(time: number, keyFrames: T[], startIdx: number = 0): number {
+  private static upperBound<T extends { frame: number }>(frame: number, keyFrames: T[], startIdx: number = 0): number {
     let left = startIdx,
       right = keyFrames.length
     while (left < right) {
       const mid = Math.floor((left + right) / 2)
-      if (keyFrames[mid].time <= time) left = mid + 1
+      if (keyFrames[mid].frame <= frame) left = mid + 1
       else right = mid
     }
     return left
   }
 
-  private findKeyframeIndex<T extends { time: number }>(time: number, keyFrames: T[], cachedIdx: number): number {
+  private findKeyframeIndex<T extends { frame: number }>(frame: number, keyFrames: T[], cachedIdx: number): number {
     if (keyFrames.length === 0) return -1
 
     if (cachedIdx >= 0 && cachedIdx < keyFrames.length) {
-      const frameTime = keyFrames[cachedIdx].time
-      const nextFrameTime = cachedIdx + 1 < keyFrames.length ? keyFrames[cachedIdx + 1].time : Infinity
-      if (time >= frameTime && time < nextFrameTime) {
+      const currentFrame = keyFrames[cachedIdx].frame
+      const nextFrame = cachedIdx + 1 < keyFrames.length ? keyFrames[cachedIdx + 1].frame : Infinity
+      if (frame >= currentFrame && frame < nextFrame) {
         return cachedIdx
       }
     }
-    const idx = Model.upperBound(time, keyFrames, 0) - 1
+    const idx = Model.upperBound(frame, keyFrames, 0) - 1
     return idx
   }
 
-  private applyPoseFromClip(clip: AnimationClip | null, time: number): void {
+  private applyPoseFromClip(clip: AnimationClip | null, frame: number): void {
     if (!clip) return
     if (clip !== this.lastAppliedClip) {
       this.boneTrackIndices.clear()
@@ -975,8 +995,8 @@ export class Model {
       if (keyFrames.length === 0) continue
 
       const cachedIdx = this.boneTrackIndices.get(boneName) ?? -1
-      const clampedTime = Math.max(keyFrames[0].time, Math.min(keyFrames[keyFrames.length - 1].time, time))
-      const idx = this.findKeyframeIndex(clampedTime, keyFrames, cachedIdx)
+      const clampedFrame = Math.max(keyFrames[0].frame, Math.min(keyFrames[keyFrames.length - 1].frame, frame))
+      const idx = this.findKeyframeIndex(clampedFrame, keyFrames, cachedIdx)
 
       if (idx < 0) continue
 
@@ -997,8 +1017,8 @@ export class Model {
         const localTranslation = this.convertVMDTranslationToLocal(boneIdx, frameA.translation, frameRotation)
         localTrans.set(localTranslation)
       } else {
-        const timeDelta = frameB.time - frameA.time
-        const gradient = (clampedTime - frameA.time) / timeDelta
+        const frameDelta = frameB.frame - frameA.frame
+        const gradient = frameDelta > 0 ? (clampedFrame - frameA.frame) / frameDelta : 0
         const interp = frameB.interpolation
 
         const rotT = interpolateControlPoints(interp.rotation, gradient)
@@ -1025,8 +1045,8 @@ export class Model {
       if (keyFrames.length === 0) continue
 
       const cachedIdx = this.morphTrackIndices.get(morphName) ?? -1
-      const clampedTime = Math.max(keyFrames[0].time, Math.min(keyFrames[keyFrames.length - 1].time, time))
-      const idx = this.findKeyframeIndex(clampedTime, keyFrames, cachedIdx)
+      const clampedFrame = Math.max(keyFrames[0].frame, Math.min(keyFrames[keyFrames.length - 1].frame, frame))
+      const idx = this.findKeyframeIndex(clampedFrame, keyFrames, cachedIdx)
 
       if (idx < 0) continue
 
@@ -1041,7 +1061,9 @@ export class Model {
       const weight = frameB
         ? frameA.weight +
         (frameB.weight - frameA.weight) *
-        ((clampedTime - keyFrames[idx].time) / (keyFrames[idx + 1].time - keyFrames[idx].time))
+        (keyFrames[idx + 1].frame > keyFrames[idx].frame
+          ? (clampedFrame - keyFrames[idx].frame) / (keyFrames[idx + 1].frame - keyFrames[idx].frame)
+          : 0)
         : frameA.weight
 
       this.runtimeMorph.weights[morphIdx] = weight
@@ -1059,9 +1081,9 @@ export class Model {
 
     this.animationState.update(deltaTime)
     const clip = this.animationState.getCurrentClip()
-    const time = this.animationState.getCurrentTime()
+    const frame = this.animationState.getCurrentFrame()
     if (clip !== null) {
-      this.applyPoseFromClip(clip, time)
+      this.applyPoseFromClip(clip, frame)
     }
 
     // Apply morphs if tweens changed morphs or animation changed morphs
@@ -1223,7 +1245,7 @@ export class Model {
     }
   }
 
-  public computeWorldMatrices(): void {
+  computeWorldMatrices(): void {
     const bones = this.skeleton.bones
     const localRot = this.runtimeSkeleton.localRotations
     const localTrans = this.runtimeSkeleton.localTranslations