reze-engine 0.3.3 → 0.3.5

package/dist/player.js

@@ -1,5 +1,4 @@
-import { bezierInterpolate } from "./bezier-interpolate";
-import { Quat, Vec3 } from "./math";
+import { Quat, Vec3, bezierInterpolate } from "./math";
 import { VMDLoader } from "./vmd-loader";
 export class Player {
     constructor() {
@@ -16,60 +15,14 @@ export class Player {
         this.startTime = 0; // Real-time when playback started
         this.pausedTime = 0; // Accumulated paused duration
         this.pauseStartTime = 0;
-        this.audioLoaded = false;
     }
     /**
-     * Load VMD animation file and optionally audio
+     * Load VMD animation file
      */
-    async loadVmd(vmdUrl, audioUrl) {
+    async loadVmd(vmdUrl) {
         // Load animation
         this.frames = await VMDLoader.load(vmdUrl);
         this.processFrames();
-        // Load audio if provided
-        if (audioUrl) {
-            await this.loadAudio(audioUrl);
-        }
-    }
-    /**
-     * Load audio file
-     */
-    async loadAudio(url) {
-        this.audioUrl = url;
-        this.audioLoaded = false;
-        return new Promise((resolve, reject) => {
-            const audio = new Audio(url);
-            audio.preload = "auto";
-            // iOS Safari requires playsinline attribute for inline playback
-            // This must be set before loading
-            audio.setAttribute("playsinline", "true");
-            audio.setAttribute("webkit-playsinline", "true");
-            // Set volume to ensure audio is ready
-            audio.volume = 1.0;
-            // iOS sometimes requires audio element to be in DOM
-            // Add it hidden to the document body
-            audio.style.display = "none";
-            audio.style.position = "absolute";
-            audio.style.visibility = "hidden";
-            audio.style.width = "0";
-            audio.style.height = "0";
-            document.body.appendChild(audio);
-            audio.addEventListener("loadeddata", () => {
-                this.audioElement = audio;
-                this.audioLoaded = true;
-                resolve();
-            });
-            audio.addEventListener("error", (e) => {
-                console.warn("Failed to load audio:", url, e);
-                this.audioLoaded = false;
-                // Remove from DOM on error
-                if (audio.parentNode) {
-                    audio.parentNode.removeChild(audio);
-                }
-                // Don't reject - animation should still work without audio
-                resolve();
-            });
-            audio.load();
-        });
     }
     /**
      * Process frames into tracks
@@ -140,6 +93,7 @@ export class Player {
     }
     /**
      * Start or resume playback
+     * Note: For iOS, this should be called synchronously from a user interaction event
      */
     play() {
         if (this.frames.length === 0)
@@ -156,22 +110,6 @@ export class Player {
             this.pausedTime = 0;
         }
         this.isPlaying = true;
-        // Play audio if available
-        if (this.audioElement && this.audioLoaded) {
-            // Ensure audio is ready for iOS
-            this.audioElement.currentTime = this.currentTime;
-            this.audioElement.muted = false;
-            this.audioElement.volume = 1.0;
-            // iOS requires play() to be called synchronously during user interaction
-            // This must happen directly from the user's click/touch event
-            const playPromise = this.audioElement.play();
-            if (playPromise !== undefined) {
-                playPromise.catch((error) => {
-                    // Log error but don't block animation playback
-                    console.warn("Audio play failed:", error, error.name);
-                });
-            }
-        }
     }
     /**
      * Pause playback
@@ -181,10 +119,6 @@ export class Player {
             return;
         this.isPaused = true;
         this.pauseStartTime = performance.now();
-        // Pause audio if available
-        if (this.audioElement) {
-            this.audioElement.pause();
-        }
     }
     /**
      * Stop playback and reset to beginning
@@ -195,11 +129,6 @@ export class Player {
         this.currentTime = 0;
         this.startTime = 0;
         this.pausedTime = 0;
-        // Stop audio if available
-        if (this.audioElement) {
-            this.audioElement.pause();
-            this.audioElement.currentTime = 0;
-        }
     }
     /**
      * Seek to specific time
@@ -212,10 +141,6 @@ export class Player {
             this.startTime = performance.now() - clampedTime * 1000;
             this.pausedTime = 0;
         }
-        // Seek audio if available
-        if (this.audioElement && this.audioLoaded) {
-            this.audioElement.currentTime = clampedTime;
-        }
     }
     /**
      * Update playback and return current pose
@@ -238,14 +163,6 @@ export class Player {
             this.pause(); // Auto-pause at end
             return this.getPoseAtTime(this.currentTime);
         }
-        // Sync audio if present (with tolerance)
-        if (this.audioElement && this.audioLoaded) {
-            const audioTime = this.audioElement.currentTime;
-            const syncTolerance = 0.1; // 100ms tolerance
-            if (Math.abs(audioTime - this.currentTime) > syncTolerance) {
-                this.audioElement.currentTime = this.currentTime;
-            }
-        }
         return this.getPoseAtTime(this.currentTime);
     }
     /**
@@ -403,34 +320,4 @@ export class Player {
     isPausedState() {
         return this.isPaused;
     }
-    /**
-     * Check if has audio
-     */
-    hasAudio() {
-        return this.audioElement !== undefined && this.audioLoaded;
-    }
-    /**
-     * Set audio volume (0.0 to 1.0)
-     */
-    setVolume(volume) {
-        if (this.audioElement) {
-            this.audioElement.volume = Math.max(0, Math.min(1, volume));
-        }
-    }
-    /**
-     * Mute audio
-     */
-    mute() {
-        if (this.audioElement) {
-            this.audioElement.muted = true;
-        }
-    }
-    /**
-     * Unmute audio
-     */
-    unmute() {
-        if (this.audioElement) {
-            this.audioElement.muted = false;
-        }
-    }
 }

package/package.json

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

package/src/ammo-loader.ts

@@ -29,7 +29,3 @@ export async function loadAmmo(): Promise<AmmoInstance> {
 
   return ammoPromise
 }
-
-export function getAmmoInstance(): AmmoInstance | null {
-  return ammoInstance
-}

package/src/engine.ts

@@ -1267,8 +1267,8 @@ export class Engine {
     this.lightData[3] = 0.0 // Padding for vec3f alignment
   }
 
-  public async loadAnimation(url: string, audioUrl?: string) {
-    await this.player.loadVmd(url, audioUrl)
+  public async loadAnimation(url: string) {
+    await this.player.loadVmd(url)
     this.hasAnimation = true
 
     // Show first frame (time 0) immediately

package/src/ik-solver.ts

@@ -5,7 +5,7 @@
  */
 
 import { Mat4, Quat, Vec3 } from "./math"
-import { Bone, IKLink, IKSolver, IKChainInfo, EulerRotationOrder, SolveAxis } from "./model"
+import { Bone, IKLink, IKSolver, IKChainInfo } from "./model"
 
 const enum InternalEulerRotationOrder {
   YXZ = 0,
@@ -89,13 +89,9 @@ export class IKSolverSystem {
     localRotations: Float32Array,
     localTranslations: Float32Array,
     worldMatrices: Float32Array,
-    ikChainInfo: IKChainInfo[],
-    usePhysics: boolean = false
+    ikChainInfo: IKChainInfo[]
   ): void {
     for (const solver of ikSolvers) {
-      if (usePhysics && solver.canSkipWhenPhysicsEnabled) {
-        continue
-      }
       this.solveIK(solver, bones, localRotations, localTranslations, worldMatrices, ikChainInfo)
     }
   }
@@ -135,9 +131,9 @@ export class IKSolverSystem {
 
     // Update chain bones and target bone world matrices (initial state, no IK yet)
     for (let i = chains.length - 1; i >= 0; i--) {
-      this.updateWorldMatrix(chains[i].boneIndex, bones, localRotations, localTranslations, worldMatrices)
+      this.updateWorldMatrix(chains[i].boneIndex, bones, localRotations, localTranslations, worldMatrices, undefined)
     }
-    this.updateWorldMatrix(targetBoneIndex, bones, localRotations, localTranslations, worldMatrices)
+    this.updateWorldMatrix(targetBoneIndex, bones, localRotations, localTranslations, worldMatrices, undefined)
 
     // Re-read positions after initial update
     const updatedIkPosition = this.getWorldTranslation(ikBoneIndex, worldMatrices)
@@ -355,9 +351,9 @@ export class IKSolverSystem {
     // Update world matrices for affected bones (using IK-modified rotations)
     for (let i = chainIndex; i >= 0; i--) {
       const link = solver.links[i]
-      this.updateWorldMatrixWithIK(link.boneIndex, bones, localRotations, localTranslations, worldMatrices, ikChainInfo)
+      this.updateWorldMatrix(link.boneIndex, bones, localRotations, localTranslations, worldMatrices, ikChainInfo)
     }
-    this.updateWorldMatrix(targetBoneIndex, bones, localRotations, localTranslations, worldMatrices)
+    this.updateWorldMatrix(targetBoneIndex, bones, localRotations, localTranslations, worldMatrices, undefined)
   }
 
   private static limitAngle(angle: number, min: number, max: number, useAxis: boolean): number {
@@ -401,29 +397,33 @@ export class IKSolverSystem {
     )
   }
 
-  private static updateWorldMatrixWithIK(
+  private static updateWorldMatrix(
     boneIndex: number,
     bones: Bone[],
     localRotations: Float32Array,
     localTranslations: Float32Array,
     worldMatrices: Float32Array,
-    ikChainInfo: IKChainInfo[]
+    ikChainInfo?: IKChainInfo[]
   ): void {
     const bone = bones[boneIndex]
     const qi = boneIndex * 4
     const ti = boneIndex * 3
 
-    // Use IK-modified rotation if available
+    // Get local rotation
     const localRot = new Quat(
       localRotations[qi],
       localRotations[qi + 1],
       localRotations[qi + 2],
       localRotations[qi + 3]
     )
-    const chainInfo = ikChainInfo[boneIndex]
+
+    // Apply IK rotation if available
     let finalRot = localRot
-    if (chainInfo && chainInfo.ikRotation) {
-      finalRot = chainInfo.ikRotation.multiply(localRot).normalize()
+    if (ikChainInfo) {
+      const chainInfo = ikChainInfo[boneIndex]
+      if (chainInfo && chainInfo.ikRotation) {
+        finalRot = chainInfo.ikRotation.multiply(localRot).normalize()
+      }
     }
     const rotateM = Mat4.fromQuat(finalRot.x, finalRot.y, finalRot.z, finalRot.w)
 
@@ -446,43 +446,4 @@ export class IKSolverSystem {
       worldMatrices.subarray(worldOffset, worldOffset + 16).set(localM.values)
     }
   }
-
-  private static updateWorldMatrix(
-    boneIndex: number,
-    bones: Bone[],
-    localRotations: Float32Array,
-    localTranslations: Float32Array,
-    worldMatrices: Float32Array
-  ): void {
-    const bone = bones[boneIndex]
-    const qi = boneIndex * 4
-    const ti = boneIndex * 3
-
-    const localRot = new Quat(
-      localRotations[qi],
-      localRotations[qi + 1],
-      localRotations[qi + 2],
-      localRotations[qi + 3]
-    )
-    const rotateM = Mat4.fromQuat(localRot.x, localRot.y, localRot.z, localRot.w)
-
-    const localTx = localTranslations[ti]
-    const localTy = localTranslations[ti + 1]
-    const localTz = localTranslations[ti + 2]
-
-    const localM = Mat4.identity()
-      .translateInPlace(bone.bindTranslation[0], bone.bindTranslation[1], bone.bindTranslation[2])
-      .multiply(rotateM)
-      .translateInPlace(localTx, localTy, localTz)
-
-    const worldOffset = boneIndex * 16
-    if (bone.parentIndex >= 0) {
-      const parentOffset = bone.parentIndex * 16
-      const parentMat = new Mat4(worldMatrices.subarray(parentOffset, parentOffset + 16))
-      const worldMat = parentMat.multiply(localM)
-      worldMatrices.subarray(worldOffset, worldOffset + 16).set(worldMat.values)
-    } else {
-      worldMatrices.subarray(worldOffset, worldOffset + 16).set(localM.values)
-    }
-  }
 }

package/src/math.ts

@@ -26,6 +26,10 @@ export class Vec3 {
     return Math.sqrt(this.x * this.x + this.y * this.y + this.z * this.z)
   }
 
+  lengthSquared(): number {
+    return this.x * this.x + this.y * this.y + this.z * this.z
+  }
+
   normalize(): Vec3 {
     const len = this.length()
     if (len === 0) return new Vec3(0, 0, 0)
@@ -123,14 +127,6 @@ export class Quat {
     )
   }
 
-  // Rotate a vector by this quaternion (Babylon.js style naming)
-  rotate(v: Vec3): Vec3 {
-    const qv = new Vec3(this.x, this.y, this.z)
-    const uv = qv.cross(v)
-    const uuv = qv.cross(uv)
-    return v.add(uv.scale(2 * this.w)).add(uuv.scale(2))
-  }
-
   // Static method: create quaternion that rotates from one direction to another
   static fromTo(from: Vec3, to: Vec3): Quat {
     const dot = from.dot(to)
@@ -553,3 +549,46 @@ export class Mat4 {
     return new Mat4(out)
   }
 }
+
+/**
+ * Bezier interpolation function
+ * @param x1 First control point X (0-127, normalized to 0-1)
+ * @param x2 Second control point X (0-127, normalized to 0-1)
+ * @param y1 First control point Y (0-127, normalized to 0-1)
+ * @param y2 Second control point Y (0-127, normalized to 0-1)
+ * @param t Interpolation parameter (0-1)
+ * @returns Interpolated value (0-1)
+ */
+export function bezierInterpolate(x1: number, x2: number, y1: number, y2: number, t: number): number {
+  // Clamp t to [0, 1]
+  t = Math.max(0, Math.min(1, t))
+
+  // Binary search for the t value that gives us the desired x
+  // We're solving for t in the Bezier curve: x(t) = 3*(1-t)^2*t*x1 + 3*(1-t)*t^2*x2 + t^3
+  let start = 0
+  let end = 1
+  let mid = 0.5
+
+  // Iterate until we find the t value that gives us the desired x
+  for (let i = 0; i < 15; i++) {
+    // Evaluate Bezier curve at mid point
+    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
+  }
+
+  // Now evaluate the y value at this t
+  const y = 3 * (1 - mid) * (1 - mid) * mid * y1 + 3 * (1 - mid) * mid * mid * y2 + mid * mid * mid
+
+  return y
+}

package/src/model.ts

@@ -50,24 +50,6 @@ export interface IKLink {
   hasLimit: boolean
   minAngle?: Vec3 // Minimum Euler angles (radians)
   maxAngle?: Vec3 // Maximum Euler angles (radians)
-  rotationOrder?: EulerRotationOrder // YXZ, ZYX, or XZY
-  solveAxis?: SolveAxis // None, Fixed, X, Y, or Z
-}
-
-// Euler rotation order for angle constraints
-export enum EulerRotationOrder {
-  YXZ = 0,
-  ZYX = 1,
-  XZY = 2,
-}
-
-// Solve axis optimization
-export enum SolveAxis {
-  None = 0,
-  Fixed = 1,
-  X = 2,
-  Y = 3,
-  Z = 4,
 }
 
 // IK solver definition
@@ -78,7 +60,6 @@ export interface IKSolver {
   iterationCount: number
   limitAngle: number // Max rotation per iteration (radians)
   links: IKLink[] // Chain bones from effector to root
-  canSkipWhenPhysicsEnabled: boolean
 }
 
 // IK chain info per bone (runtime state)
@@ -128,7 +109,6 @@ export interface SkeletonRuntime {
   localRotations: Float32Array // quat per bone (x,y,z,w) length = boneCount*4
   localTranslations: Float32Array // vec3 per bone length = boneCount*3
   worldMatrices: Float32Array // mat4 per bone length = boneCount*16
-  computedBones: boolean[] // length = boneCount
   ikChainInfo?: IKChainInfo[] // IK chain info per bone (only for IK chain bones)
   ikSolvers?: IKSolver[] // All IK solvers in the model
 }
@@ -245,7 +225,6 @@ export class Model {
         acc[bone.name] = index
         return acc
       }, {} as Record<string, number>),
-      computedBones: new Array(boneCount).fill(false),
     }
 
     const rotations = this.runtimeSkeleton.localRotations
@@ -283,18 +262,6 @@ export class Model {
     for (let i = 0; i < boneCount; i++) {
       const bone = bones[i]
       if (bone.ikTargetIndex !== undefined && bone.ikLinks && bone.ikLinks.length > 0) {
-        // Check if all links are affected by physics (for optimization)
-        let canSkipWhenPhysicsEnabled = true
-        for (const link of bone.ikLinks) {
-          // For now, assume no bones are physics-controlled (can be enhanced later)
-          // If a bone has a rigidbody attached, it's physics-controlled
-          const hasPhysics = this.rigidbodies.some((rb) => rb.boneIndex === link.boneIndex)
-          if (!hasPhysics) {
-            canSkipWhenPhysicsEnabled = false
-            break
-          }
-        }
-
         const solver: IKSolver = {
           index: solverIndex++,
           ikBoneIndex: i,
@@ -302,7 +269,6 @@ export class Model {
           iterationCount: bone.ikIteration ?? 1,
           limitAngle: bone.ikLimitAngle ?? Math.PI,
           links: bone.ikLinks,
-          canSkipWhenPhysicsEnabled,
         }
         ikSolvers.push(solver)
       }
@@ -550,14 +516,10 @@ export class Model {
           state.targetQuat[qi + 3]
         )
         const result = Quat.slerp(startQuat, targetQuat, e)
-        const cx = result.x
-        const cy = result.y
-        const cz = result.z
-        const cw = result.w
-        sx = cx
-        sy = cy
-        sz = cz
-        sw = cw
+        sx = result.x
+        sy = result.y
+        sz = result.z
+        sw = result.w
       }
 
       state.startQuat[qi] = sx
@@ -706,10 +668,9 @@ export class Model {
     // Animated change
     const state = this.morphTweenState
     const now = performance.now()
-    const currentWeight = this.runtimeMorph.weights[idx]
 
     // If already tweening, start from current interpolated value
-    let startWeight = currentWeight
+    let startWeight = this.runtimeMorph.weights[idx]
     if (state.active[idx] === 1) {
       const startMs = state.startTimeMs[idx]
       const prevDur = Math.max(1, state.durationMs[idx])
@@ -802,13 +763,13 @@ export class Model {
       this.applyMorphs()
     }
 
-    // Compute initial world matrices (needed for IK solving)
+    // Compute initial world matrices (needed for IK solving to read bone positions)
     this.computeWorldMatrices()
 
-    // Solve IK chains (modifies localRotations)
+    // Solve IK chains (modifies localRotations with final IK rotations)
     this.solveIKChains()
 
-    // Recompute world matrices with IK rotations applied
+    // Recompute world matrices with final IK rotations applied to localRotations
     this.computeWorldMatrices()
 
     return hasActiveMorphTweens
@@ -827,8 +788,7 @@ export class Model {
       this.runtimeSkeleton.localRotations,
       this.runtimeSkeleton.localTranslations,
       this.runtimeSkeleton.worldMatrices,
-      ikChainInfo,
-      false // usePhysics - can be enhanced later
+      ikChainInfo
     )
   }
 
@@ -837,11 +797,13 @@ export class Model {
     const localRot = this.runtimeSkeleton.localRotations
     const localTrans = this.runtimeSkeleton.localTranslations
     const worldBuf = this.runtimeSkeleton.worldMatrices
-    const computed = this.runtimeSkeleton.computedBones.fill(false)
     const boneCount = bones.length
 
     if (boneCount === 0) return
 
+    // Local computed array (avoids instance field overhead)
+    const computed = new Array<boolean>(boneCount).fill(false)
+
     const computeWorld = (i: number): void => {
       if (computed[i]) return
 
@@ -880,14 +842,9 @@ export class Model {
               ay = -ay
               az = -az
             }
-            const identityQuat = new Quat(0, 0, 0, 1)
             const appendQuat = new Quat(ax, ay, az, aw)
-            const result = Quat.slerp(identityQuat, appendQuat, absRatio)
-            const rx = result.x
-            const ry = result.y
-            const rz = result.z
-            const rw = result.w
-            rotateM = Mat4.fromQuat(rx, ry, rz, rw).multiply(rotateM)
+            const result = Quat.slerp(new Quat(0, 0, 0, 1), appendQuat, absRatio)
+            rotateM = Mat4.fromQuat(result.x, result.y, result.z, result.w).multiply(rotateM)
           }
 
           if (b.appendMove) {