reze-engine 0.7.0 → 0.8.1

package/src/ik-solver.ts

@@ -1,8 +1,4 @@
-/**
- * IK Solver implementation
- * Based on reference from babylon-mmd and Saba MMD library
- * https://github.com/benikabocha/saba/blob/master/src/Saba/Model/MMD/MMDIkSolver.cpp
- */
+// IK solver (MMD-style; see Saba MMDIkSolver.cpp)
 
 import { Mat4, Quat, Vec3 } from "./math"
 import { Bone, IKLink, IKSolver, IKChainInfo } from "./model"
@@ -76,16 +72,10 @@ class IKChain {
   }
 }
 
-/**
- * Solve IK chains for a model
- */
 export class IKSolverSystem {
   private static readonly EPSILON = 1.0e-8
   private static readonly THRESHOLD = (88 * Math.PI) / 180
 
-  /**
-   * Solve all IK chains
-   */
   public static solve(
     ikSolvers: IKSolver[],
     bones: Bone[],

package/src/index.ts

@@ -1,4 +1,3 @@
-export { Engine, type EngineStats } from "./engine"
-export { Vec3, Quat, Mat4 } from "./math"
-export type { AnimationData, BoneKeyframe, MorphKeyframe, BoneInterpolation, ControlPoint } from "./animation"
-export { bezierInterpolate, interpolateControlPoints, rawInterpolationToBoneInterpolation, LINEAR_INTERPOLATION } from "./animation"
+export { Engine, type EngineStats } from "./engine"
+export { Model } from "./model"
+export { Vec3, Quat, Mat4 } from "./math"

package/src/math.ts

@@ -295,6 +295,33 @@ export class Mat4 {
     )
   }
 
+  // LH ortho, NDC depth 0=near 1=far
+  static orthographicLh(left: number, right: number, bottom: number, top: number, near: number, far: number): Mat4 {
+    const rl = 1 / (right - left)
+    const tb = 1 / (top - bottom)
+    const fn = 1 / (far - near)
+    return new Mat4(
+      new Float32Array([
+        2 * rl,
+        0,
+        0,
+        0,
+        0,
+        2 * tb,
+        0,
+        0,
+        0,
+        0,
+        fn,
+        0,
+        -(right + left) * rl,
+        -(top + bottom) * tb,
+        -near * fn,
+        1,
+      ])
+    )
+  }
+
   multiply(other: Mat4): Mat4 {
     // Column-major multiplication (matches WGSL/GLSL convention):
     // result = a * b

package/src/model.ts

@@ -1,8 +1,10 @@
 import { Mat4, Quat, Vec3 } from "./math"
-import { Rigidbody, Joint, Physics } from "./physics"
+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 { AnimationData, BoneKeyframe, MorphKeyframe, BoneInterpolation, interpolateControlPoints, rawInterpolationToBoneInterpolation } from "./animation"
+import { BoneInterpolation, interpolateControlPoints, rawInterpolationToBoneInterpolation } from "./animation"
 
 const VMD_FPS = 30
 const VERTEX_STRIDE = 8
@@ -148,6 +150,28 @@ interface TweenState {
 }
 
 export class Model {
+  private static _nextId = 0
+  private static nextDefaultName(): string {
+    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)
+    return model
+  }
+
+  private _name: string = ""
+
+  get name(): string {
+    return this._name
+  }
+
+  setName(value: string): void {
+    this._name = value
+  }
+
   private vertexData: Float32Array<ArrayBuffer>
   private baseVertexData: Float32Array<ArrayBuffer> // Original vertex data before morphing
   private vertexCount: number
@@ -184,7 +208,6 @@ export class Model {
 
   // Animation runtime
   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
@@ -196,9 +219,6 @@ export class Model {
   private boneTrackIndices: Map<string, number> = new Map()
   private morphTrackIndices: Map<string, number> = new Map()
 
-  // Physics runtime
-  private physics: Physics | null = null
-
   // IK and Physics enable flags
   private ikEnabled = true
   private physicsEnabled = true
@@ -235,11 +255,6 @@ export class Model {
     this.initializeRuntimeMorph()
     this.initializeTweenBuffers()
     this.applyMorphs()
-
-    // Initialize physics if rigidbodies exist
-    if (rigidbodies.length > 0) {
-      this.physics = new Physics(rigidbodies, joints)
-    }
   }
 
   private initializeRuntimeSkeleton(): void {
@@ -456,6 +471,13 @@ export class Model {
     return this.skeleton
   }
 
+  // World bone origin (world matrix col3); unknown name → null
+  getBoneWorldPosition(boneName: string): Vec3 | null {
+    const idx = this.runtimeSkeleton.nameIndex[boneName]
+    if (idx === undefined || idx < 0) return null
+    return this.runtimeSkeleton.worldMatrices[idx].getPosition()
+  }
+
   getSkinning(): Skinning {
     return this.skinning
   }
@@ -581,14 +603,7 @@ export class Model {
     }
   }
 
-  /**
-   * 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
   private convertVMDTranslationToLocal(boneIdx: number, vmdRelativeTranslation: Vec3, rotation?: Quat): Vec3 {
     const skeleton = this.skeleton
     const bones = skeleton.bones
@@ -648,6 +663,10 @@ export class Model {
     return localTranslation
   }
 
+  getWorldMatrices(): Mat4[] {
+    return this.runtimeSkeleton.worldMatrices
+  }
+
   getBoneWorldMatrices(): Float32Array {
     // Convert Mat4[] to Float32Array for WebGPU compatibility
     const boneCount = this.skeleton.bones.length
@@ -698,6 +717,11 @@ export class Model {
       this.runtimeMorph.weights[idx] = clampedWeight
       this.tweenState.morphActive[idx] = 0
       this.applyMorphs()
+      try {
+        Engine.getInstance().markVertexBufferDirty(this)
+      } catch {
+        /* not registered yet */
+      }
       return
     }
 
@@ -791,50 +815,29 @@ export class Model {
     }
   }
 
-  /**
-   * Load VMD animation file
-   */
   async loadVmd(vmdUrl: string): Promise<void> {
     const vmdKeyFrames = await VMDLoader.load(vmdUrl)
 
-    // Convert VMDKeyFrame[] to AnimationData
-    const boneTracks: Record<string, BoneKeyframe[]> = {}
-    const morphTracks: Record<string, MorphKeyframe[]> = {}
+    this.resetAllBones()
+    this.resetAllMorphs()
 
+    // Build bone tracks: Map<boneName, Array<{boneName, frame, rotation, translation, interpolation, time}>>
+    const boneTracksByBone: Record<string, Array<{ frame: number; rotation: Quat; translation: Vec3; interpolation: BoneInterpolation }>> = {}
     for (const keyFrame of vmdKeyFrames) {
       for (const bf of keyFrame.boneFrames) {
-        if (!boneTracks[bf.boneName]) boneTracks[bf.boneName] = []
-        boneTracks[bf.boneName].push({
+        if (!boneTracksByBone[bf.boneName]) boneTracksByBone[bf.boneName] = []
+        boneTracksByBone[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.boneTracks = new Map()
-    for (const name in data.boneTracks) {
-      const keyframes = data.boneTracks[name]
+    for (const name in boneTracksByBone) {
+      const keyframes = boneTracksByBone[name]
       const sorted = [...keyframes].sort((a, b) => a.frame - b.frame)
       this.boneTracks.set(
         name,
@@ -849,9 +852,18 @@ 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) {
+        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 data.morphTracks) {
-      const keyframes = data.morphTracks[name]
+    for (const name in morphTracksByMorph) {
+      const keyframes = morphTracksByMorph[name]
       const sorted = [...keyframes].sort((a, b) => a.frame - b.frame)
       this.morphTracks.set(
         name,
@@ -881,15 +893,8 @@ export class Model {
     this.animationTime = 0
     this.getPoseAtTime(0)
 
-    if (this.physics) {
-      this.computeWorldMatrices()
-      this.physics.reset(this.runtimeSkeleton.worldMatrices, this.skeleton.inverseBindMatrices)
-    }
   }
 
-  /**
-   * Reset all bones to their default pose
-   */
   public resetAllBones(): void {
     for (let boneIdx = 0; boneIdx < this.skeleton.bones.length; boneIdx++) {
       const localRot = this.runtimeSkeleton.localRotations[boneIdx]
@@ -900,9 +905,6 @@ export class Model {
       localTrans.set(Vec3.zeros())
     }
     this.computeWorldMatrices()
-    if (this.physics) {
-      this.physics.reset(this.runtimeSkeleton.worldMatrices, this.skeleton.inverseBindMatrices)
-    }
   }
 
   public resetAllMorphs(): void {
@@ -914,30 +916,24 @@ export class Model {
     this.applyMorphs()
   }
 
-  /**
-   * Enable or disable IK solving
-   */
   public setIKEnabled(enabled: boolean): void {
     this.ikEnabled = enabled
   }
 
-  /**
-   * Enable or disable physics simulation
-   */
   public setPhysicsEnabled(enabled: boolean): void {
     this.physicsEnabled = enabled
   }
 
+  public getPhysicsEnabled(): boolean {
+    return this.physicsEnabled
+  }
+
   playAnimation(): void {
     if (!this._hasAnimation) return
 
     this.isPaused = false
     this.isPlaying = true
 
-    if (this.physics && this.animationTime === 0) {
-      this.computeWorldMatrices()
-      this.physics.reset(this.runtimeSkeleton.worldMatrices, this.skeleton.inverseBindMatrices)
-    }
   }
 
   pauseAnimation(): void {
@@ -957,13 +953,6 @@ export class Model {
     this.animationTime = clampedTime
   }
 
-  /**
-   * 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
@@ -974,9 +963,6 @@ export class Model {
     }
   }
 
-  /**
-   * Binary search upper bound helper (static to avoid recreation)
-   */
   private static upperBound<T extends { time: number }>(time: number, keyFrames: T[], startIdx: number = 0): number {
     let left = startIdx,
       right = keyFrames.length
@@ -988,10 +974,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
-   */
   private findKeyframeIndex<T extends { time: number }>(time: number, keyFrames: T[], cachedIdx: number): number {
     if (keyFrames.length === 0) return -1
 
@@ -1011,10 +993,6 @@ export class Model {
     return idx
   }
 
-  /**
-   * Get pose at specific time (internal helper)
-   * Optimized for per-frame performance
-   */
   private getPoseAtTime(time: number): void {
     if (!this._hasAnimation) return
 
@@ -1098,12 +1076,7 @@ export class Model {
     }
   }
 
-  /**
-   * 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: number): boolean {
     // Update tween time (in milliseconds)
     this.tweenTimeMs += deltaTime * 1000
@@ -1145,10 +1118,6 @@ export class Model {
       this.computeWorldMatrices()
     }
 
-    if (this.physicsEnabled && this.physics) {
-      this.physics.step(deltaTime, this.runtimeSkeleton.worldMatrices, this.skeleton.inverseBindMatrices)
-    }
-
     return verticesChanged
   }
 
@@ -1291,7 +1260,7 @@ export class Model {
     }
   }
 
-  private computeWorldMatrices(): void {
+  public computeWorldMatrices(): void {
     const bones = this.skeleton.bones
     const localRot = this.runtimeSkeleton.localRotations
     const localTrans = this.runtimeSkeleton.localTranslations

package/src/pmx-loader.ts

@@ -262,7 +262,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)