reze-engine 0.15.0 → 0.16.0

package/src/engine.ts

@@ -1,6 +1,7 @@
 import { Camera } from "./camera"
 import { Mat4, Quat, Vec3 } from "./math"
 import { Model } from "./model"
+import { MORPH_COMPUTE_WGSL } from "./shaders/passes/morph"
 import { PmxLoader } from "./pmx-loader"
 import { RezePhysics } from "./physics"
 import {
@@ -188,8 +189,11 @@ export const DEFAULT_ENGINE_OPTIONS = {
 }
 
 export interface EngineStats {
-  fps: number
-  frameTime: number // ms
+  fps: number // derived from mean frame interval — bounded by the real refresh rate
+  frameTime: number // ms — mean frame interval (vsync-to-vsync), not CPU work time
+  frameTimeMax: number // ms — worst frame interval in the window (hitch / stutter indicator)
+  fps1PercentLow: number // "1% low" fps = 1000 / 99th-percentile frame interval
+  jitter: number // ms — stddev of frame intervals (pacing evenness; high = janky at any mean fps)
 }
 
 type DrawCallType = "opaque" | "transparent" | "ground" | "opaque-outline" | "transparent-outline"
@@ -231,6 +235,16 @@ interface ModelInstance {
   materialPresets: MaterialPresetMap | undefined
   physics: RezePhysics | null
   vertexBufferNeedsUpdate: boolean
+  gpuMorph: GpuMorph | null
+}
+
+// Per-model GPU vertex-morph compute state. Present only for models with vertex morphs.
+interface GpuMorph {
+  bindGroup: GPUBindGroup
+  weightsBuffer: GPUBuffer
+  weightsData: Float32Array // staging copy uploaded when weights change
+  workgroups: number
+  dispatchNeeded: boolean
 }
 
 export class Engine {
@@ -374,6 +388,8 @@ export class Engine {
   // Safari's Metal backend won't fold pow(x, 1) to identity.
   private compositePipelineIdentity!: GPURenderPipeline
   private compositePipelineGamma!: GPURenderPipeline
+  private morphComputePipeline!: GPUComputePipeline
+  private morphComputeBindGroupLayout!: GPUBindGroupLayout
   private compositeBindGroupLayout!: GPUBindGroupLayout
   private compositeBindGroup!: GPUBindGroup
   private compositeUniformBuffer!: GPUBuffer
@@ -417,6 +433,10 @@ export class Engine {
   private shadowMapDepthView!: GPUTextureView
   private brdfLutTexture!: GPUTexture
   private brdfLutView!: GPUTextureView
+  private filmicLutTexture!: GPUTexture
+  private filmicLutView!: GPUTextureView
+  // Width of the baked Filmic tone LUT (composite.ts FILMIC_LUT_W must match).
+  private static readonly FILMIC_LUT_WIDTH = 256
   private static readonly SHADOW_MAP_SIZE = 2048
   private shadowDepthPipeline!: GPURenderPipeline
   private shadowLightVPBuffer!: GPUBuffer
@@ -452,20 +472,29 @@ export class Engine {
   // IK and physics enabled at engine level (same for all models)
   private ikEnabled = true
   private physicsEnabled = true
+  // GPU vertex-morph path. Set false BEFORE loadModel to fall back to the CPU path (A/B).
+  private useGpuMorphs = true
 
   // Camera target binding (Babylon/Three style: camera follows model)
   private cameraTargetModel: Model | null = null
   private cameraTargetBoneName = "全ての親"
   private cameraTargetOffset: Vec3 = new Vec3(0, 0, 0)
 
-  private lastFpsUpdate = performance.now()
-  private framesSinceLastUpdate = 0
   private lastFrameTime = performance.now()
-  private frameTimeSum = 0
-  private frameTimeCount = 0
+  // Smoothness metrics are computed over a ring buffer of true frame intervals
+  // (vsync-to-vsync), recomputed at STATS_REFRESH_MS so the readout doesn't flicker.
+  private static readonly STATS_WINDOW = 120
+  private static readonly STATS_REFRESH_MS = 500
+  private frameIntervals = new Float32Array(Engine.STATS_WINDOW)
+  private frameIntervalWrite = 0
+  private frameIntervalFilled = 0
+  private lastStatsCompute = performance.now()
   private stats: EngineStats = {
     fps: 0,
     frameTime: 0,
+    frameTimeMax: 0,
+    fps1PercentLow: 0,
+    jitter: 0,
   }
   private animationFrameId: number | null = null
   private renderLoopCallback: (() => void) | null = null
@@ -726,6 +755,91 @@ export class Engine {
     ltcTemp.destroy()
   }
 
+  // Bake the Blender 3.6 Filmic MHC tone curve into a WIDTH×1 r16float LUT sampled by the
+  // composite pass. The 14 anchors are the same as the old inline array; we fit a monotone
+  // cubic (Fritsch–Carlson) through them so the curve is C1-continuous (no Mach banding in
+  // smooth gradients) while still passing through every anchor (look preserved) and staying
+  // monotone (no tonemap overshoot/ringing). Domain is uniform in log2 space: anchor k sits
+  // at t=k, k=0..13 (t = log2(linear)+10). See composite.ts::filmic for the sampling map.
+  private bakeFilmicLut() {
+    const anchors = [
+      0.0028, 0.0068, 0.0151, 0.0313, 0.061, 0.112, 0.192, 0.306, 0.459, 0.631, 0.82, 0.907, 0.962, 0.989,
+    ]
+    const n = anchors.length
+    // Secant slopes (unit spacing, so d_k = y_{k+1} - y_k).
+    const d = new Array<number>(n - 1)
+    for (let k = 0; k < n - 1; k++) d[k] = anchors[k + 1] - anchors[k]
+    // Endpoint + interior tangents.
+    const m = new Array<number>(n)
+    m[0] = d[0]
+    m[n - 1] = d[n - 2]
+    for (let k = 1; k < n - 1; k++) m[k] = (d[k - 1] + d[k]) * 0.5
+    // Fritsch–Carlson monotonicity clamp.
+    for (let k = 0; k < n - 1; k++) {
+      if (d[k] === 0) {
+        m[k] = 0
+        m[k + 1] = 0
+        continue
+      }
+      const a = m[k] / d[k]
+      const b = m[k + 1] / d[k]
+      const s = a * a + b * b
+      if (s > 9) {
+        const tau = 3 / Math.sqrt(s)
+        m[k] = tau * a * d[k]
+        m[k + 1] = tau * b * d[k]
+      }
+    }
+    const W = Engine.FILMIC_LUT_WIDTH
+    const values = new Float32Array(W)
+    for (let j = 0; j < W; j++) {
+      const t = ((n - 1) * j) / (W - 1) // t ∈ [0, n-1]
+      const k = Math.min(Math.floor(t), n - 2)
+      const s = t - k // local param in [0,1], unit-spaced segment
+      const s2 = s * s
+      const s3 = s2 * s
+      // Hermite basis (h=1).
+      const h00 = 2 * s3 - 3 * s2 + 1
+      const h10 = s3 - 2 * s2 + s
+      const h01 = -2 * s3 + 3 * s2
+      const h11 = s3 - s2
+      values[j] = h00 * anchors[k] + h10 * m[k] + h01 * anchors[k + 1] + h11 * m[k + 1]
+    }
+
+    // f32 → f16 bits (same conversion as bakeBrdfLut).
+    const half = new Uint16Array(W)
+    const f32 = new Float32Array(1)
+    const u32 = new Uint32Array(f32.buffer)
+    for (let j = 0; j < W; j++) {
+      f32[0] = values[j]
+      const x = u32[0]
+      const sign = (x >>> 16) & 0x8000
+      const exp = ((x >>> 23) & 0xff) - 127 + 15
+      const mant = x & 0x7fffff
+      if (exp <= 0) {
+        half[j] = sign
+      } else if (exp >= 31) {
+        half[j] = sign | 0x7c00
+      } else {
+        half[j] = sign | (exp << 10) | (mant >>> 13)
+      }
+    }
+
+    this.filmicLutTexture = this.device.createTexture({
+      label: "Filmic tone LUT",
+      size: [W, 1],
+      format: "r16float",
+      usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
+    })
+    this.filmicLutView = this.filmicLutTexture.createView()
+    this.device.queue.writeTexture(
+      { texture: this.filmicLutTexture },
+      half,
+      { bytesPerRow: W * 2, rowsPerImage: 1 },
+      { width: W, height: 1, depthOrArrayLayers: 1 },
+    )
+  }
+
   private createRenderPipeline(config: {
     label: string
     layout: GPUPipelineLayout
@@ -1154,6 +1268,7 @@ export class Engine {
 
     // One-shot bake of Blender EEVEE's combined BRDF LUT (DFG + LTC packed rgba8unorm).
     this.bakeBrdfLut()
+    this.bakeFilmicLut()
 
     // Now that shadow resources exist, create the main per-frame bind group
     this.perFrameBindGroup = this.device.createBindGroup({
@@ -1436,6 +1551,8 @@ export class Engine {
         // Aux mask/alpha texture — composite reads .g to reconstruct the alpha that
         // used to live in the HDR target before the rg11b10ufloat switch.
         { binding: 4, visibility: GPUShaderStage.FRAGMENT, texture: {} },
+        // Filmic tone LUT (r16float, filterable) — sampled with the binding-2 sampler.
+        { binding: 5, visibility: GPUShaderStage.FRAGMENT, texture: {} },
       ],
     })
 
@@ -1463,6 +1580,31 @@ export class Engine {
     this.compositePipelineIdentity = makeCompositePipeline(false, "composite pipeline (gamma=1)")
     this.compositePipelineGamma = makeCompositePipeline(true, "composite pipeline (gamma!=1)")
 
+    // GPU vertex-morph compute pipeline (shared by all models; per-model bind groups).
+    // Bindings: 0-4 read-only storage (base pos, CSR rowStart/colMorph/colOffset, weights),
+    // 5 read-write storage (vertex buffer), 6 uniform (params).
+    const roStorage = { type: "read-only-storage" as const }
+    this.morphComputeBindGroupLayout = this.device.createBindGroupLayout({
+      label: "morph compute bind group layout",
+      entries: [
+        { binding: 0, visibility: GPUShaderStage.COMPUTE, buffer: roStorage },
+        { binding: 1, visibility: GPUShaderStage.COMPUTE, buffer: roStorage },
+        { binding: 2, visibility: GPUShaderStage.COMPUTE, buffer: roStorage },
+        { binding: 3, visibility: GPUShaderStage.COMPUTE, buffer: roStorage },
+        { binding: 4, visibility: GPUShaderStage.COMPUTE, buffer: roStorage },
+        { binding: 5, visibility: GPUShaderStage.COMPUTE, buffer: { type: "storage" } },
+        { binding: 6, visibility: GPUShaderStage.COMPUTE, buffer: { type: "uniform" } },
+      ],
+    })
+    this.morphComputePipeline = this.device.createComputePipeline({
+      label: "morph compute pipeline",
+      layout: this.device.createPipelineLayout({ bindGroupLayouts: [this.morphComputeBindGroupLayout] }),
+      compute: {
+        module: this.device.createShaderModule({ label: "morph compute shader", code: MORPH_COMPUTE_WGSL }),
+        entryPoint: "cs",
+      },
+    })
+
     this.bloomPassDescriptor = {
       label: "bloom pass",
       colorAttachments: [
@@ -1781,6 +1923,7 @@ export class Engine {
             { binding: 2, resource: this.bloomSampler },
             { binding: 3, resource: { buffer: this.compositeUniformBuffer } },
             { binding: 4, resource: this.maskResolveView },
+            { binding: 5, resource: this.filmicLutView },
           ],
         })
       }
@@ -2342,6 +2485,11 @@ export class Engine {
     this.ikEnabled = enabled
   }
 
+  // Toggle the GPU vertex-morph path. Only affects models loaded afterwards.
+  setGpuMorphsEnabled(enabled: boolean): void {
+    this.useGpuMorphs = enabled
+  }
+
   getIKEnabled(): boolean {
     return this.ikEnabled
   }
@@ -2372,7 +2520,23 @@ export class Engine {
   private updateInstances(deltaTime: number): void {
     this.forEachInstance((inst) => {
       const verticesChanged = inst.model.update(deltaTime, this.ikEnabled)
-      if (verticesChanged) inst.vertexBufferNeedsUpdate = true
+      if (inst.gpuMorph) {
+        // GPU path: on a weight change, upload effective weights (thresholding tiny values
+        // to 0 to match the CPU skip) and flag the compute dispatch for this frame.
+        if (inst.model.consumeMorphWeightsDirty()) {
+          const eff = inst.model.getEffectiveMorphWeights()
+          const wd = inst.gpuMorph.weightsData
+          const n = Math.min(wd.length, eff.length)
+          for (let i = 0; i < n; i++) {
+            const w = eff[i]
+            wd[i] = w < 0.0001 ? 0 : w
+          }
+          this.device.queue.writeBuffer(inst.gpuMorph.weightsBuffer, 0, wd as ArrayBufferView<ArrayBuffer>)
+          inst.gpuMorph.dispatchNeeded = true
+        }
+      } else if (verticesChanged) {
+        inst.vertexBufferNeedsUpdate = true
+      }
       if (inst.physics && this.physicsEnabled) {
         inst.physics.step(deltaTime, inst.model.getWorldMatrices(), inst.model.getBoneInverseBindMatrices())
       }
@@ -2381,12 +2545,52 @@ export class Engine {
   }
 
   private updateVertexBuffer(inst: ModelInstance): void {
+    // GPU-morph models never CPU-upload the vertex buffer after load — the compute pass
+    // owns the position slots. Ignore any stray dirty flag (e.g. from markVertexBufferDirty).
+    if (inst.gpuMorph) {
+      inst.vertexBufferNeedsUpdate = false
+      return
+    }
     const vertices = inst.model.getVertices()
     if (!vertices?.length) return
-    this.device.queue.writeBuffer(inst.vertexBuffer, 0, vertices)
+    // Vertex morphs touch only a subset of verts (typically the face), so upload just the
+    // changed [minVert, maxVert] slice when the model can report one; null = full upload.
+    const range = inst.model.consumeVertexUploadRange()
+    if (range) {
+      const STRIDE = 8 // floats per vertex (pos3 + normal3 + uv2)
+      const firstFloat = range.minVert * STRIDE
+      const floatLen = (range.maxVert - range.minVert + 1) * STRIDE
+      const byteOffset = firstFloat * 4
+      this.device.queue.writeBuffer(
+        inst.vertexBuffer,
+        byteOffset,
+        vertices.buffer,
+        vertices.byteOffset + byteOffset,
+        floatLen * 4,
+      )
+    } else {
+      this.device.queue.writeBuffer(inst.vertexBuffer, 0, vertices)
+    }
     inst.vertexBufferNeedsUpdate = false
   }
 
+  // One compute pass covering every model whose morph weights changed this frame.
+  private dispatchMorphCompute(encoder: GPUCommandEncoder): void {
+    let pass: GPUComputePassEncoder | null = null
+    for (const inst of this.modelInstances.values()) {
+      const gm = inst.gpuMorph
+      if (!gm || !gm.dispatchNeeded) continue
+      if (!pass) {
+        pass = encoder.beginComputePass({ label: "morph compute" })
+        pass.setPipeline(this.morphComputePipeline)
+      }
+      pass.setBindGroup(0, gm.bindGroup)
+      pass.dispatchWorkgroups(gm.workgroups)
+      gm.dispatchNeeded = false
+    }
+    if (pass) pass.end()
+  }
+
   private async setupModelInstance(
     name: string,
     model: Model,
@@ -2402,7 +2606,8 @@ export class Engine {
     const vertexBuffer = this.device.createBuffer({
       label: `${name}: vertex buffer`,
       size: vertices.byteLength,
-      usage: GPUBufferUsage.VERTEX | GPUBufferUsage.COPY_DST,
+      // STORAGE so the morph compute pass can write morphed positions in place.
+      usage: GPUBufferUsage.VERTEX | GPUBufferUsage.COPY_DST | GPUBufferUsage.STORAGE,
     })
     this.device.queue.writeBuffer(vertexBuffer, 0, vertices)
 
@@ -2473,6 +2678,8 @@ export class Engine {
 
     const gpuBuffers: GPUBuffer[] = [vertexBuffer, indexBuffer, jointsBuffer, weightsBuffer, skinMatrixBuffer]
 
+    const gpuMorph = this.createGpuMorph(name, model, vertexBuffer, gpuBuffers)
+
     const inst: ModelInstance = {
       name,
       model,
@@ -2495,11 +2702,83 @@ export class Engine {
       materialPresets: undefined,
       physics,
       vertexBufferNeedsUpdate: false,
+      gpuMorph,
     }
     await this.setupMaterialsForInstance(inst)
     this.modelInstances.set(name, inst)
   }
 
+  // Build the per-model GPU vertex-morph state. Returns null (and leaves the model on the
+  // CPU morph path) when the model has no vertex morphs. Created buffers are pushed into
+  // gpuBuffers so they're released with the instance.
+  private createGpuMorph(
+    name: string,
+    model: Model,
+    vertexBuffer: GPUBuffer,
+    gpuBuffers: GPUBuffer[],
+  ): GpuMorph | null {
+    if (!this.useGpuMorphs) return null
+    const data = model.buildMorphComputeData()
+    if (!data) return null
+
+    const RO = GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST
+    const mkStorage = (label: string, arr: Float32Array | Uint32Array): GPUBuffer => {
+      const buf = this.device.createBuffer({
+        label: `${name}: morph ${label}`,
+        size: Math.max(arr.byteLength, 4),
+        usage: RO,
+      })
+      this.device.queue.writeBuffer(buf, 0, arr as ArrayBufferView<ArrayBuffer>)
+      gpuBuffers.push(buf)
+      return buf
+    }
+
+    const baseBuf = mkStorage("basePositions", data.basePositions)
+    const rowBuf = mkStorage("rowStart", data.rowStart)
+    const colMorphBuf = mkStorage("colMorph", data.colMorph)
+    const colOffsetBuf = mkStorage("colOffset", data.colOffset)
+
+    // Weights are zero-initialized by WebGPU; the first weight change uploads real values.
+    const weightsBuffer = this.device.createBuffer({
+      label: `${name}: morph weights`,
+      size: Math.max(data.morphCount * 4, 4),
+      usage: RO,
+    })
+    gpuBuffers.push(weightsBuffer)
+
+    const paramsBuffer = this.device.createBuffer({
+      label: `${name}: morph params`,
+      size: 16,
+      usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST,
+    })
+    this.device.queue.writeBuffer(paramsBuffer, 0, new Uint32Array([data.vertexCount, 0, 0, 0]))
+    gpuBuffers.push(paramsBuffer)
+
+    const bindGroup = this.device.createBindGroup({
+      label: `${name}: morph compute bind group`,
+      layout: this.morphComputeBindGroupLayout,
+      entries: [
+        { binding: 0, resource: { buffer: baseBuf } },
+        { binding: 1, resource: { buffer: rowBuf } },
+        { binding: 2, resource: { buffer: colMorphBuf } },
+        { binding: 3, resource: { buffer: colOffsetBuf } },
+        { binding: 4, resource: { buffer: weightsBuffer } },
+        { binding: 5, resource: { buffer: vertexBuffer } },
+        { binding: 6, resource: { buffer: paramsBuffer } },
+      ],
+    })
+
+    model.enableGpuMorphs()
+
+    return {
+      bindGroup,
+      weightsBuffer,
+      weightsData: new Float32Array(data.morphCount),
+      workgroups: Math.ceil(data.vertexCount / 64),
+      dispatchNeeded: false, // vertex buffer already holds base; dispatch on first weight change
+    }
+  }
+
   private createGroundGeometry(width: number = 100, height: number = 100) {
     const halfWidth = width / 2
     const halfHeight = height / 2
@@ -3467,6 +3746,11 @@ export class Engine {
     this.updateShadowLightVP()
 
     const encoder = this.device.createCommandEncoder()
+
+    // GPU vertex morphs: write morphed positions into vertex buffers before any pass reads
+    // them. WebGPU inserts the storage→vertex barrier between this pass and the render passes.
+    if (hasModels) this.dispatchMorphCompute(encoder)
+
     if (hasModels) {
       const sp = encoder.beginRenderPass({
         colorAttachments: [],
@@ -3554,7 +3838,9 @@ export class Engine {
       this.resolvePickResult(pick.x / dpr, pick.y / dpr)
     }
 
-    this.updateStats(performance.now() - currentTime)
+    // Feed the true vsync-to-vsync interval (deltaTime, computed at frame start), not the
+    // CPU time spent in render() — that's what actually reflects perceived smoothness.
+    this.updateStats(deltaTime * 1000)
   }
 
   private drawInstanceShadow(sp: GPURenderPassEncoder, inst: ModelInstance): void {
@@ -3696,28 +3982,49 @@ export class Engine {
     })
   }
 
-  private updateStats(frameTime: number) {
-    // Simplified frame time tracking - rolling average with fixed window
-    const maxSamples = 60
-    this.frameTimeSum += frameTime
-    this.frameTimeCount++
-    if (this.frameTimeCount > maxSamples) {
-      // Maintain rolling window by subtracting oldest sample estimate
-      const avg = this.frameTimeSum / maxSamples
-      this.frameTimeSum -= avg
-      this.frameTimeCount = maxSamples
-    }
-    this.stats.frameTime = Math.round((this.frameTimeSum / this.frameTimeCount) * 100) / 100
+  // frameIntervalMs is the true vsync-to-vsync frame interval (render dt), NOT the CPU
+  // time spent in render() — the latter misses GPU cost and pacing, so it can read fast
+  // while the scene stutters. Metrics are derived from a ring buffer of these intervals.
+  private updateStats(frameIntervalMs: number) {
+    const w = Engine.STATS_WINDOW
+    this.frameIntervals[this.frameIntervalWrite] = frameIntervalMs
+    this.frameIntervalWrite = (this.frameIntervalWrite + 1) % w
+    if (this.frameIntervalFilled < w) this.frameIntervalFilled++
 
-    // FPS tracking
     const now = performance.now()
-    this.framesSinceLastUpdate++
-    const elapsed = now - this.lastFpsUpdate
+    if (now - this.lastStatsCompute < Engine.STATS_REFRESH_MS) return
+    this.lastStatsCompute = now
+
+    const n = this.frameIntervalFilled
+    if (n === 0) return
 
-    if (elapsed >= 1000) {
-      this.stats.fps = Math.round((this.framesSinceLastUpdate / elapsed) * 1000)
-      this.framesSinceLastUpdate = 0
-      this.lastFpsUpdate = now
+    let sum = 0
+    let max = 0
+    for (let i = 0; i < n; i++) {
+      const v = this.frameIntervals[i]
+      sum += v
+      if (v > max) max = v
     }
+    const mean = sum / n
+
+    let varSum = 0
+    for (let i = 0; i < n; i++) {
+      const d = this.frameIntervals[i] - mean
+      varSum += d * d
+    }
+    const stddev = Math.sqrt(varSum / n)
+
+    // 99th-percentile frame interval → "1% low" fps. TypedArray.sort is numeric.
+    const sorted = this.frameIntervals.slice(0, n).sort()
+    const p99 = sorted[Math.min(n - 1, Math.floor(n * 0.99))]
+
+    // fps from the MEAN interval is inherently bounded by the real refresh (a vsync-locked
+    // interval can't average below the refresh period), so this never reads above the
+    // monitor rate — fixing the old frame-count/window off-by-one (61 on 60Hz, 241 on 240Hz).
+    this.stats.fps = mean > 0 ? Math.round(1000 / mean) : 0
+    this.stats.frameTime = Math.round(mean * 100) / 100
+    this.stats.frameTimeMax = Math.round(max * 100) / 100
+    this.stats.fps1PercentLow = p99 > 0 ? Math.round(1000 / p99) : 0
+    this.stats.jitter = Math.round(stddev * 100) / 100
   }
 }

package/src/ik-solver.ts

@@ -86,6 +86,12 @@ const _ikMat: Float32Array[] = [
   new Float32Array(16), new Float32Array(16), new Float32Array(16), new Float32Array(16),
 ]
 
+// An IKChain is derived purely from static link topology (bone index + angle limits +
+// solve axis), which never changes at runtime. Build the chain array once per solver and
+// reuse it — avoids reallocating the array and re-running the per-link limit/axis setup
+// (IKChain ctor) on every solve() every frame.
+const _chainCache = new WeakMap<IKSolver, IKChain[]>()
+
 export class IKSolverSystem {
   private static readonly EPSILON = 1.0e-8
   private static readonly THRESHOLD = (88 * Math.PI) / 180
@@ -118,20 +124,21 @@ export class IKSolverSystem {
     const ikBoneIndex = solver.ikBoneIndex
     const targetBoneIndex = solver.targetBoneIndex
 
-    // Reset IK rotations
+    // Reset IK rotations (in place — same object is accumulated into during solve)
     for (const link of solver.links) {
       const chainInfo = ikChainInfo[link.boneIndex]
       if (chainInfo) {
-        chainInfo.ikRotation = new Quat(0, 0, 0, 1)
+        chainInfo.ikRotation.setXYZW(0, 0, 0, 1)
       }
     }
 
     if (this.getDistance(ikBoneIndex, targetBoneIndex, worldMatrices) < this.EPSILON) return
 
-    // Build IK chains
-    const chains: IKChain[] = []
-    for (const link of solver.links) {
-      chains.push(new IKChain(link.boneIndex, link))
+    // Build IK chains (cached per solver — static topology, see _chainCache)
+    let chains = _chainCache.get(solver)
+    if (chains === undefined) {
+      chains = solver.links.map((link) => new IKChain(link.boneIndex, link))
+      _chainCache.set(solver, chains)
     }
 
     // Update chain bones and target bone world matrices (initial state, no IK yet)
@@ -278,7 +285,7 @@ export class IKSolverSystem {
 
       if (chain.minimumAngle && chain.maximumAngle) {
         const localRot = localRotations[chainBoneIndex]
-        chainInfo.localRotation = localRot.clone()
+        chainInfo.localRotation.set(localRot)
 
         // combinedRot = chainInfo.ikRotation * localRot
         Quat.multiplyInto(chainInfo.ikRotation, localRot, _ikQuat[1])

package/src/math.ts

@@ -348,64 +348,54 @@ export class Mat4 {
 
   // Perspective matrix for LEFT-HANDED coordinate system (Z+ forward)
   // For left-handed: Z goes from 0 (near) to 1 (far), +Z is forward
-  static perspective(fov: number, aspect: number, near: number, far: number): Mat4 {
+  // Zero-alloc perspective into an existing column-major array (same values as perspective).
+  static perspectiveInto(out: Float32Array, fov: number, aspect: number, near: number, far: number): void {
     const f = 1.0 / Math.tan(fov / 2)
     const rangeInv = 1.0 / (far - near) // Positive for left-handed
+    out[0] = f / aspect; out[1] = 0; out[2] = 0; out[3] = 0
+    out[4] = 0; out[5] = f; out[6] = 0; out[7] = 0
+    out[8] = 0; out[9] = 0; out[10] = (far + near) * rangeInv; out[11] = 1 // Z+ forward (LH)
+    out[12] = 0; out[13] = 0; out[14] = -near * far * rangeInv * 2; out[15] = 0
+  }
 
-    return new Mat4(
-      new Float32Array([
-        f / aspect,
-        0,
-        0,
-        0,
-        0,
-        f,
-        0,
-        0,
-        0,
-        0,
-        (far + near) * rangeInv,
-        1, // Positive for left-handed (Z+ forward)
-        0,
-        0,
-        -near * far * rangeInv * 2, // Negated for left-handed
-        0,
-      ])
-    )
+  static perspective(fov: number, aspect: number, near: number, far: number): Mat4 {
+    const m = new Mat4(new Float32Array(16))
+    Mat4.perspectiveInto(m.values, fov, aspect, near, far)
+    return m
+  }
+
+  // Zero-alloc LH lookAt into an existing column-major array (scalar math, no Vec3 temps;
+  // identical result to lookAt: forward=norm(target-eye), right=norm(up×forward), up=norm(forward×right)).
+  static lookAtInto(
+    out: Float32Array,
+    ex: number, ey: number, ez: number,
+    tx: number, ty: number, tz: number,
+    ux: number, uy: number, uz: number
+  ): void {
+    // sqrt(dot) (not hypot) to match Vec3.length()/normalize() bit-for-bit.
+    let fx = tx - ex, fy = ty - ey, fz = tz - ez
+    const fl = Math.sqrt(fx * fx + fy * fy + fz * fz); const fi = fl > 0 ? 1 / fl : 0
+    fx *= fi; fy *= fi; fz *= fi
+    let rx = uy * fz - uz * fy, ry = uz * fx - ux * fz, rz = ux * fy - uy * fx
+    const rl = Math.sqrt(rx * rx + ry * ry + rz * rz); const ri = rl > 0 ? 1 / rl : 0
+    rx *= ri; ry *= ri; rz *= ri
+    let vx = fy * rz - fz * ry, vy = fz * rx - fx * rz, vz = fx * ry - fy * rx
+    const vl = Math.sqrt(vx * vx + vy * vy + vz * vz); const vi = vl > 0 ? 1 / vl : 0
+    vx *= vi; vy *= vi; vz *= vi
+    out[0] = rx; out[1] = vx; out[2] = fx; out[3] = 0
+    out[4] = ry; out[5] = vy; out[6] = fy; out[7] = 0
+    out[8] = rz; out[9] = vz; out[10] = fz; out[11] = 0
+    out[12] = -(rx * ex + ry * ey + rz * ez)
+    out[13] = -(vx * ex + vy * ey + vz * ez)
+    out[14] = -(fx * ex + fy * ey + fz * ez)
+    out[15] = 1
   }
 
   // LookAt matrix for LEFT-HANDED coordinate system (Z+ forward)
-  // For left-handed: camera looks along +Z direction
   static lookAt(eye: Vec3, target: Vec3, up: Vec3): Mat4 {
-    // In left-handed: forward = target - eye (Z+ direction)
-    // 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,
-        forward.x,
-        0,
-        right.y,
-        upVec.y,
-        forward.y,
-        0,
-        right.z,
-        upVec.z,
-        forward.z,
-        0,
-        -right.dot(eye),
-        -upVec.dot(eye),
-        -forward.dot(eye),
-        1,
-      ])
-    )
+    const m = new Mat4(new Float32Array(16))
+    Mat4.lookAtInto(m.values, eye.x, eye.y, eye.z, target.x, target.y, target.z, up.x, up.y, up.z)
+    return m
   }
 
   // LH ortho, NDC depth 0=near 1=far