reze-engine 0.3.10 → 0.3.12

package/README.md

@@ -1,66 +1,66 @@
-# Reze Engine
-
-A lightweight engine built with WebGPU and TypeScript for real-time 3D anime character MMD model rendering.
-
-## Features
-
-- Physics
-- Alpha blending
-- Post alpha eye rendering
-- Rim lighting
-- Bloom
-- Outlines
-- MSAA 4x anti-aliasing
-- Bone and morph api
-- VMD animation
-- Ik solver
-
-## Usage
-
-```javascript
-export default function Scene() {
-  const canvasRef = useRef < HTMLCanvasElement > null
-  const engineRef = useRef < Engine > null
-
-  const initEngine = useCallback(async () => {
-    if (canvasRef.current) {
-      try {
-        const engine = new Engine(canvasRef.current)
-        engineRef.current = engine
-        await engine.init()
-        await engine.loadModel("/models/塞尔凯特/塞尔凯特.pmx")
-
-        engine.runRenderLoop(() => {})
-      } catch (error) {
-        console.error(error)
-      }
-    }
-  }, [])
-
-  useEffect(() => {
-    void (async () => {
-      initEngine()
-    })()
-
-    return () => {
-      if (engineRef.current) {
-        engineRef.current.dispose()
-      }
-    }
-  }, [initEngine])
-
-  return <canvas ref={canvasRef} className="w-full h-full" />
-}
-```
-
-## Projects Using This Engine
-
-- **[MiKaPo](https://mikapo.vercel.app)** - Online real-time motion capture for MMD using webcam and MediaPipe
-- **[Popo](https://popo.love)** - Fine-tuned LLM that generates MMD poses from natural language descriptions
-- **[MPL](https://mmd-mpl.vercel.app)** - Semantic motion programming language for scripting MMD animations with intuitive syntax
-
-## Tutorial
-
-Learn WebGPU from scratch by building an anime character renderer in incremental steps. The tutorial covers the complete rendering pipeline from a simple triangle to fully textured, skeletal-animated characters.
-
-[How to Render an Anime Character with WebGPU](https://reze.one/tutorial)
+# Reze Engine
+
+A lightweight engine built with WebGPU and TypeScript for real-time 3D anime character MMD model rendering.
+
+## Features
+
+- Physics
+- Alpha blending
+- Post alpha eye rendering
+- Rim lighting
+- Bloom
+- Outlines
+- MSAA 4x anti-aliasing
+- Bone and morph api
+- VMD animation
+- Ik solver
+
+## Usage
+
+```javascript
+export default function Scene() {
+  const canvasRef = useRef < HTMLCanvasElement > null
+  const engineRef = useRef < Engine > null
+
+  const initEngine = useCallback(async () => {
+    if (canvasRef.current) {
+      try {
+        const engine = new Engine(canvasRef.current)
+        engineRef.current = engine
+        await engine.init()
+        await engine.loadModel("/models/塞尔凯特/塞尔凯特.pmx")
+
+        engine.runRenderLoop(() => {})
+      } catch (error) {
+        console.error(error)
+      }
+    }
+  }, [])
+
+  useEffect(() => {
+    void (async () => {
+      initEngine()
+    })()
+
+    return () => {
+      if (engineRef.current) {
+        engineRef.current.dispose()
+      }
+    }
+  }, [initEngine])
+
+  return <canvas ref={canvasRef} className="w-full h-full" />
+}
+```
+
+## Projects Using This Engine
+
+- **[MiKaPo](https://mikapo.vercel.app)** - Online real-time motion capture for MMD using webcam and MediaPipe
+- **[Popo](https://popo.love)** - Fine-tuned LLM that generates MMD poses from natural language descriptions
+- **[MPL](https://mmd-mpl.vercel.app)** - Semantic motion programming language for scripting MMD animations with intuitive syntax
+
+## Tutorial
+
+Learn WebGPU from scratch by building an anime character renderer in incremental steps. The tutorial covers the complete rendering pipeline from a simple triangle to fully textured, skeletal-animated characters.
+
+[How to Render an Anime Character with WebGPU](https://reze.one/tutorial)

package/dist/audio.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Audio system for generating procedural explosion sounds
+ * Based on Web Audio API synthesis
+ */
+export declare class AudioSystem {
+    private ctx;
+    private enabled;
+    private volume;
+    private limiter;
+    /**
+     * Initialize audio context and compressor
+     * Must be called after user interaction (browser requirement)
+     */
+    init(): void;
+    /**
+     * Play deep bass explosion sound (firework burst)
+     * Combines sub-bass, noise, and crack sounds for realistic explosion
+     */
+    playExplosion(): void;
+    /**
+     * Play lighter "whoosh" sound for rocket launch
+     */
+    playRocketLaunch(): void;
+    setVolume(volume: number): void;
+    getVolume(): number;
+    isEnabled(): boolean;
+    setEnabled(enabled: boolean): void;
+}
+//# sourceMappingURL=audio.d.ts.map

package/dist/audio.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"audio.d.ts","sourceRoot":"","sources":["../src/audio.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,qBAAa,WAAW;IACtB,OAAO,CAAC,GAAG,CAA4B;IACvC,OAAO,CAAC,OAAO,CAAiB;IAChC,OAAO,CAAC,MAAM,CAAY;IAC1B,OAAO,CAAC,OAAO,CAAsC;IAErD;;;OAGG;IACH,IAAI,IAAI,IAAI;IAiBZ;;;OAGG;IACH,aAAa,IAAI,IAAI;IA8DrB;;OAEG;IACH,gBAAgB,IAAI,IAAI;IAsBxB,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAI/B,SAAS,IAAI,MAAM;IAInB,SAAS,IAAI,OAAO;IAIpB,UAAU,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI;CAGnC"}

package/dist/audio.js

@@ -0,0 +1,116 @@
+/**
+ * Audio system for generating procedural explosion sounds
+ * Based on Web Audio API synthesis
+ */
+export class AudioSystem {
+    constructor() {
+        this.ctx = null;
+        this.enabled = false;
+        this.volume = 1;
+        this.limiter = null;
+    }
+    /**
+     * Initialize audio context and compressor
+     * Must be called after user interaction (browser requirement)
+     */
+    init() {
+        if (!this.ctx) {
+            this.ctx = new (window.AudioContext || window.webkitAudioContext)();
+            this.limiter = this.ctx.createDynamicsCompressor();
+            this.limiter.threshold.value = -10;
+            this.limiter.knee.value = 40;
+            this.limiter.ratio.value = 12;
+            this.limiter.connect(this.ctx.destination);
+            this.enabled = true;
+        }
+        // Resume if suspended (iOS/Safari requirement)
+        if (this.ctx.state === "suspended") {
+            this.ctx.resume();
+        }
+    }
+    /**
+     * Play deep bass explosion sound (firework burst)
+     * Combines sub-bass, noise, and crack sounds for realistic explosion
+     */
+    playExplosion() {
+        if (!this.enabled || !this.ctx || !this.limiter)
+            return;
+        const t = this.ctx.currentTime;
+        // --- 1. SUB-BASS KICK (deep rumble) ---
+        const osc = this.ctx.createOscillator();
+        const oscGain = this.ctx.createGain();
+        osc.type = "sine";
+        osc.frequency.setValueAtTime(50, t); // Start at 50Hz
+        osc.frequency.exponentialRampToValueAtTime(20, t + 2.5); // Drop to 20Hz
+        oscGain.gain.setValueAtTime(this.volume * 1.5, t);
+        oscGain.gain.exponentialRampToValueAtTime(0.01, t + 5.0); // Long decay
+        osc.connect(oscGain);
+        oscGain.connect(this.limiter);
+        osc.start(t);
+        osc.stop(t + 5.0);
+        // --- 2. NOISE (crackling/rumble texture) ---
+        const bufferSize = this.ctx.sampleRate * 5.0;
+        const buffer = this.ctx.createBuffer(1, bufferSize, this.ctx.sampleRate);
+        const data = buffer.getChannelData(0);
+        for (let i = 0; i < bufferSize; i++) {
+            data[i] = Math.random() * 2 - 1;
+        }
+        const noise = this.ctx.createBufferSource();
+        noise.buffer = buffer;
+        const noiseFilter = this.ctx.createBiquadFilter();
+        noiseFilter.type = "lowpass";
+        noiseFilter.frequency.setValueAtTime(150, t);
+        noiseFilter.frequency.exponentialRampToValueAtTime(30, t + 4.0);
+        const noiseGain = this.ctx.createGain();
+        noiseGain.gain.setValueAtTime(this.volume * 1.0, t);
+        noiseGain.gain.exponentialRampToValueAtTime(0.01, t + 4.5);
+        noise.connect(noiseFilter);
+        noiseFilter.connect(noiseGain);
+        noiseGain.connect(this.limiter);
+        noise.start(t);
+        // --- 3. CRACK (sharp attack) ---
+        const crack = this.ctx.createOscillator();
+        crack.type = "triangle";
+        const crackGain = this.ctx.createGain();
+        crack.frequency.setValueAtTime(200, t);
+        crack.frequency.exponentialRampToValueAtTime(50, t + 0.1);
+        crackGain.gain.setValueAtTime(this.volume * 0.3, t);
+        crackGain.gain.exponentialRampToValueAtTime(0.01, t + 0.1);
+        crack.connect(crackGain);
+        crackGain.connect(this.limiter);
+        crack.start(t);
+        crack.stop(t + 0.1);
+    }
+    /**
+     * Play lighter "whoosh" sound for rocket launch
+     */
+    playRocketLaunch() {
+        if (!this.enabled || !this.ctx || !this.limiter)
+            return;
+        const t = this.ctx.currentTime;
+        // Rising tone
+        const osc = this.ctx.createOscillator();
+        const oscGain = this.ctx.createGain();
+        osc.type = "sawtooth";
+        osc.frequency.setValueAtTime(100, t);
+        osc.frequency.exponentialRampToValueAtTime(400, t + 0.5);
+        oscGain.gain.setValueAtTime(this.volume * 0.3, t);
+        oscGain.gain.exponentialRampToValueAtTime(0.01, t + 0.5);
+        osc.connect(oscGain);
+        oscGain.connect(this.limiter);
+        osc.start(t);
+        osc.stop(t + 0.5);
+    }
+    setVolume(volume) {
+        this.volume = Math.max(0, Math.min(1, volume));
+    }
+    getVolume() {
+        return this.volume;
+    }
+    isEnabled() {
+        return this.enabled;
+    }
+    setEnabled(enabled) {
+        this.enabled = enabled;
+    }
+}

package/dist/engine.js

@@ -250,12 +250,12 @@ export class Engine {
 
           let lightAccum = light.ambientColor;
           
-          // Rim light calculation
+          // Rim light calculation - proper Fresnel for edge-only highlights
           let viewDir = normalize(camera.viewPos - input.worldPos);
-          var rimFactor = 1.0 - max(dot(n, viewDir), 0.0);
-          rimFactor = rimFactor * rimFactor; // Optimized: direct multiply instead of pow(x, 2.0)
+          let fresnel = 1.0 - abs(dot(n, viewDir));
+          let rimFactor = pow(fresnel, 4.0); // Higher power for sharper edge-only effect
           let rimLight = material.rimColor * material.rimIntensity * rimFactor;
-          
+
           let color = albedo * lightAccum + rimLight;
           
           return vec4f(color, finalAlpha);

package/dist/ik-solver.d.ts

@@ -3,6 +3,7 @@
  * Based on reference from babylon-mmd and Saba MMD library
  * https://github.com/benikabocha/saba/blob/master/src/Saba/Model/MMD/MMDIkSolver.cpp
  */
+import { Mat4, Quat, Vec3 } from "./math";
 import { Bone, IKSolver, IKChainInfo } from "./model";
 /**
  * Solve IK chains for a model
@@ -13,14 +14,12 @@ export declare class IKSolverSystem {
     /**
      * Solve all IK chains
      */
-    static solve(ikSolvers: IKSolver[], bones: Bone[], localRotations: Float32Array, localTranslations: Float32Array, worldMatrices: Float32Array, ikChainInfo: IKChainInfo[]): void;
+    static solve(ikSolvers: IKSolver[], bones: Bone[], localRotations: Quat[], localTranslations: Vec3[], worldMatrices: Mat4[], ikChainInfo: IKChainInfo[]): void;
     private static solveIK;
     private static solveChain;
     private static limitAngle;
     private static getDistance;
     private static getWorldTranslation;
-    private static getQuatFromArray;
-    private static setQuatToArray;
     private static extractEulerAngles;
     private static limitEulerAngles;
     private static reconstructQuatFromEuler;

package/dist/ik-solver.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ik-solver.d.ts","sourceRoot":"","sources":["../src/ik-solver.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,EAAE,IAAI,EAAU,QAAQ,EAAE,WAAW,EAAE,MAAM,SAAS,CAAA;AAoE7D;;GAEG;AACH,qBAAa,cAAc;IACzB,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,OAAO,CAAS;IACxC,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,SAAS,CAAuB;IAExD;;OAEG;WACW,KAAK,CACjB,SAAS,EAAE,QAAQ,EAAE,EACrB,KAAK,EAAE,IAAI,EAAE,EACb,cAAc,EAAE,YAAY,EAC5B,iBAAiB,EAAE,YAAY,EAC/B,aAAa,EAAE,YAAY,EAC3B,WAAW,EAAE,WAAW,EAAE,GACzB,IAAI;IAMP,OAAO,CAAC,MAAM,CAAC,OAAO;IA4EtB,OAAO,CAAC,MAAM,CAAC,UAAU;IA2FzB,OAAO,CAAC,MAAM,CAAC,UAAU;IAYzB,OAAO,CAAC,MAAM,CAAC,WAAW;IAM1B,OAAO,CAAC,MAAM,CAAC,mBAAmB;IAKlC,OAAO,CAAC,MAAM,CAAC,gBAAgB;IAI/B,OAAO,CAAC,MAAM,CAAC,cAAc;IAO7B,OAAO,CAAC,MAAM,CAAC,kBAAkB;IAmCjC,OAAO,CAAC,MAAM,CAAC,gBAAgB;IAQ/B,OAAO,CAAC,MAAM,CAAC,wBAAwB;IAqBvC,OAAO,CAAC,MAAM,CAAC,4BAA4B;IAe3C,OAAO,CAAC,MAAM,CAAC,eAAe;IAS9B,OAAO,CAAC,MAAM,CAAC,iBAAiB;CA2CjC"}
+{"version":3,"file":"ik-solver.d.ts","sourceRoot":"","sources":["../src/ik-solver.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAA;AACzC,OAAO,EAAE,IAAI,EAAU,QAAQ,EAAE,WAAW,EAAE,MAAM,SAAS,CAAA;AAoE7D;;GAEG;AACH,qBAAa,cAAc;IACzB,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,OAAO,CAAS;IACxC,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,SAAS,CAAuB;IAExD;;OAEG;WACW,KAAK,CACjB,SAAS,EAAE,QAAQ,EAAE,EACrB,KAAK,EAAE,IAAI,EAAE,EACb,cAAc,EAAE,IAAI,EAAE,EACtB,iBAAiB,EAAE,IAAI,EAAE,EACzB,aAAa,EAAE,IAAI,EAAE,EACrB,WAAW,EAAE,WAAW,EAAE,GACzB,IAAI;IAMP,OAAO,CAAC,MAAM,CAAC,OAAO;IA2EtB,OAAO,CAAC,MAAM,CAAC,UAAU;IA2FzB,OAAO,CAAC,MAAM,CAAC,UAAU;IAYzB,OAAO,CAAC,MAAM,CAAC,WAAW;IAM1B,OAAO,CAAC,MAAM,CAAC,mBAAmB;IAKlC,OAAO,CAAC,MAAM,CAAC,kBAAkB;IAmCjC,OAAO,CAAC,MAAM,CAAC,gBAAgB;IAQ/B,OAAO,CAAC,MAAM,CAAC,wBAAwB;IAqBvC,OAAO,CAAC,MAAM,CAAC,4BAA4B;IAc3C,OAAO,CAAC,MAAM,CAAC,eAAe;IAS9B,OAAO,CAAC,MAAM,CAAC,iBAAiB;CAoCjC"}

package/dist/ik-solver.js

@@ -122,10 +122,9 @@ export class IKSolverSystem {
         for (const link of solver.links) {
             const chainInfo = ikChainInfo[link.boneIndex];
             if (chainInfo?.ikRotation) {
-                const qi = link.boneIndex * 4;
-                const localRot = this.getQuatFromArray(localRotations, qi);
+                const localRot = localRotations[link.boneIndex];
                 const finalRot = chainInfo.ikRotation.multiply(localRot).normalize();
-                this.setQuatToArray(localRotations, qi, finalRot);
+                localRot.set(finalRot);
             }
         }
     }
@@ -182,14 +181,14 @@ export class IKSolverSystem {
             chainInfo.ikRotation = ikRotation.multiply(chainInfo.ikRotation);
             // Apply angle constraints if present
             if (chain.minimumAngle && chain.maximumAngle) {
-                const qi = chainBoneIndex * 4;
-                const localRot = this.getQuatFromArray(localRotations, qi);
+                const localRot = localRotations[chainBoneIndex];
                 chainInfo.localRotation = localRot.clone();
                 const combinedRot = chainInfo.ikRotation.multiply(localRot);
                 const euler = this.extractEulerAngles(combinedRot, chain.rotationOrder);
                 const limited = this.limitEulerAngles(euler, chain.minimumAngle, chain.maximumAngle, useAxis);
                 chainInfo.ikRotation = this.reconstructQuatFromEuler(limited, chain.rotationOrder);
-                chainInfo.ikRotation = chainInfo.ikRotation.multiply(localRot.conjugate().normalize());
+                // Clone localRot to avoid mutating, then conjugate and normalize
+                chainInfo.ikRotation = chainInfo.ikRotation.multiply(localRot.clone().conjugate().normalize());
             }
         }
         // Update world matrices for affected bones (using IK-modified rotations)
@@ -218,17 +217,8 @@ export class IKSolverSystem {
         return pos1.subtract(pos2).length();
     }
     static getWorldTranslation(boneIndex, worldMatrices) {
-        const offset = boneIndex * 16;
-        return new Vec3(worldMatrices[offset + 12], worldMatrices[offset + 13], worldMatrices[offset + 14]);
-    }
-    static getQuatFromArray(array, offset) {
-        return new Quat(array[offset], array[offset + 1], array[offset + 2], array[offset + 3]);
-    }
-    static setQuatToArray(array, offset, quat) {
-        array[offset] = quat.x;
-        array[offset + 1] = quat.y;
-        array[offset + 2] = quat.z;
-        array[offset + 3] = quat.w;
+        const mat = worldMatrices[boneIndex];
+        return new Vec3(mat.values[12], mat.values[13], mat.values[14]);
     }
     static extractEulerAngles(quat, order) {
         const rotMatrix = Mat4.fromQuat(quat.x, quat.y, quat.z, quat.w);
@@ -292,8 +282,7 @@ export class IKSolverSystem {
     static getParentWorldRotationMatrix(boneIndex, bones, worldMatrices) {
         const bone = bones[boneIndex];
         if (bone.parentIndex >= 0) {
-            const parentOffset = bone.parentIndex * 16;
-            const parentMat = new Mat4(worldMatrices.subarray(parentOffset, parentOffset + 16));
+            const parentMat = worldMatrices[bone.parentIndex];
             // Remove translation
             const rotMat = Mat4.identity();
             const m = parentMat.values;
@@ -310,9 +299,8 @@ export class IKSolverSystem {
     }
     static updateWorldMatrix(boneIndex, bones, localRotations, localTranslations, worldMatrices, ikChainInfo) {
         const bone = bones[boneIndex];
-        const qi = boneIndex * 4;
-        const ti = boneIndex * 3;
-        const localRot = this.getQuatFromArray(localRotations, qi);
+        const localRot = localRotations[boneIndex];
+        const localTrans = localTranslations[boneIndex];
         // Apply IK rotation if available
         let finalRot = localRot;
         if (ikChainInfo) {
@@ -322,22 +310,18 @@ export class IKSolverSystem {
             }
         }
         const rotateM = Mat4.fromQuat(finalRot.x, finalRot.y, finalRot.z, finalRot.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;
+            .translateInPlace(localTrans.x, localTrans.y, localTrans.z);
+        const worldMat = worldMatrices[boneIndex];
         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);
+            const parentMat = worldMatrices[bone.parentIndex];
+            const result = parentMat.multiply(localM);
+            worldMat.values.set(result.values);
         }
         else {
-            worldMatrices.subarray(worldOffset, worldOffset + 16).set(localM.values);
+            worldMat.values.set(localM.values);
         }
     }
 }

package/dist/math.d.ts

@@ -4,6 +4,7 @@ export declare class Vec3 {
     y: number;
     z: number;
     constructor(x: number, y: number, z: number);
+    static zeros(): Vec3;
     add(other: Vec3): Vec3;
     subtract(other: Vec3): Vec3;
     length(): number;
@@ -11,6 +12,7 @@ export declare class Vec3 {
     cross(other: Vec3): Vec3;
     dot(other: Vec3): number;
     scale(scalar: number): Vec3;
+    set(other: Vec3): Vec3;
 }
 export declare class Quat {
     x: number;
@@ -18,6 +20,7 @@ export declare class Quat {
     z: number;
     w: number;
     constructor(x: number, y: number, z: number, w: number);
+    static identity(): Quat;
     add(other: Quat): Quat;
     clone(): Quat;
     multiply(other: Quat): Quat;
@@ -26,6 +29,7 @@ export declare class Quat {
     normalize(): Quat;
     static fromAxisAngle(axis: Vec3, angle: number): Quat;
     toArray(): [number, number, number, number];
+    set(other: Quat): Quat;
     static slerp(a: Quat, b: Quat, t: number): Quat;
     static fromEuler(rotX: number, rotY: number, rotZ: number): Quat;
 }

package/dist/math.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"math.d.ts","sourceRoot":"","sources":["../src/math.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"math.d.ts","sourceRoot":"","sources":["../src/math.ts"],"names":[],"mappings":"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"}

package/dist/math.js

@@ -8,6 +8,9 @@ export class Vec3 {
         this.y = y;
         this.z = z;
     }
+    static zeros() {
+        return new Vec3(0, 0, 0);
+    }
     add(other) {
         return new Vec3(this.x + other.x, this.y + other.y, this.z + other.z);
     }
@@ -17,11 +20,21 @@ export class Vec3 {
     length() {
         return Math.sqrt(this.x * this.x + this.y * this.y + this.z * this.z);
     }
+    // Normalize this vector in-place (mutates this object)
     normalize() {
         const len = this.length();
-        if (len === 0)
-            return new Vec3(0, 0, 0);
-        return new Vec3(this.x / len, this.y / len, this.z / len);
+        if (len === 0) {
+            this.x = 0;
+            this.y = 0;
+            this.z = 0;
+        }
+        else {
+            const invLen = 1 / len;
+            this.x *= invLen;
+            this.y *= invLen;
+            this.z *= invLen;
+        }
+        return this;
     }
     cross(other) {
         return new Vec3(this.y * other.z - this.z * other.y, this.z * other.x - this.x * other.z, this.x * other.y - this.y * other.x);
@@ -32,6 +45,13 @@ export class Vec3 {
     scale(scalar) {
         return new Vec3(this.x * scalar, this.y * scalar, this.z * scalar);
     }
+    // Set this vector's components from another vector (in-place mutation)
+    set(other) {
+        this.x = other.x;
+        this.y = other.y;
+        this.z = other.z;
+        return this;
+    }
 }
 export class Quat {
     constructor(x, y, z, w) {
@@ -40,6 +60,9 @@ export class Quat {
         this.z = z;
         this.w = w;
     }
+    static identity() {
+        return new Quat(0, 0, 0, 1);
+    }
     add(other) {
         return new Quat(this.x + other.x, this.y + other.y, this.z + other.z, this.w + other.w);
     }
@@ -50,30 +73,62 @@ export class Quat {
         // Proper quaternion multiplication (not component-wise)
         return new Quat(this.w * other.x + this.x * other.w + this.y * other.z - this.z * other.y, this.w * other.y - this.x * other.z + this.y * other.w + this.z * other.x, this.w * other.z + this.x * other.y - this.y * other.x + this.z * other.w, this.w * other.w - this.x * other.x - this.y * other.y - this.z * other.z);
     }
+    // Conjugate this quaternion in-place (mutates this object)
+    // Conjugate (inverse for unit quaternions): (x, y, z, w) -> (-x, -y, -z, w)
     conjugate() {
-        // Conjugate (inverse for unit quaternions): (x, y, z, w) -> (-x, -y, -z, w)
-        return new Quat(-this.x, -this.y, -this.z, this.w);
+        this.x = -this.x;
+        this.y = -this.y;
+        this.z = -this.z;
+        return this;
     }
     length() {
         return Math.sqrt(this.x * this.x + this.y * this.y + this.z * this.z + this.w * this.w);
     }
+    // Normalize this quaternion in-place (mutates this object)
     normalize() {
         const len = this.length();
-        if (len === 0)
-            return new Quat(0, 0, 0, 1);
-        return new Quat(this.x / len, this.y / len, this.z / len, this.w / len);
+        if (len === 0) {
+            this.x = 0;
+            this.y = 0;
+            this.z = 0;
+            this.w = 1;
+        }
+        else {
+            const invLen = 1 / len;
+            this.x *= invLen;
+            this.y *= invLen;
+            this.z *= invLen;
+            this.w *= invLen;
+        }
+        return this;
     }
     // Static method: create quaternion from rotation axis and angle
     static fromAxisAngle(axis, angle) {
-        const normalizedAxis = axis.normalize();
+        // Clone to avoid mutating input, then normalize
+        const nx = axis.x;
+        const ny = axis.y;
+        const nz = axis.z;
+        const len = Math.sqrt(nx * nx + ny * ny + nz * nz);
+        const invLen = len > 0 ? 1 / len : 0;
+        const normalizedX = nx * invLen;
+        const normalizedY = ny * invLen;
+        const normalizedZ = nz * invLen;
         const halfAngle = angle * 0.5;
         const sinHalf = Math.sin(halfAngle);
         const cosHalf = Math.cos(halfAngle);
-        return new Quat(normalizedAxis.x * sinHalf, normalizedAxis.y * sinHalf, normalizedAxis.z * sinHalf, cosHalf);
+        return new Quat(normalizedX * sinHalf, normalizedY * sinHalf, normalizedZ * sinHalf, cosHalf);
     }
     toArray() {
         return [this.x, this.y, this.z, this.w];
     }
+    // Set this quaternion's components from another quaternion (in-place mutation)
+    set(other) {
+        this.x = other.x;
+        this.y = other.y;
+        this.z = other.z;
+        this.w = other.w;
+        return this;
+    }
     // Spherical linear interpolation between two quaternions
     static slerp(a, b, t) {
         let cos = a.x * b.x + a.y * b.y + a.z * b.z + a.w * b.w;
@@ -153,9 +208,13 @@ export class Mat4 {
     // For left-handed: camera looks along +Z direction
     static lookAt(eye, target, up) {
         // In left-handed: forward = target - eye (Z+ direction)
-        const forward = target.subtract(eye).normalize();
-        const right = up.cross(forward).normalize(); // X+ is right
-        const upVec = forward.cross(right).normalize(); // Y+ is up
+        // These operations create new Vec3 objects, so normalize() mutates those new objects
+        const forward = target.subtract(eye);
+        forward.normalize();
+        const right = up.cross(forward);
+        right.normalize(); // X+ is right
+        const upVec = forward.cross(right);
+        upVec.normalize(); // Y+ is up
         return new Mat4(new Float32Array([
             right.x,
             upVec.x,

package/dist/model.d.ts

@@ -1,4 +1,4 @@
-import { Quat, Vec3 } from "./math";
+import { Mat4, Quat, Vec3 } from "./math";
 import { Rigidbody, Joint } from "./physics";
 export interface Texture {
     path: string;
@@ -83,9 +83,9 @@ export interface Morphing {
 }
 export interface SkeletonRuntime {
     nameIndex: Record<string, number>;
-    localRotations: Float32Array;
-    localTranslations: Float32Array;
-    worldMatrices: Float32Array;
+    localRotations: Quat[];
+    localTranslations: Vec3[];
+    worldMatrices: Mat4[];
     ikChainInfo?: IKChainInfo[];
     ikSolvers?: IKSolver[];
 }
@@ -110,7 +110,7 @@ export declare class Model {
     private morphsDirty;
     private cachedIdentityMat1;
     private cachedIdentityMat2;
-    private cachedSkinMatrices?;
+    private skinMatricesArray?;
     private tweenState;
     private tweenTimeMs;
     private animationData;