reze-engine 0.15.0 → 0.16.0

package/src/physics/contact.ts

@@ -37,27 +37,49 @@ export interface Contact {
   appliedNormalImpulse: number
   appliedFrictionImpulse1: number
   appliedFrictionImpulse2: number
+
+  // Per-substep cache. Written by the solver's setup pass, read by iter.
+  // Normal row:
+  cAxN: number; cAyN: number; cAzN: number   // rA × n
+  cBxN: number; cByN: number; cBzN: number   // rB × n
+  jacInvN: number
+  bounceVel: number   // restitution reference, captured at setup from initial relVelN
+  // Friction tangent 1:
+  t1x: number; t1y: number; t1z: number
+  cAxT1: number; cAyT1: number; cAzT1: number
+  cBxT1: number; cByT1: number; cBzT1: number
+  jacInvT1: number
+  // Friction tangent 2:
+  t2x: number; t2y: number; t2z: number
+  cAxT2: number; cAyT2: number; cAzT2: number
+  cBxT2: number; cByT2: number; cBzT2: number
+  jacInvT2: number
 }
 
 function makeContact(): Contact {
   return {
-    bodyA: 0,
-    bodyB: 0,
-    rAx: 0,
-    rAy: 0,
-    rAz: 0,
-    rBx: 0,
-    rBy: 0,
-    rBz: 0,
-    nx: 0,
-    ny: 0,
-    nz: 0,
+    bodyA: 0, bodyB: 0,
+    rAx: 0, rAy: 0, rAz: 0,
+    rBx: 0, rBy: 0, rBz: 0,
+    nx: 0, ny: 0, nz: 0,
     depth: 0,
     friction: 0,
     restitution: 0,
     appliedNormalImpulse: 0,
     appliedFrictionImpulse1: 0,
     appliedFrictionImpulse2: 0,
+    cAxN: 0, cAyN: 0, cAzN: 0,
+    cBxN: 0, cByN: 0, cBzN: 0,
+    jacInvN: 0,
+    bounceVel: 0,
+    t1x: 0, t1y: 0, t1z: 0,
+    cAxT1: 0, cAyT1: 0, cAzT1: 0,
+    cBxT1: 0, cByT1: 0, cBzT1: 0,
+    jacInvT1: 0,
+    t2x: 0, t2y: 0, t2z: 0,
+    cAxT2: 0, cAyT2: 0, cAzT2: 0,
+    cBxT2: 0, cByT2: 0, cBzT2: 0,
+    jacInvT2: 0,
   }
 }
 
@@ -958,26 +980,17 @@ function flipLastNormal(pool: ContactPool): void {
   c.nz = -c.nz
 }
 
-// O(N²) AABB pair test. For 30–100 PMX bodies that's <5000 checks per
-// step; SAP / dynamic AABB tree pay off above ~500 bodies. The pair filter
-// uses the AND form `(maskA & groupB) && (maskB & groupA)` — both sides
-// must agree, which is what PMX rigs are tuned against.
+// Iterate the prebuilt candidate-pair list and AABB-test each pair. The
+// static-static and group/mask filters were applied once at construction —
+// see RigidBodyStore.getCollisionPairs. SAP / dynamic AABB tree pay off
+// above ~500 bodies; below that this flat sweep wins on cache locality.
 export function findContacts(store: RigidBodyStore, pool: ContactPool): void {
   store.updateAabbs()
-  const N = store.count
-  const invMass = store.invMass
-  const group = store.collisionGroup
-  const mask = store.willCollideMask
-
-  for (let i = 0; i < N; i++) {
-    const gi = group[i]
-    const mi = mask[i]
-    const dynA = invMass[i] > 0
-    for (let j = i + 1; j < N; j++) {
-      if (!dynA && invMass[j] === 0) continue // both static — no resolution
-      if ((mi & group[j]) === 0 || (mask[j] & gi) === 0) continue
-      if (!aabbOverlap(store, i, j)) continue
-      generateContacts(store, i, j, pool)
-    }
+  const pairs = store.getCollisionPairs()
+  for (let p = 0; p < pairs.length; p += 2) {
+    const i = pairs[p]
+    const j = pairs[p + 1]
+    if (!aabbOverlap(store, i, j)) continue
+    generateContacts(store, i, j, pool)
   }
 }

package/src/physics/physics.ts

@@ -21,11 +21,16 @@ export class RezePhysics {
   private constraints: SixDofSpringConstraint[]
   private contacts: ContactPool
   private firstFrame = true
-  // Fixed-timestep accumulator: physics runs at 75 Hz regardless of render
-  // rate, so spring impulse, damping, and integration are deterministic.
   private timeAccum = 0
-  private readonly fixedTimeStep = 1 / 75
-  private readonly maxSubSteps = 10
+  private readonly fixedTimeStep = 1 / 60
+  private readonly maxSubSteps = 6
+
+  // Fixed-timestep render interpolation ("Fix Your Timestep"): the dynamic body pose is
+  // rendered as lerp(prev, curr, alpha) between the last two completed substeps, where
+  // alpha = leftover accumulator / fixedTimeStep. Removes the temporal aliasing that shows
+  // as hair/cloth judder when the render rate doesn't line up with the 60Hz physics step.
+  private prevPositions: Float32Array
+  private prevOrientations: Float32Array
 
   constructor(rigidbodies: Rigidbody[], joints: Joint[] = []) {
     this.rigidbodies = rigidbodies
@@ -34,6 +39,14 @@ export class RezePhysics {
     this.world = new World(new Vec3(0, -98, 0))
     this.constraints = buildConstraints(rigidbodies, joints)
     this.contacts = new ContactPool()
+    this.prevPositions = new Float32Array(this.store.count * 3)
+    this.prevOrientations = new Float32Array(this.store.count * 4)
+  }
+
+  // Snapshot the current body pose as the interpolation "previous" state.
+  private savePrevState(): void {
+    this.prevPositions.set(this.store.positions)
+    this.prevOrientations.set(this.store.orientations)
   }
 
   setGravity(gravity: Vec3): void {
@@ -72,6 +85,8 @@ export class RezePhysics {
   reset(boneWorldMatrices: Mat4[]): void {
     if (this.firstFrame) return
     this.snapBodiesToBones(boneWorldMatrices)
+    this.savePrevState() // prev == curr after a snap, so no interpolation jump
+    this.timeAccum = 0
   }
 
   step(dt: number, boneWorldMatrices: Mat4[], boneInverseBindMatrices: Float32Array): void {
@@ -80,6 +95,7 @@ export class RezePhysics {
       // Start at current bone pose, not the PMX bind pose, so animations
       // that skip frame 0 don't pop bodies on first step.
       this.snapBodiesToBones(boneWorldMatrices)
+      this.savePrevState()
       this.firstFrame = false
     }
 
@@ -89,17 +105,21 @@ export class RezePhysics {
     this.syncFromBones(boneWorldMatrices, dt)
 
     // Fixed-timestep substeps. The maxSubSteps cap prevents runaway after
-    // a long stall (tab backgrounded, etc.).
+    // a long stall (tab backgrounded, etc.). Snapshot the pose before each step so
+    // after the loop prevState is one substep behind the live (current) state.
     this.timeAccum += dt
     let sub = 0
     while (this.timeAccum >= this.fixedTimeStep && sub < this.maxSubSteps) {
+      this.savePrevState()
       this.world.step(this.store, this.constraints, this.contacts, this.fixedTimeStep)
       this.timeAccum -= this.fixedTimeStep
       sub++
     }
     if (sub === this.maxSubSteps) this.timeAccum = 0
 
-    this.applyDynamicsToBones(boneWorldMatrices)
+    // Fraction into the next (not-yet-taken) step; always in [0, 1).
+    const alpha = this.fixedTimeStep > 0 ? this.timeAccum / this.fixedTimeStep : 0
+    this.applyDynamicsToBones(boneWorldMatrices, alpha)
   }
 
   // Snap all bone-bound bodies to boneWorld × bodyOffset, zero velocities.
@@ -219,13 +239,18 @@ export class RezePhysics {
 
   // Dynamic bodies write their transform back to the bone matrix:
   //   boneWorld = bodyWorld × bodyOffsetInverse.
-  private applyDynamicsToBones(boneWorldMatrices: Mat4[]): void {
+  // The body pose is the render-interpolated pose between the previous and current
+  // substep states (alpha = fraction into the next step), which removes fixed-step judder.
+  private applyDynamicsToBones(boneWorldMatrices: Mat4[], alpha: number): void {
     const N = this.store.count
     const inv = this.store.bodyOffsetInverse
     const positions = this.store.positions
     const orientations = this.store.orientations
+    const prevPos = this.prevPositions
+    const prevOri = this.prevOrientations
     const types = this.store.type
     const boneIdx = this.store.boneIndex
+    const oneMinus = 1 - alpha
 
     for (let i = 0; i < N; i++) {
       if (types[i] !== RigidbodyType.Dynamic) continue
@@ -234,16 +259,32 @@ export class RezePhysics {
 
       const i3 = i * 3
       const i4 = i * 4
-      Mat4.fromPositionRotationInto(
-        positions[i3 + 0],
-        positions[i3 + 1],
-        positions[i3 + 2],
-        orientations[i4 + 0],
-        orientations[i4 + 1],
-        orientations[i4 + 2],
-        orientations[i4 + 3],
-        _bodyMat,
-      )
+
+      // Position: straight lerp.
+      const px = prevPos[i3 + 0] * oneMinus + positions[i3 + 0] * alpha
+      const py = prevPos[i3 + 1] * oneMinus + positions[i3 + 1] * alpha
+      const pz = prevPos[i3 + 2] * oneMinus + positions[i3 + 2] * alpha
+
+      // Orientation: shortest-arc nlerp (bodies rotate little per fixed step, so nlerp
+      // tracks slerp closely and avoids the trig).
+      const ax = prevOri[i4 + 0], ay = prevOri[i4 + 1], az = prevOri[i4 + 2], aw = prevOri[i4 + 3]
+      let bx = orientations[i4 + 0], by = orientations[i4 + 1], bz = orientations[i4 + 2], bw = orientations[i4 + 3]
+      if (ax * bx + ay * by + az * bz + aw * bw < 0) {
+        bx = -bx; by = -by; bz = -bz; bw = -bw
+      }
+      let qx = ax * oneMinus + bx * alpha
+      let qy = ay * oneMinus + by * alpha
+      let qz = az * oneMinus + bz * alpha
+      let qw = aw * oneMinus + bw * alpha
+      const ql = Math.sqrt(qx * qx + qy * qy + qz * qz + qw * qw)
+      if (ql > 0) {
+        const invL = 1 / ql
+        qx *= invL; qy *= invL; qz *= invL; qw *= invL
+      } else {
+        qx = 0; qy = 0; qz = 0; qw = 1
+      }
+
+      Mat4.fromPositionRotationInto(px, py, pz, qx, qy, qz, qw, _bodyMat)
       Mat4.multiplyArrays(_bodyMat, 0, inv, i * 16, _boneMat, 0)
 
       // Sanity gate against NaN / extreme values — silently drop the update.