reze-engine 0.13.0 → 0.13.2

package/src/math.ts

@@ -69,6 +69,54 @@ export class Vec3 {
     this.z = other.z
     return this
   }
+
+  setXYZ(x: number, y: number, z: number): Vec3 {
+    this.x = x
+    this.y = y
+    this.z = z
+    return this
+  }
+
+  // out = a - b (no allocation)
+  static subtractInto(a: Vec3, b: Vec3, out: Vec3): Vec3 {
+    out.x = a.x - b.x
+    out.y = a.y - b.y
+    out.z = a.z - b.z
+    return out
+  }
+
+  // out = a × b (no allocation). Safe when out === a or out === b.
+  static crossInto(a: Vec3, b: Vec3, out: Vec3): Vec3 {
+    const ax = a.x, ay = a.y, az = a.z
+    const bx = b.x, by = b.y, bz = b.z
+    out.x = ay * bz - az * by
+    out.y = az * bx - ax * bz
+    out.z = ax * by - ay * bx
+    return out
+  }
+
+  // Read translation from Mat4 values array (column-major) into out.
+  static setFromMat4Translation(m: Float32Array, out: Vec3): Vec3 {
+    out.x = m[12]
+    out.y = m[13]
+    out.z = m[14]
+    return out
+  }
+
+  // Transform normal by the upper-left 3x3 of a Mat4 (column-major) into out.
+  // Safe when out === normal.
+  static transformMat4RotationInto(normal: Vec3, m: Float32Array, out: Vec3): Vec3 {
+    const nx = normal.x, ny = normal.y, nz = normal.z
+    out.x = m[0] * nx + m[4] * ny + m[8] * nz
+    out.y = m[1] * nx + m[5] * ny + m[9] * nz
+    out.z = m[2] * nx + m[6] * ny + m[10] * nz
+    return out
+  }
+
+  // In-place normalize returning length squared info via Vec3. Alias for normalize() but explicit.
+  normalizeInPlace(): Vec3 {
+    return this.normalize()
+  }
 }
 
 export class Quat {
@@ -204,6 +252,71 @@ export class Quat {
     return new Quat(s0 * a.x + s1 * bx, s0 * a.y + s1 * by, s0 * a.z + s1 * bz, s0 * a.w + s1 * bw)
   }
 
+  // out = a * b (quaternion multiplication, rotation composition).
+  // Safe when out === a or out === b.
+  static multiplyInto(a: Quat, b: Quat, out: Quat): Quat {
+    const ax = a.x, ay = a.y, az = a.z, aw = a.w
+    const bx = b.x, by = b.y, bz = b.z, bw = b.w
+    out.x = aw * bx + ax * bw + ay * bz - az * by
+    out.y = aw * by - ax * bz + ay * bw + az * bx
+    out.z = aw * bz + ax * by - ay * bx + az * bw
+    out.w = aw * bw - ax * bx - ay * by - az * bz
+    return out
+  }
+
+  // out = quat from axis (unnormalized) and angle.
+  static fromAxisAngleInto(ax: number, ay: number, az: number, angle: number, out: Quat): Quat {
+    const len = Math.sqrt(ax * ax + ay * ay + az * az)
+    const invLen = len > 0 ? 1 / len : 0
+    const nx = ax * invLen, ny = ay * invLen, nz = az * invLen
+    const half = angle * 0.5
+    const s = Math.sin(half), c = Math.cos(half)
+    out.x = nx * s
+    out.y = ny * s
+    out.z = nz * s
+    out.w = c
+    return out
+  }
+
+  // out = slerp(a, b, t). Safe when out === a or out === b.
+  static slerpInto(a: Quat, b: Quat, t: number, out: Quat): Quat {
+    let cos = a.x * b.x + a.y * b.y + a.z * b.z + a.w * b.w
+    let bx = b.x, by = b.y, bz = b.z, bw = b.w
+    if (cos < 0) {
+      cos = -cos
+      bx = -bx; by = -by; bz = -bz; bw = -bw
+    }
+    if (cos > 0.9995) {
+      const x = a.x + t * (bx - a.x)
+      const y = a.y + t * (by - a.y)
+      const z = a.z + t * (bz - a.z)
+      const w = a.w + t * (bw - a.w)
+      const invLen = 1 / Math.hypot(x, y, z, w)
+      out.x = x * invLen; out.y = y * invLen; out.z = z * invLen; out.w = w * invLen
+      return out
+    }
+    const theta0 = Math.acos(cos)
+    const sinTheta0 = Math.sin(theta0)
+    const theta = theta0 * t
+    const s0 = Math.sin(theta0 - theta) / sinTheta0
+    const s1 = Math.sin(theta) / sinTheta0
+    out.x = s0 * a.x + s1 * bx
+    out.y = s0 * a.y + s1 * by
+    out.z = s0 * a.z + s1 * bz
+    out.w = s0 * a.w + s1 * bw
+    return out
+  }
+
+  setXYZW(x: number, y: number, z: number, w: number): Quat {
+    this.x = x; this.y = y; this.z = z; this.w = w
+    return this
+  }
+
+  setIdentity(): Quat {
+    this.x = 0; this.y = 0; this.z = 0; this.w = 1
+    return this
+  }
+
   // Convert Euler angles to quaternion (ZXY order, left-handed, PMX format)
   static fromEuler(rotX: number, rotY: number, rotZ: number): Quat {
     const cx = Math.cos(rotX * 0.5)
@@ -371,6 +484,116 @@ export class Mat4 {
     return new Mat4(this.values.slice())
   }
 
+  // Write rotation matrix from quaternion into existing Float32Array (column-major).
+  static fromQuatInto(x: number, y: number, z: number, w: number, out: Float32Array, offset: number = 0): void {
+    const x2 = x + x, y2 = y + y, z2 = z + z
+    const xx = x * x2, xy = x * y2, xz = x * z2
+    const yy = y * y2, yz = y * z2, zz = z * z2
+    const wx = w * x2, wy = w * y2, wz = w * z2
+    out[offset + 0] = 1 - (yy + zz)
+    out[offset + 1] = xy + wz
+    out[offset + 2] = xz - wy
+    out[offset + 3] = 0
+    out[offset + 4] = xy - wz
+    out[offset + 5] = 1 - (xx + zz)
+    out[offset + 6] = yz + wx
+    out[offset + 7] = 0
+    out[offset + 8] = xz + wy
+    out[offset + 9] = yz - wx
+    out[offset + 10] = 1 - (xx + yy)
+    out[offset + 11] = 0
+    out[offset + 12] = 0
+    out[offset + 13] = 0
+    out[offset + 14] = 0
+    out[offset + 15] = 1
+  }
+
+  // Fused local transform: out = T(bindT) · R(quat) · T(localT).
+  // Result translation = bindT + R * localT; rotation column block = R.
+  // Column-major. Zero allocations.
+  static localTransformInto(
+    bx: number, by: number, bz: number,
+    qx: number, qy: number, qz: number, qw: number,
+    lx: number, ly: number, lz: number,
+    out: Float32Array
+  ): void {
+    const x2 = qx + qx, y2 = qy + qy, z2 = qz + qz
+    const xx = qx * x2, xy = qx * y2, xz = qx * z2
+    const yy = qy * y2, yz = qy * z2, zz = qz * z2
+    const wx = qw * x2, wy = qw * y2, wz = qw * z2
+    const m00 = 1 - (yy + zz), m01 = xy + wz,       m02 = xz - wy
+    const m10 = xy - wz,       m11 = 1 - (xx + zz), m12 = yz + wx
+    const m20 = xz + wy,       m21 = yz - wx,       m22 = 1 - (xx + yy)
+    out[0] = m00; out[1] = m01; out[2] = m02; out[3] = 0
+    out[4] = m10; out[5] = m11; out[6] = m12; out[7] = 0
+    out[8] = m20; out[9] = m21; out[10] = m22; out[11] = 0
+    out[12] = bx + m00 * lx + m10 * ly + m20 * lz
+    out[13] = by + m01 * lx + m11 * ly + m21 * lz
+    out[14] = bz + m02 * lx + m12 * ly + m22 * lz
+    out[15] = 1
+  }
+
+  // Write position+rotation transform into existing Float32Array.
+  static fromPositionRotationInto(
+    px: number, py: number, pz: number,
+    qx: number, qy: number, qz: number, qw: number,
+    out: Float32Array
+  ): void {
+    Mat4.fromQuatInto(qx, qy, qz, qw, out, 0)
+    out[12] = px
+    out[13] = py
+    out[14] = pz
+  }
+
+  // In-place 4x4 inverse into out array. Returns true on success, false if singular (out untouched).
+  static inverseInto(m: Float32Array, out: Float32Array): boolean {
+    const a00 = m[0], a01 = m[1], a02 = m[2], a03 = m[3]
+    const a10 = m[4], a11 = m[5], a12 = m[6], a13 = m[7]
+    const a20 = m[8], a21 = m[9], a22 = m[10], a23 = m[11]
+    const a30 = m[12], a31 = m[13], a32 = m[14], a33 = m[15]
+    const b00 = a00 * a11 - a01 * a10
+    const b01 = a00 * a12 - a02 * a10
+    const b02 = a00 * a13 - a03 * a10
+    const b03 = a01 * a12 - a02 * a11
+    const b04 = a01 * a13 - a03 * a11
+    const b05 = a02 * a13 - a03 * a12
+    const b06 = a20 * a31 - a21 * a30
+    const b07 = a20 * a32 - a22 * a30
+    const b08 = a20 * a33 - a23 * a30
+    const b09 = a21 * a32 - a22 * a31
+    const b10 = a21 * a33 - a23 * a31
+    const b11 = a22 * a33 - a23 * a32
+    let det = b00 * b11 - b01 * b10 + b02 * b09 + b03 * b08 - b04 * b07 + b05 * b06
+    if (Math.abs(det) < 1e-10) return false
+    det = 1.0 / det
+    out[0] = (a11 * b11 - a12 * b10 + a13 * b09) * det
+    out[1] = (a02 * b10 - a01 * b11 - a03 * b09) * det
+    out[2] = (a31 * b05 - a32 * b04 + a33 * b03) * det
+    out[3] = (a22 * b04 - a21 * b05 - a23 * b03) * det
+    out[4] = (a12 * b08 - a10 * b11 - a13 * b07) * det
+    out[5] = (a00 * b11 - a02 * b08 + a03 * b07) * det
+    out[6] = (a32 * b02 - a30 * b05 - a33 * b01) * det
+    out[7] = (a20 * b05 - a22 * b02 + a23 * b01) * det
+    out[8] = (a10 * b10 - a11 * b08 + a13 * b06) * det
+    out[9] = (a01 * b08 - a00 * b10 - a03 * b06) * det
+    out[10] = (a30 * b04 - a31 * b02 + a33 * b00) * det
+    out[11] = (a21 * b02 - a20 * b04 - a23 * b00) * det
+    out[12] = (a11 * b07 - a10 * b09 - a12 * b06) * det
+    out[13] = (a00 * b09 - a01 * b07 + a02 * b06) * det
+    out[14] = (a31 * b01 - a30 * b03 - a32 * b00) * det
+    out[15] = (a20 * b03 - a21 * b01 + a22 * b00) * det
+    return true
+  }
+
+  // Copy only the rotation (upper-left 3x3) of src into dst, zero out translation, identity w.
+  // Column-major in both.
+  static copyRotationInto(src: Float32Array, dst: Float32Array): void {
+    dst[0] = src[0]; dst[1] = src[1]; dst[2] = src[2]; dst[3] = 0
+    dst[4] = src[4]; dst[5] = src[5]; dst[6] = src[6]; dst[7] = 0
+    dst[8] = src[8]; dst[9] = src[9]; dst[10] = src[10]; dst[11] = 0
+    dst[12] = 0; dst[13] = 0; dst[14] = 0; dst[15] = 1
+  }
+
   static fromQuat(x: number, y: number, z: number, w: number): Mat4 {
     // Column-major rotation matrix from quaternion (matches glMatrix/WGSL)
     const out = new Float32Array(16)
@@ -424,6 +647,46 @@ export class Mat4 {
     return Mat4.toQuatFromArray(this.values, 0)
   }
 
+  // Extract quaternion from matrix array into an existing Quat (no allocation).
+  static toQuatFromArrayInto(m: Float32Array, offset: number, out: Quat): Quat {
+    const m00 = m[offset + 0], m01 = m[offset + 4], m02 = m[offset + 8]
+    const m10 = m[offset + 1], m11 = m[offset + 5], m12 = m[offset + 9]
+    const m20 = m[offset + 2], m21 = m[offset + 6], m22 = m[offset + 10]
+    const trace = m00 + m11 + m22
+    let x = 0, y = 0, z = 0, w = 1
+    if (trace > 0) {
+      const s = Math.sqrt(trace + 1.0) * 2
+      w = 0.25 * s
+      x = (m21 - m12) / s
+      y = (m02 - m20) / s
+      z = (m10 - m01) / s
+    } else if (m00 > m11 && m00 > m22) {
+      const s = Math.sqrt(1.0 + m00 - m11 - m22) * 2
+      w = (m21 - m12) / s
+      x = 0.25 * s
+      y = (m01 + m10) / s
+      z = (m02 + m20) / s
+    } else if (m11 > m22) {
+      const s = Math.sqrt(1.0 + m11 - m00 - m22) * 2
+      w = (m02 - m20) / s
+      x = (m01 + m10) / s
+      y = 0.25 * s
+      z = (m12 + m21) / s
+    } else {
+      const s = Math.sqrt(1.0 + m22 - m00 - m11) * 2
+      w = (m10 - m01) / s
+      x = (m02 + m20) / s
+      y = (m12 + m21) / s
+      z = 0.25 * s
+    }
+    const invLen = 1 / Math.hypot(x, y, z, w)
+    out.x = x * invLen
+    out.y = y * invLen
+    out.z = z * invLen
+    out.w = w * invLen
+    return out
+  }
+
   // Static method to extract quaternion from matrix array (avoids creating Mat4 object)
   static toQuatFromArray(m: Float32Array, offset: number): Quat {
     const m00 = m[offset + 0],
@@ -567,3 +830,31 @@ export class Mat4 {
   }
 }
 
+// Preallocated scratch instances for hot paths. Each subsystem should use its own
+// slot to avoid cross-call stomping. Bump the count if more call sites need scratch.
+export const scratchMat4Values: Float32Array[] = [
+  new Float32Array(16),
+  new Float32Array(16),
+  new Float32Array(16),
+  new Float32Array(16),
+  new Float32Array(16),
+  new Float32Array(16),
+]
+
+export const scratchVec3: Vec3[] = [
+  new Vec3(0, 0, 0),
+  new Vec3(0, 0, 0),
+  new Vec3(0, 0, 0),
+  new Vec3(0, 0, 0),
+  new Vec3(0, 0, 0),
+  new Vec3(0, 0, 0),
+  new Vec3(0, 0, 0),
+  new Vec3(0, 0, 0),
+]
+
+export const scratchQuat: Quat[] = [
+  new Quat(0, 0, 0, 1),
+  new Quat(0, 0, 0, 1),
+  new Quat(0, 0, 0, 1),
+  new Quat(0, 0, 0, 1),
+]

package/src/model.ts

@@ -1,4 +1,4 @@
-import { Mat4, Quat, Vec3 } from "./math"
+import { Mat4, Quat, Vec3, scratchMat4Values, scratchQuat } from "./math"
 import { Engine } from "./engine"
 import { joinAssetPath, type AssetReader } from "./asset-reader"
 import { Rigidbody, Joint } from "./physics"
@@ -167,6 +167,27 @@ export class Model {
     this._name = value
   }
 
+  // Root transform public API. Instant setters — no tween baked in; wrap in
+  // your own lerp if you need smoothing. Changes are applied on the next
+  // getSkinMatrices() call (once per frame during rendering).
+  get position(): Vec3 {
+    return this._position
+  }
+
+  get rotation(): Quat {
+    return this._rotation
+  }
+
+  setPosition(position: Vec3): void {
+    this._position.set(position)
+    this.rootMatrixDirty = true
+  }
+
+  setRotation(rotation: Quat): void {
+    this._rotation.set(rotation)
+    this.rootMatrixDirty = true
+  }
+
   private vertexData: Float32Array<ArrayBuffer>
   private baseVertexData: Float32Array<ArrayBuffer> // Original vertex data before morphing
   private vertexCount: number
@@ -191,9 +212,15 @@ export class Model {
   private runtimeMorph!: MorphRuntime
   private morphsDirty: boolean = false // Flag indicating if morphs need to be applied
 
-  // Cached identity matrices to avoid allocations in computeWorldMatrices
-  private cachedIdentityMat1 = Mat4.identity()
-  private cachedIdentityMat2 = Mat4.identity()
+  // Root transform — model's placement in world space, independent of bones.
+  // Folded into skin matrices (see getSkinMatrices) so every pass (main VS,
+  // shadow VS, any future skinned pass) sees it without per-shader plumbing.
+  // Skip-when-identity flag avoids the extra mat mul per bone when unused.
+  private _position: Vec3 = Vec3.zeros()
+  private _rotation: Quat = Quat.identity()
+  private rootMatrixValues: Float32Array = new Float32Array([1,0,0,0, 0,1,0,0, 0,0,1,0, 0,0,0,1])
+  private rootMatrixDirty: boolean = false
+  private rootIsIdentity: boolean = true
 
   // Cached skin matrices array to avoid allocations in getSkinMatrices
   private skinMatricesArray?: Float32Array
@@ -687,12 +714,32 @@ export class Model {
 
     const skinMatrices = this.skinMatricesArray
 
-    // Compute skin matrices: skinMatrix = worldMatrix × inverseBindMatrix
-    for (let i = 0; i < boneCount; i++) {
-      const worldMat = worldMats[i]
-      const invBindOffset = i * 16
-      const skinOffset = i * 16
-      Mat4.multiplyArrays(worldMat.values, 0, invBindMats, invBindOffset, skinMatrices, skinOffset)
+    // Rebuild root matrix + cache identity-shortcut flag only when pos/rot changed.
+    if (this.rootMatrixDirty) {
+      const p = this._position, r = this._rotation
+      Mat4.fromPositionRotationInto(p.x, p.y, p.z, r.x, r.y, r.z, r.w, this.rootMatrixValues)
+      this.rootIsIdentity =
+        p.x === 0 && p.y === 0 && p.z === 0 &&
+        r.x === 0 && r.y === 0 && r.z === 0 && r.w === 1
+      this.rootMatrixDirty = false
+    }
+
+    if (this.rootIsIdentity) {
+      // skinMatrix = worldMatrix × inverseBindMatrix
+      for (let i = 0; i < boneCount; i++) {
+        const off = i * 16
+        Mat4.multiplyArrays(worldMats[i].values, 0, invBindMats, off, skinMatrices, off)
+      }
+    } else {
+      // skinMatrix = rootMatrix × worldMatrix × inverseBindMatrix
+      // Two-mul path. scratchMat4Values[1] — [0] is owned by computeWorldMatrices.
+      const rootVals = this.rootMatrixValues
+      const tmp = scratchMat4Values[1]
+      for (let i = 0; i < boneCount; i++) {
+        const off = i * 16
+        Mat4.multiplyArrays(rootVals, 0, worldMats[i].values, 0, tmp, 0)
+        Mat4.multiplyArrays(tmp, 0, invBindMats, off, skinMatrices, off)
+      }
     }
 
     return skinMatrices
@@ -1205,17 +1252,24 @@ export class Model {
     }
 
     // Get base rotation
-    let boneRot = localRot[boneIndex]
+    const baseRot = localRot[boneIndex]
+    let fx = baseRot.x, fy = baseRot.y, fz = baseRot.z, fw = baseRot.w
 
-    // Apply IK rotation if requested
+    // Apply IK rotation if requested: finalRot = ik * base, then normalize
     if (applyIK && ikChainInfo) {
       const chainInfo = ikChainInfo[boneIndex]
       if (chainInfo?.ikRotation) {
-        boneRot = chainInfo.ikRotation.multiply(boneRot).normalize()
+        const ik = chainInfo.ikRotation
+        const nx = ik.w * fx + ik.x * fw + ik.y * fz - ik.z * fy
+        const ny = ik.w * fy - ik.x * fz + ik.y * fw + ik.z * fx
+        const nz = ik.w * fz + ik.x * fy - ik.y * fx + ik.z * fw
+        const nw = ik.w * fw - ik.x * fx - ik.y * fy - ik.z * fz
+        const len = Math.sqrt(nx * nx + ny * ny + nz * nz + nw * nw)
+        const inv = len > 0 ? 1 / len : 0
+        fx = nx * inv; fy = ny * inv; fz = nz * inv; fw = nw * inv
       }
     }
 
-    let rotateM = Mat4.fromQuat(boneRot.x, boneRot.y, boneRot.z, boneRot.w)
     let addLocalTx = 0, addLocalTy = 0, addLocalTz = 0
 
     // Handle append transformations (same logic as computeWorldMatrices)
@@ -1231,26 +1285,29 @@ export class Model {
 
       if (hasRatio) {
         if (b.appendRotate) {
-          // Get append parent's rotation
-          // During IK solving, use only base local rotation (not IK rotations) to avoid
-          // conflicts with IK rotations that are still being computed incrementally
-          // IK rotations will be applied to localRotations after IK solving completes
+          // Recurse first (may touch scratch); all scratch use below happens after it unwinds
           if (appendParentIdx >= 0) {
-            // Compute append parent's world matrix for dependency order, but use base rotation for append
             this.computeSingleBoneWorldMatrix(appendParentIdx, applyIK)
           }
 
-          // Use append parent's base local rotation only (IK rotations are applied after solving)
-          let appendRot = localRot[appendParentIdx]
-
+          const appendRot = localRot[appendParentIdx]
           let ax = appendRot.x, ay = appendRot.y, az = appendRot.z
           const aw = appendRot.w
           const absRatio = ratio < 0 ? -ratio : ratio
           if (ratio < 0) { ax = -ax; ay = -ay; az = -az }
 
-          const appendQuat = new Quat(ax, ay, az, aw)
-          const result = Quat.slerp(Quat.identity(), appendQuat, absRatio)
-          rotateM = Mat4.fromQuat(result.x, result.y, result.z, result.w).multiply(rotateM)
+          // slerp(identity, appendQuat, absRatio) into scratchQuat[1]
+          scratchQuat[0].setXYZW(ax, ay, az, aw)
+          scratchQuat[2].setIdentity()
+          Quat.slerpInto(scratchQuat[2], scratchQuat[0], absRatio, scratchQuat[1])
+
+          // finalRot = slerpResult * finalRot (rotation composition as quat mul)
+          const sx = scratchQuat[1].x, sy = scratchQuat[1].y, sz = scratchQuat[1].z, sw = scratchQuat[1].w
+          const nx = sw * fx + sx * fw + sy * fz - sz * fy
+          const ny = sw * fy - sx * fz + sy * fw + sz * fx
+          const nz = sw * fz + sx * fy - sy * fx + sz * fw
+          const nw = sw * fw - sx * fx - sy * fy - sz * fz
+          fx = nx; fy = ny; fz = nz; fw = nw
         }
 
         if (b.appendMove) {
@@ -1267,18 +1324,21 @@ export class Model {
     const localTy = boneTrans.y + addLocalTy
     const localTz = boneTrans.z + addLocalTz
 
-    this.cachedIdentityMat1
-      .setIdentity()
-      .translateInPlace(b.bindTranslation[0], b.bindTranslation[1], b.bindTranslation[2])
-    this.cachedIdentityMat2.setIdentity().translateInPlace(localTx, localTy, localTz)
-    const localM = this.cachedIdentityMat1.multiply(rotateM).multiply(this.cachedIdentityMat2)
+    // Fused local transform: T_bind · R(finalRot) · T_local → scratchMat4Values[0]
+    const localMVals = scratchMat4Values[0]
+    Mat4.localTransformInto(
+      b.bindTranslation[0], b.bindTranslation[1], b.bindTranslation[2],
+      fx, fy, fz, fw,
+      localTx, localTy, localTz,
+      localMVals
+    )
 
     const worldMat = worldMats[boneIndex]
     if (b.parentIndex >= 0) {
       const parentMat = worldMats[b.parentIndex]
-      Mat4.multiplyArrays(parentMat.values, 0, localM.values, 0, worldMat.values, 0)
+      Mat4.multiplyArrays(parentMat.values, 0, localMVals, 0, worldMat.values, 0)
     } else {
-      worldMat.values.set(localM.values)
+      worldMat.values.set(localMVals)
     }
   }
 
@@ -1302,13 +1362,15 @@ export class Model {
         console.warn(`[RZM] bone ${i} parent out of range: ${b.parentIndex}`)
       }
 
+      // Ensure parent is computed FIRST, before we touch any scratch buffers.
+      // Recursion may itself use scratchMat4Values[0] / scratchQuat; doing it up
+      // front keeps the current frame's scratch slots untouched when we use them below.
+      if (b.parentIndex >= 0 && !computed[b.parentIndex]) computeWorld(b.parentIndex)
+
       const boneRot = localRot[i]
-      let rotateM = Mat4.fromQuat(boneRot.x, boneRot.y, boneRot.z, boneRot.w)
-      let addLocalTx = 0,
-        addLocalTy = 0,
-        addLocalTz = 0
+      let fx = boneRot.x, fy = boneRot.y, fz = boneRot.z, fw = boneRot.w
+      let addLocalTx = 0, addLocalTy = 0, addLocalTz = 0
 
-      // Optimized append rotation check - only check necessary conditions
       const appendParentIdx = b.appendParentIndex
       const hasAppend =
         b.appendRotate && appendParentIdx !== undefined && appendParentIdx >= 0 && appendParentIdx < boneCount
@@ -1320,19 +1382,22 @@ export class Model {
         if (hasRatio) {
           if (b.appendRotate) {
             const appendRot = localRot[appendParentIdx]
-            let ax = appendRot.x
-            let ay = appendRot.y
-            let az = appendRot.z
+            let ax = appendRot.x, ay = appendRot.y, az = appendRot.z
             const aw = appendRot.w
             const absRatio = ratio < 0 ? -ratio : ratio
-            if (ratio < 0) {
-              ax = -ax
-              ay = -ay
-              az = -az
-            }
-            const appendQuat = new Quat(ax, ay, az, aw)
-            const result = Quat.slerp(Quat.identity(), appendQuat, absRatio)
-            rotateM = Mat4.fromQuat(result.x, result.y, result.z, result.w).multiply(rotateM)
+            if (ratio < 0) { ax = -ax; ay = -ay; az = -az }
+
+            scratchQuat[0].setXYZW(ax, ay, az, aw)
+            scratchQuat[2].setIdentity()
+            Quat.slerpInto(scratchQuat[2], scratchQuat[0], absRatio, scratchQuat[1])
+
+            // finalRot = slerpResult * finalRot (quat mul)
+            const sx = scratchQuat[1].x, sy = scratchQuat[1].y, sz = scratchQuat[1].z, sw = scratchQuat[1].w
+            const nx = sw * fx + sx * fw + sy * fz - sz * fy
+            const ny = sw * fy - sx * fz + sy * fw + sz * fx
+            const nz = sw * fz + sx * fy - sy * fx + sz * fw
+            const nw = sw * fw - sx * fx - sy * fy - sz * fz
+            fx = nx; fy = ny; fz = nz; fw = nw
           }
 
           if (b.appendMove) {
@@ -1345,26 +1410,25 @@ export class Model {
         }
       }
 
-      // Build local matrix: identity + bind translation, then rotation, then local translation, then append translation
       const boneTrans = localTrans[i]
       const localTx = boneTrans.x + addLocalTx
       const localTy = boneTrans.y + addLocalTy
       const localTz = boneTrans.z + addLocalTz
-      this.cachedIdentityMat1
-        .setIdentity()
-        .translateInPlace(b.bindTranslation[0], b.bindTranslation[1], b.bindTranslation[2])
-      this.cachedIdentityMat2.setIdentity().translateInPlace(localTx, localTy, localTz)
-      const localM = this.cachedIdentityMat1.multiply(rotateM).multiply(this.cachedIdentityMat2)
+
+      const localMVals = scratchMat4Values[0]
+      Mat4.localTransformInto(
+        b.bindTranslation[0], b.bindTranslation[1], b.bindTranslation[2],
+        fx, fy, fz, fw,
+        localTx, localTy, localTz,
+        localMVals
+      )
 
       const worldMat = worldMats[i]
       if (b.parentIndex >= 0) {
-        const p = b.parentIndex
-        if (!computed[p]) computeWorld(p)
-        const parentMat = worldMats[p]
-        // Multiply parent world matrix by local matrix
-        Mat4.multiplyArrays(parentMat.values, 0, localM.values, 0, worldMat.values, 0)
+        const parentMat = worldMats[b.parentIndex]
+        Mat4.multiplyArrays(parentMat.values, 0, localMVals, 0, worldMat.values, 0)
       } else {
-        worldMat.values.set(localM.values)
+        worldMat.values.set(localMVals)
       }
       computed[i] = true
     }