reze-engine 0.15.0 → 0.16.0

package/dist/physics/contact.js

@@ -14,23 +14,28 @@ import { RigidbodyShape } from "./types";
 export const CONTACT_MARGIN = 0.04;
 function makeContact() {
     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,
     };
 }
 // Pool of reusable Contact objects.
@@ -701,28 +706,18 @@ function flipLastNormal(pool) {
     c.ny = -c.ny;
     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, pool) {
     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/dist/physics/physics.d.ts

@@ -12,7 +12,10 @@ export declare class RezePhysics {
     private timeAccum;
     private readonly fixedTimeStep;
     private readonly maxSubSteps;
+    private prevPositions;
+    private prevOrientations;
     constructor(rigidbodies: Rigidbody[], joints?: Joint[]);
+    private savePrevState;
     setGravity(gravity: Vec3): void;
     getGravity(): Vec3;
     getRigidbodies(): Rigidbody[];

package/dist/physics/physics.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"physics.d.ts","sourceRoot":"","sources":["../../src/physics/physics.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,SAAS,CAAA;AAC1C,OAAO,KAAK,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,SAAS,CAAA;AAE/C,OAAO,EAAE,cAAc,EAAE,MAAM,QAAQ,CAAA;AAYvC,qBAAa,WAAW;IACtB,OAAO,CAAC,WAAW,CAAa;IAChC,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,KAAK,CAAgB;IAC7B,OAAO,CAAC,KAAK,CAAO;IACpB,OAAO,CAAC,WAAW,CAA0B;IAC7C,OAAO,CAAC,QAAQ,CAAa;IAC7B,OAAO,CAAC,UAAU,CAAO;IAGzB,OAAO,CAAC,SAAS,CAAI;IACrB,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAS;IACvC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAK;gBAErB,WAAW,EAAE,SAAS,EAAE,EAAE,MAAM,GAAE,KAAK,EAAO;IAS1D,UAAU,CAAC,OAAO,EAAE,IAAI,GAAG,IAAI;IAG/B,UAAU,IAAI,IAAI;IAGlB,cAAc,IAAI,SAAS,EAAE;IAG7B,SAAS,IAAI,KAAK,EAAE;IAGpB,QAAQ,IAAI,cAAc;IAI1B,sBAAsB,IAAI,KAAK,CAAC;QAAE,QAAQ,EAAE,IAAI,CAAC;QAAC,QAAQ,EAAE,IAAI,CAAA;KAAE,CAAC;IAiBnE,KAAK,CAAC,iBAAiB,EAAE,IAAI,EAAE,GAAG,IAAI;IAKtC,IAAI,CAAC,EAAE,EAAE,MAAM,EAAE,iBAAiB,EAAE,IAAI,EAAE,EAAE,uBAAuB,EAAE,YAAY,GAAG,IAAI;IA6BxF,OAAO,CAAC,iBAAiB;IAuCzB,OAAO,CAAC,aAAa;IA6ErB,OAAO,CAAC,oBAAoB;CAiC7B"}
+{"version":3,"file":"physics.d.ts","sourceRoot":"","sources":["../../src/physics/physics.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,SAAS,CAAA;AAC1C,OAAO,KAAK,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,SAAS,CAAA;AAE/C,OAAO,EAAE,cAAc,EAAE,MAAM,QAAQ,CAAA;AAYvC,qBAAa,WAAW;IACtB,OAAO,CAAC,WAAW,CAAa;IAChC,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,KAAK,CAAgB;IAC7B,OAAO,CAAC,KAAK,CAAO;IACpB,OAAO,CAAC,WAAW,CAA0B;IAC7C,OAAO,CAAC,QAAQ,CAAa;IAC7B,OAAO,CAAC,UAAU,CAAO;IACzB,OAAO,CAAC,SAAS,CAAI;IACrB,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAS;IACvC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAI;IAMhC,OAAO,CAAC,aAAa,CAAc;IACnC,OAAO,CAAC,gBAAgB,CAAc;gBAE1B,WAAW,EAAE,SAAS,EAAE,EAAE,MAAM,GAAE,KAAK,EAAO;IAY1D,OAAO,CAAC,aAAa;IAKrB,UAAU,CAAC,OAAO,EAAE,IAAI,GAAG,IAAI;IAG/B,UAAU,IAAI,IAAI;IAGlB,cAAc,IAAI,SAAS,EAAE;IAG7B,SAAS,IAAI,KAAK,EAAE;IAGpB,QAAQ,IAAI,cAAc;IAI1B,sBAAsB,IAAI,KAAK,CAAC;QAAE,QAAQ,EAAE,IAAI,CAAC;QAAC,QAAQ,EAAE,IAAI,CAAA;KAAE,CAAC;IAiBnE,KAAK,CAAC,iBAAiB,EAAE,IAAI,EAAE,GAAG,IAAI;IAOtC,IAAI,CAAC,EAAE,EAAE,MAAM,EAAE,iBAAiB,EAAE,IAAI,EAAE,EAAE,uBAAuB,EAAE,YAAY,GAAG,IAAI;IAkCxF,OAAO,CAAC,iBAAiB;IAuCzB,OAAO,CAAC,aAAa;IA+ErB,OAAO,CAAC,oBAAoB;CAoD7B"}

package/dist/physics/physics.js

@@ -13,17 +13,22 @@ const _scratchQuat = new Quat(0, 0, 0, 1);
 export class RezePhysics {
     constructor(rigidbodies, joints = []) {
         this.firstFrame = true;
-        // Fixed-timestep accumulator: physics runs at 75 Hz regardless of render
-        // rate, so spring impulse, damping, and integration are deterministic.
         this.timeAccum = 0;
-        this.fixedTimeStep = 1 / 75;
-        this.maxSubSteps = 10;
+        this.fixedTimeStep = 1 / 60;
+        this.maxSubSteps = 6;
         this.rigidbodies = rigidbodies;
         this.joints = joints;
         this.store = new RigidBodyStore(rigidbodies);
         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.
+    savePrevState() {
+        this.prevPositions.set(this.store.positions);
+        this.prevOrientations.set(this.store.orientations);
     }
     setGravity(gravity) {
         this.world.setGravity(gravity);
@@ -60,6 +65,8 @@ export class RezePhysics {
         if (this.firstFrame)
             return;
         this.snapBodiesToBones(boneWorldMatrices);
+        this.savePrevState(); // prev == curr after a snap, so no interpolation jump
+        this.timeAccum = 0;
     }
     step(dt, boneWorldMatrices, boneInverseBindMatrices) {
         if (this.firstFrame) {
@@ -67,6 +74,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;
         }
         // Sync once per render frame; kinematic targets don't change between
@@ -74,17 +82,21 @@ export class RezePhysics {
         // bone-pose delta so joints feel the kinematic motion.
         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.
     snapBodiesToBones(boneWorldMatrices) {
@@ -185,13 +197,18 @@ export class RezePhysics {
     }
     // Dynamic bodies write their transform back to the bone matrix:
     //   boneWorld = bodyWorld × bodyOffsetInverse.
-    applyDynamicsToBones(boneWorldMatrices) {
+    // 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.
+    applyDynamicsToBones(boneWorldMatrices, alpha) {
         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;
@@ -200,7 +217,39 @@ export class RezePhysics {
                 continue;
             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.
             if (Number.isFinite(_boneMat[0]) && Math.abs(_boneMat[0]) < 1e6) {

package/dist/physics/profile.d.ts

@@ -0,0 +1,18 @@
+declare class PhysicsProfiler {
+    enabled: boolean;
+    private sums;
+    private counts;
+    begin(): number;
+    end(label: string, t0: number): void;
+    record(label: string, ms: number): void;
+    snapshot(): Record<string, {
+        avgMs: number;
+        calls: number;
+        totalMs: number;
+    }>;
+    reset(): void;
+}
+export declare const profiler: PhysicsProfiler;
+export type ProfileSnapshot = ReturnType<PhysicsProfiler["snapshot"]>;
+export {};
+//# sourceMappingURL=profile.d.ts.map

package/dist/physics/profile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"profile.d.ts","sourceRoot":"","sources":["../../src/physics/profile.ts"],"names":[],"mappings":"AAIA,cAAM,eAAe;IACnB,OAAO,UAAQ;IACf,OAAO,CAAC,IAAI,CAA8C;IAC1D,OAAO,CAAC,MAAM,CAA8C;IAE5D,KAAK,IAAI,MAAM;IAIf,GAAG,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,IAAI;IASpC,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,IAAI;IAQvC,QAAQ,IAAI,MAAM,CAAC,MAAM,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC;IAU7E,KAAK,IAAI,IAAI;CAId;AAED,eAAO,MAAM,QAAQ,iBAAwB,CAAA;AAC7C,MAAM,MAAM,eAAe,GAAG,UAAU,CAAC,eAAe,CAAC,UAAU,CAAC,CAAC,CAAA"}

package/dist/physics/profile.js

@@ -0,0 +1,44 @@
+// Per-phase wall-clock accumulator. Off by default — when `enabled` is false,
+// begin()/end() short-circuit so production has zero overhead. Toggle via
+// `RezePhysics.setProfileEnabled(true)` and read with `getProfile()`.
+class PhysicsProfiler {
+    constructor() {
+        this.enabled = false;
+        this.sums = Object.create(null);
+        this.counts = Object.create(null);
+    }
+    begin() {
+        return this.enabled ? performance.now() : 0;
+    }
+    end(label, t0) {
+        if (!this.enabled)
+            return;
+        const dt = performance.now() - t0;
+        this.sums[label] = (this.sums[label] ?? 0) + dt;
+        this.counts[label] = (this.counts[label] ?? 0) + 1;
+    }
+    // Direct accumulator for durations not measured via begin()/end() — used by
+    // GPU timestamp readback, which arrives async after the frame has ended.
+    record(label, ms) {
+        if (!this.enabled)
+            return;
+        this.sums[label] = (this.sums[label] ?? 0) + ms;
+        this.counts[label] = (this.counts[label] ?? 0) + 1;
+    }
+    // Snapshot since last reset(). avgMs is per call; totalMs is the cumulative
+    // window cost — divide by elapsed wall time to get a "% of frame budget".
+    snapshot() {
+        const out = {};
+        for (const k in this.sums) {
+            const total = this.sums[k];
+            const calls = this.counts[k];
+            out[k] = { avgMs: calls > 0 ? total / calls : 0, calls, totalMs: total };
+        }
+        return out;
+    }
+    reset() {
+        this.sums = Object.create(null);
+        this.counts = Object.create(null);
+    }
+}
+export const profiler = new PhysicsProfiler();

package/dist/physics/solver.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"solver.d.ts","sourceRoot":"","sources":["../../src/physics/solver.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,QAAQ,CAAA;AAC5C,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,cAAc,CAAA;AAE1D,OAAO,KAAK,EAAW,WAAW,EAAE,MAAM,WAAW,CAAA;AAgBrD,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,cAAc,EACrB,WAAW,EAAE,sBAAsB,EAAE,EACrC,QAAQ,EAAE,WAAW,EACrB,EAAE,EAAE,MAAM,EACV,UAAU,EAAE,MAAM,GACjB,IAAI,CAyNN"}
+{"version":3,"file":"solver.d.ts","sourceRoot":"","sources":["../../src/physics/solver.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,QAAQ,CAAA;AAC5C,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,cAAc,CAAA;AAE1D,OAAO,KAAK,EAAW,WAAW,EAAE,MAAM,WAAW,CAAA;AAWrD,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,cAAc,EACrB,WAAW,EAAE,sBAAsB,EAAE,EACrC,QAAQ,EAAE,WAAW,EACrB,EAAE,EAAE,MAAM,EACV,UAAU,EAAE,MAAM,GACjB,IAAI,CAyBN"}