@woosh/meep-engine 2.155.0 → 2.157.0

package/src/engine/physics/body/SolverBodyState.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SolverBodyState.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/body/SolverBodyState.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoDG;AAEH,+CAA+C;AAC/C,6BAA8B;AAC9B,oFAAoF;AACpF,4BAA6B;AAC7B,4BAA6B;AAC7B,4BAA6B;AAC7B,oFAAoF;AACpF,uBAAwB;AACxB,uBAAwB;AACxB,uBAAwB;AACxB,uBAAwB;AACxB,kCAAkC;AAClC,yBAA0B;AAC1B,yBAA0B;AAC1B,0BAA2B;AAC3B,mCAAmC;AACnC,0BAA2B;AAC3B,0BAA2B;AAC3B,0BAA2B;AAE3B,wBAAwB;AACxB,4BAA6B;AAE7B;IACI,uCAoCC;IAjCG;;;OAGG;IACH,MAFU,YAAY,CAEwB;IAE9C;;;;;OAKG;IACH,gBAAkC;IAElC;;;;OAIG;IACH,mBAAsC;IAEtC,eAAe;IACf,yBAAyB;IAEzB;;;;OAIG;IACH,cAAc;IAEd,eAAe;IACf,mBAAqB;IAGzB;;;OAGG;IACH,6BAEC;IAED;;;;;OAKG;IACH,WAFW,MAAM,QAiBhB;IAED;;;;;;;;OAQG;IACH,YAJW,MAAM,6CA8ChB;IAED;;;;;;;OAOG;IACH,gBAFW,WAAW,QAoBrB;IAED;;;OAGG;IACH,eAeC;CACJ"}
+{"version":3,"file":"SolverBodyState.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/body/SolverBodyState.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoDG;AAEH,+CAA+C;AAC/C,6BAA8B;AAC9B,oFAAoF;AACpF,4BAA6B;AAC7B,4BAA6B;AAC7B,4BAA6B;AAC7B,oFAAoF;AACpF,uBAAwB;AACxB,uBAAwB;AACxB,uBAAwB;AACxB,uBAAwB;AACxB,kCAAkC;AAClC,yBAA0B;AAC1B,yBAA0B;AAC1B,0BAA2B;AAC3B,mCAAmC;AACnC,0BAA2B;AAC3B,0BAA2B;AAC3B,0BAA2B;AAE3B,wBAAwB;AACxB,4BAA6B;AAE7B;IACI,uCAoCC;IAjCG;;;OAGG;IACH,MAFU,YAAY,CAEwB;IAE9C;;;;;OAKG;IACH,gBAAkC;IAElC;;;;OAIG;IACH,mBAAsC;IAEtC,eAAe;IACf,yBAAyB;IAEzB;;;;OAIG;IACH,cAAc;IAEd,eAAe;IACf,mBAAqB;IAGzB;;;OAGG;IACH,6BAEC;IAED;;;;;OAKG;IACH,WAFW,MAAM,QAiBhB;IAED;;;;;;;;OAQG;IACH,YAJW,MAAM,6CAsDhB;IAED;;;;;;;OAOG;IACH,gBAFW,WAAW,QAoBrB;IAED;;;OAGG;IACH,eAeC;CACJ"}

package/src/engine/physics/body/SolverBodyState.js

@@ -1,5 +1,6 @@
 import { ceilPowerOfTwo } from "../../../core/binary/operations/ceilPowerOfTwo.js";
 import { BodyKind } from "../ecs/BodyKind.js";
+import { RigidBodyFlags } from "../ecs/RigidBodyFlags.js";
 
 /**
  * # SolverBodyState — data-oriented mirror of the per-body solver hot state
@@ -171,10 +172,18 @@ export class SolverBodyState {
         const dynamic = rb.kind === BodyKind.Dynamic;
         if (dynamic) {
             d[base + SBS_INV_MASS] = rb.mass > 0 ? 1 / rb.mass : 0;
+            // LockRot*: a locked BODY-LOCAL angular DOF gathers zero inverse
+            // inertia, so no contact or joint impulse can rotate the body
+            // about that local axis (world_inverse_inertia_apply rotates this
+            // diagonal, so the lock follows the body's orientation). Note the
+            // flag does not cancel a PRE-EXISTING spin about the axis — no
+            // impulse can change it any more; callers zero angularVelocity
+            // themselves when locking a body mid-spin.
             const ii = rb.inverseInertiaLocal;
-            d[base + SBS_INV_I_X] = ii.x;
-            d[base + SBS_INV_I_Y] = ii.y;
-            d[base + SBS_INV_I_Z] = ii.z;
+            const flags = rb.flags;
+            d[base + SBS_INV_I_X] = (flags & RigidBodyFlags.LockRotX) !== 0 ? 0 : ii.x;
+            d[base + SBS_INV_I_Y] = (flags & RigidBodyFlags.LockRotY) !== 0 ? 0 : ii.y;
+            d[base + SBS_INV_I_Z] = (flags & RigidBodyFlags.LockRotZ) !== 0 ? 0 : ii.z;
         } else {
             // Static / Kinematic: immovable to the solver — no inverse mass,
             // no inverse inertia (mirrors the object path's `kind` guards).

package/src/engine/physics/broadphase/compute_fat_world_aabb.d.ts

@@ -1,7 +1,32 @@
 /**
- * Compute the inflated world AABB of a shape under a pose, padded by both a
- * constant slack and a velocity-proportional swept extent. The output is the
- * thing to hand to `BVH#node_move_aabb`.
+ * Tight world AABB of a shape under a pose — the containment probe for the
+ * stage-2 refit skip, and the base box {@link fatten_world_aabb} pads.
+ *
+ * @param {number[]|Float32Array|Float64Array} result
+ * @param {number} result_offset
+ * @param {AbstractShape3D} shape
+ * @param {Transform} transform
+ */
+export function compute_world_aabb(result: number[] | Float32Array | Float64Array, result_offset: number, shape: AbstractShape3D, transform: Transform): void;
+/**
+ * Inflate a world AABB in place: a symmetric constant slack plus a
+ * DIRECTIONAL velocity pad — each axis extends only toward where the body is
+ * heading (`lower += min(v·dt·k, 0)`, `upper += max(v·dt·k, 0)`). A symmetric
+ * velocity pad swept up to ~8× the volume a moving body can actually reach
+ * this step, manufacturing false broadphase pairs at speed for nothing.
+ *
+ * @param {number[]|Float32Array|Float64Array} aabb inflated in place
+ * @param {number} offset
+ * @param {number} vx world linear velocity x
+ * @param {number} vy world linear velocity y
+ * @param {number} vz world linear velocity z
+ * @param {number} dt step size
+ */
+export function fatten_world_aabb(aabb: number[] | Float32Array | Float64Array, offset: number, vx: number, vy: number, vz: number, dt: number): void;
+/**
+ * Compute the inflated world AABB of a shape under a pose, padded by a
+ * symmetric constant slack and a directional velocity-proportional swept
+ * extent. The output is the thing to hand to `BVH#node_move_aabb`.
  *
  * @param {number[]|Float32Array|Float64Array} result
  * @param {number} result_offset

package/src/engine/physics/broadphase/compute_fat_world_aabb.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"compute_fat_world_aabb.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/broadphase/compute_fat_world_aabb.js"],"names":[],"mappings":"AAmBA;;;;;;;;;;;;;GAaG;AACH,+CATW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,iBAClC,MAAM,oDAGN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QA6BhB"}
+{"version":3,"file":"compute_fat_world_aabb.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/broadphase/compute_fat_world_aabb.js"],"names":[],"mappings":"AAuBA;;;;;;;;GAQG;AACH,2CALW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,iBAClC,MAAM,sDAiBhB;AAED;;;;;;;;;;;;;GAaG;AACH,wCAPW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,UAClC,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAchB;AAED;;;;;;;;;;;;;GAaG;AACH,+CATW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,iBAClC,MAAM,oDAGN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAShB"}

package/src/engine/physics/broadphase/compute_fat_world_aabb.js

@@ -4,38 +4,33 @@ const scratch_local = new Float64Array(6);
 
 /**
  * Constant inflation applied to a world AABB so a small motion doesn't churn
- * the broadphase. Tuned to Box2D / Bullet conventions.
+ * the broadphase. Tuned to Box2D / Bullet conventions. Symmetric: jitter has
+ * no preferred direction.
  * @type {number}
  */
 const FAT_LINEAR = 0.05;
 
 /**
- * Per-second-of-velocity inflation. Two seconds of motion is a generous look-ahead
- * — `node_move_aabb` only re-inserts when the inflated AABB no longer encloses
- * the actual one, so this is a hint, not an upper bound.
+ * Per-second-of-velocity inflation. Two seconds of motion is a generous
+ * look-ahead; the refit skip at the call site (PhysicsSystem stage 2 keeps a
+ * leaf's stored fat AABB while the body's tight AABB stays inside it) is what
+ * turns the look-ahead into amortised refit savings, so this is a hint, not
+ * an upper bound. Applied DIRECTIONALLY — only ahead of the velocity; the
+ * swept volume of this step's motion has no trailing side.
  * @type {number}
  */
 const FAT_VELOCITY_MULTIPLIER = 2;
 
 /**
- * Compute the inflated world AABB of a shape under a pose, padded by both a
- * constant slack and a velocity-proportional swept extent. The output is the
- * thing to hand to `BVH#node_move_aabb`.
+ * Tight world AABB of a shape under a pose — the containment probe for the
+ * stage-2 refit skip, and the base box {@link fatten_world_aabb} pads.
  *
  * @param {number[]|Float32Array|Float64Array} result
  * @param {number} result_offset
  * @param {AbstractShape3D} shape
  * @param {Transform} transform
- * @param {number} vx world linear velocity x
- * @param {number} vy world linear velocity y
- * @param {number} vz world linear velocity z
- * @param {number} dt step size
  */
-export function compute_fat_world_aabb(
-    result, result_offset,
-    shape, transform,
-    vx, vy, vz, dt
-) {
+export function compute_world_aabb(result, result_offset, shape, transform) {
     shape.compute_bounding_box(scratch_local);
 
     const p = transform.position;
@@ -48,14 +43,55 @@ export function compute_fat_world_aabb(
         p.x, p.y, p.z,
         q.x, q.y, q.z, q.w
     );
+}
 
-    const speed = Math.sqrt(vx * vx + vy * vy + vz * vz);
-    const pad = FAT_LINEAR + FAT_VELOCITY_MULTIPLIER * speed * dt;
+/**
+ * Inflate a world AABB in place: a symmetric constant slack plus a
+ * DIRECTIONAL velocity pad — each axis extends only toward where the body is
+ * heading (`lower += min(v·dt·k, 0)`, `upper += max(v·dt·k, 0)`). A symmetric
+ * velocity pad swept up to ~8× the volume a moving body can actually reach
+ * this step, manufacturing false broadphase pairs at speed for nothing.
+ *
+ * @param {number[]|Float32Array|Float64Array} aabb inflated in place
+ * @param {number} offset
+ * @param {number} vx world linear velocity x
+ * @param {number} vy world linear velocity y
+ * @param {number} vz world linear velocity z
+ * @param {number} dt step size
+ */
+export function fatten_world_aabb(aabb, offset, vx, vy, vz, dt) {
+    const k = FAT_VELOCITY_MULTIPLIER * dt;
+    const px = vx * k;
+    const py = vy * k;
+    const pz = vz * k;
 
-    result[result_offset] -= pad;
-    result[result_offset + 1] -= pad;
-    result[result_offset + 2] -= pad;
-    result[result_offset + 3] += pad;
-    result[result_offset + 4] += pad;
-    result[result_offset + 5] += pad;
+    aabb[offset]     += (px < 0 ? px : 0) - FAT_LINEAR;
+    aabb[offset + 1] += (py < 0 ? py : 0) - FAT_LINEAR;
+    aabb[offset + 2] += (pz < 0 ? pz : 0) - FAT_LINEAR;
+    aabb[offset + 3] += (px > 0 ? px : 0) + FAT_LINEAR;
+    aabb[offset + 4] += (py > 0 ? py : 0) + FAT_LINEAR;
+    aabb[offset + 5] += (pz > 0 ? pz : 0) + FAT_LINEAR;
+}
+
+/**
+ * Compute the inflated world AABB of a shape under a pose, padded by a
+ * symmetric constant slack and a directional velocity-proportional swept
+ * extent. The output is the thing to hand to `BVH#node_move_aabb`.
+ *
+ * @param {number[]|Float32Array|Float64Array} result
+ * @param {number} result_offset
+ * @param {AbstractShape3D} shape
+ * @param {Transform} transform
+ * @param {number} vx world linear velocity x
+ * @param {number} vy world linear velocity y
+ * @param {number} vz world linear velocity z
+ * @param {number} dt step size
+ */
+export function compute_fat_world_aabb(
+    result, result_offset,
+    shape, transform,
+    vx, vy, vz, dt
+) {
+    compute_world_aabb(result, result_offset, shape, transform);
+    fatten_world_aabb(result, result_offset, vx, vy, vz, dt);
 }

package/src/engine/physics/broadphase/generate_pairs.d.ts

@@ -11,11 +11,15 @@
  * canonical `(min, max)` pair list — narrowphase then resolves the
  * collider-cross-product internally.
  *
- * Determinism: pair encounter order is fully determined by the awake-list
- * order × per-body collider-list order × BVH leaf traversal order. All
- * three are deterministic functions of the link/unlink sequence and the
- * BVH state, so two worlds with the same scene history produce identical
- * pair lists.
+ * Determinism: each pair's (A, B) assignment is ENTITY-canonical — the
+ * body with the smaller entity id is A. Packed body ids encode slot
+ * allocation history, which two engines holding identical body state need
+ * not share; the A/B roles leak into everything downstream (contact
+ * witness sides, normal orientation, tangent-basis derivation, event
+ * payloads), so they must derive from the cross-engine identity. Pair
+ * encounter ORDER, by contrast, is allowed to vary (awake-list × BVH
+ * traversal history): every outcome-coupled consumer re-orders by entity
+ * key (islands sort contacts, events sort canonically).
  *
  * @param {BodyStorage} storage
  * @param {BVH} dynamic_bvh

package/src/engine/physics/broadphase/generate_pairs.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"generate_pairs.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/broadphase/generate_pairs.js"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,uIATW,MAAM,MAAM;IAAC,QAAQ,WAAW;IAAC,SAAS,YAAY;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAC,CAAC,CAAC,+CAElF,MAAM,OAAO,MAAM,KAAK,OAAO,oCAqFhD"}
+{"version":3,"file":"generate_pairs.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/broadphase/generate_pairs.js"],"names":[],"mappings":"AAcA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,uIATW,MAAM,MAAM;IAAC,QAAQ,WAAW;IAAC,SAAS,YAAY;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAC,CAAC,CAAC,+CAElF,MAAM,OAAO,MAAM,KAAK,OAAO,oCAyFhD"}

package/src/engine/physics/broadphase/generate_pairs.js

@@ -1,9 +1,16 @@
-import { assert } from "../../../core/assert.js";
 import { bvh_query_user_data_overlaps_aabb } from "../../../core/bvh2/bvh3/query/bvh_query_user_data_overlaps_aabb.js";
-import { pack_body_id } from "../body/BodyStorage.js";
+import { body_id_index, pack_body_id } from "../body/BodyStorage.js";
 
 const scratch_aabb = new Float64Array(6);
-const candidates = new Uint32Array(1024);
+
+/**
+ * Per-leaf candidate buffer. `let` + grow-and-retry (the BVH query returns
+ * the TRUE overlap count and drops writes past the end): a fixed cap would
+ * deterministically drop the SAME trailing candidates every frame — a
+ * permanently missed contact in dense scenes, not a transient.
+ * @type {Uint32Array}
+ */
+let candidates = new Uint32Array(1024);
 
 /**
  * Iterate every awake body, query both BVHs from each of its attached
@@ -18,11 +25,15 @@ const candidates = new Uint32Array(1024);
  * canonical `(min, max)` pair list — narrowphase then resolves the
  * collider-cross-product internally.
  *
- * Determinism: pair encounter order is fully determined by the awake-list
- * order × per-body collider-list order × BVH leaf traversal order. All
- * three are deterministic functions of the link/unlink sequence and the
- * BVH state, so two worlds with the same scene history produce identical
- * pair lists.
+ * Determinism: each pair's (A, B) assignment is ENTITY-canonical — the
+ * body with the smaller entity id is A. Packed body ids encode slot
+ * allocation history, which two engines holding identical body state need
+ * not share; the A/B roles leak into everything downstream (contact
+ * witness sides, normal orientation, tangent-basis derivation, event
+ * payloads), so they must derive from the cross-engine identity. Pair
+ * encounter ORDER, by contrast, is allowed to vary (awake-list × BVH
+ * traversal history): every outcome-coupled consumer re-orders by entity
+ * key (islands sort contacts, events sort canonically).
  *
  * @param {BodyStorage} storage
  * @param {BVH} dynamic_bvh
@@ -58,34 +69,34 @@ export function generate_pairs(
 
         const gen = storage.generation_at(body_idx);
         const my_packed = pack_body_id(body_idx, gen); // single-source the bit layout
+        const my_entity = storage.entity_at(body_idx);
 
         for (let k = 0; k < list.length; k++) {
             const node = list[k].bvhNode;
             dynamic_bvh.node_get_aabb(node, scratch_aabb);
 
-            // Dynamic ↔ Dynamic.
-            let n = bvh_query_user_data_overlaps_aabb(
-                candidates, 0,
-                dynamic_bvh,
-                scratch_aabb
-            );
-            // The BVH query writes leaves unconditionally — at capacity it both
-            // drops leaves (typed-array OOB writes no-op) AND returns a count
-            // past the buffer end, so the loop below would read `undefined`
-            // candidates and build garbage pairs. Guard the buffer size.
-            assert.lessThan(n, candidates.length, 'generate_pairs: dynamic broadphase overflowed the candidate buffer');
-            // Production-safe clamp: the assert is stripped at bundle time, so
-            // without this an overflowing query (count past the buffer) would read
-            // `undefined` candidates and fabricate NaN-keyed garbage pairs. Drop
-            // the overflow deterministically — the fat AABBs persist, so any
-            // missed pair is re-detected next frame.
-            if (n > candidates.length) n = candidates.length;
+            // Dynamic ↔ Dynamic. Grow-and-retry: the query returns the TRUE
+            // overlap count and drops writes past the buffer end, so on
+            // overflow we re-query into a doubled buffer (deterministic
+            // queries → converges in one resize, amortised to zero).
+            let n;
+            for (;;) {
+                n = bvh_query_user_data_overlaps_aabb(
+                    candidates, 0,
+                    dynamic_bvh,
+                    scratch_aabb
+                );
+                if (n <= candidates.length) break;
+                candidates = new Uint32Array(Math.max(n, candidates.length * 2));
+            }
             for (let c = 0; c < n; c++) {
                 const other = candidates[c];
                 if (other === my_packed) continue;
 
-                const idA = my_packed < other ? my_packed : other;
-                const idB = my_packed < other ? other : my_packed;
+                // Entity-canonical roles — see the header.
+                const other_entity = storage.entity_at(body_id_index(other));
+                const idA = my_entity < other_entity ? my_packed : other;
+                const idB = my_entity < other_entity ? other : my_packed;
 
                 const existing = manifolds.find(idA, idB);
                 if (existing !== -1 && manifolds.is_touched(existing)) continue;
@@ -94,18 +105,22 @@ export function generate_pairs(
                 pair_list_out.push(idA, idB);
             }
 
-            // Dynamic ↔ Static.
-            n = bvh_query_user_data_overlaps_aabb(
-                candidates, 0,
-                static_bvh,
-                scratch_aabb
-            );
-            assert.lessThan(n, candidates.length, 'generate_pairs: static broadphase overflowed the candidate buffer');
-            if (n > candidates.length) n = candidates.length; // prod-safe clamp (see dynamic loop above)
+            // Dynamic ↔ Static. Same grow-and-retry as the dynamic loop.
+            for (;;) {
+                n = bvh_query_user_data_overlaps_aabb(
+                    candidates, 0,
+                    static_bvh,
+                    scratch_aabb
+                );
+                if (n <= candidates.length) break;
+                candidates = new Uint32Array(Math.max(n, candidates.length * 2));
+            }
             for (let c = 0; c < n; c++) {
                 const other = candidates[c];
-                const idA = my_packed < other ? my_packed : other;
-                const idB = my_packed < other ? other : my_packed;
+
+                const other_entity = storage.entity_at(body_id_index(other));
+                const idA = my_entity < other_entity ? my_packed : other;
+                const idB = my_entity < other_entity ? other : my_packed;
 
                 const existing = manifolds.find(idA, idB);
                 if (existing !== -1 && manifolds.is_touched(existing)) continue;

package/src/engine/physics/ccd/linear_sweep.d.ts

@@ -1,7 +1,9 @@
 /**
  * Sweep `shape` (held at the fixed `rotation`) linearly from `(fx,fy,fz)` to
- * `(tx,ty,tz)` through both broadphase trees, ignoring colliders owned by
- * `exclude_entity`.
+ * `(tx,ty,tz)` through both broadphase trees, ignoring the BODY owned by
+ * `exclude_entity` (all its colliders, including ones attached to child
+ * entities), sensors, and any pair the system's layer/mask + user contact
+ * filter rejects.
  *
  * Returns the traversable fraction of the segment in `[0, 1]`: `1` means the
  * path is clear; a value `< 1` means a blocker was hit at that fraction and
@@ -18,7 +20,8 @@
  * @param {number} tx
  * @param {number} ty
  * @param {number} tz
- * @param {number} exclude_entity entity to ignore (the swept body itself)
+ * @param {number} exclude_entity entity owning the swept body (the body is
+ *   resolved and excluded by BODY id); -1 for an unowned sweep
  * @param {PhysicsSurfacePoint} result populated on hit; untouched on a clear path
  * @returns {number} traversable fraction in [0, 1]
  */
@@ -37,8 +40,15 @@ export function ccd_sweep_segment(system: import("../ecs/PhysicsSystem.js").Phys
  *
  * Start-of-step positions are captured into `system.__ccd_start_pos` (3 doubles
  * per body index) before the substep loop; this pass reads the final pose from
- * the live Transform. Iterates the awake list in storage order, so it is
- * deterministic.
+ * the live Transform.
+ *
+ * Bodies are processed in ENTITY order, not awake-list order. CCD order is
+ * outcome-coupled: an earlier body's clamp moves the pose a later body's
+ * sweep tests against, so two mutually-blocking CCD movers resolve
+ * differently under different orders. The awake list encodes wake/sleep
+ * HISTORY (swap-remove + append), which two engines holding identical body
+ * state need not share; entity order is derivable from state alone — the
+ * determinism contract.
  *
  * @param {import("../ecs/PhysicsSystem.js").PhysicsSystem} system
  */

package/src/engine/physics/ccd/linear_sweep.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"linear_sweep.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/ccd/linear_sweep.js"],"names":[],"mappings":"AA8FA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,0CAbW,OAAO,yBAAyB,EAAE,aAAa,SAC/C,OAAO,gDAAgD,EAAE,eAAe,YACxE;IAAC,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAA;CAAC,MACrC,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,kBACN,MAAM,UACN,mBAAmB,GACjB,MAAM,CAmClB;AAED;;;;;;;;;;;;;GAaG;AACH,oCAFW,OAAO,yBAAyB,EAAE,aAAa,QAuEzD;AAtOD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AAEH;;;;;;;;;;;;;;;GAeG;AACH,qCAFU,MAAM,CAE2B;oCArDP,mCAAmC"}
+{"version":3,"file":"linear_sweep.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/ccd/linear_sweep.js"],"names":[],"mappings":"AA6HA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,0CAdW,OAAO,yBAAyB,EAAE,aAAa,SAC/C,OAAO,gDAAgD,EAAE,eAAe,YACxE;IAAC,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAA;CAAC,MACrC,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,kBACN,MAAM,UAEN,mBAAmB,GACjB,MAAM,CA2ClB;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,oCAFW,OAAO,yBAAyB,EAAE,aAAa,QAwGzD;AAvTD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AAEH;;;;;;;;;;;;;;;GAeG;AACH,qCAFU,MAAM,CAE2B;oCArDP,mCAAmC"}

package/src/engine/physics/ccd/linear_sweep.js

@@ -1,5 +1,6 @@
-import { Ray3 } from "../../../core/geom/3d/ray/Ray3.js";
+import { BODY_INDEX_ABSENT, body_id_index, pack_body_id } from "../body/BodyStorage.js";
 import { BodyKind } from "../ecs/BodyKind.js";
+import { is_sensor } from "../ecs/is_sensor.js";
 import { RigidBodyFlags } from "../ecs/RigidBodyFlags.js";
 import { PhysicsSurfacePoint } from "../queries/PhysicsSurfacePoint.js";
 import { shape_cast } from "../queries/shape_cast.js";
@@ -56,46 +57,78 @@ import { shape_cast } from "../queries/shape_cast.js";
  */
 export const CCD_MIN_SWEEP_DISTANCE = 1e-3;
 
-/**
- * Impact distances at or below this (metres) mean the body was already
- * overlapping the target at the start of the step — i.e. a resting / sliding
- * contact the discrete solver owns, not a tunnel. The sweep ignores these so
- * CCD never clamps a body to a surface it is merely sitting or sliding on.
- * @type {number}
- */
-const CCD_INITIAL_OVERLAP_EPS = 1e-6;
-
 // ── Module scratch ──────────────────────────────────────────────────────────
 // CCD runs inside the step loop; reuse buffers so the pass allocates nothing.
 
-/** Swept ray, re-seeded per sweep (origin, unit direction, tMax). */
-const _ray = new Ray3();
+/**
+ * Swept ray, re-seeded per sweep (origin, unit direction, tMax). A plain
+ * DOUBLE-precision ray-like rather than a `Ray3`: Ray3 is Float32Array-backed,
+ * and funnelling the f64 sweep endpoints through f32 quantises them (~1 mm at
+ * |coord| ≈ 10⁴, ~16 mm at 10⁵) — visible TOI jitter far from the world
+ * origin. {@link shape_cast} reads only the named accessors, so a ray-like
+ * object preserves the Transform's full f64 precision end to end.
+ */
+const _ray = {
+    origin_x: 0, origin_y: 0, origin_z: 0,
+    direction_x: 0, direction_y: 0, direction_z: 0,
+    tMax: 0,
+};
 
 /** Sweep result reused across bodies inside {@link ccd_resolve}. */
 const _hit = new PhysicsSurfacePoint();
 
 /**
- * Entity whose colliders the current sweep must ignore (the moving body's own).
- * Module-scoped so {@link _exclude_self} stays a stable, non-allocating
- * reference handed to {@link shape_cast}.
+ * CCD-eligible body indices of the current pass, ordered by ENTITY id.
+ * Grows by doubling; module-scoped so the pass allocates nothing in steady
+ * state.
+ * @type {Uint32Array}
+ */
+let _ccd_order = new Uint32Array(64);
+
+/**
+ * System the current sweep runs against. Module-scoped so {@link _ccd_filter}
+ * stays a stable, non-allocating reference handed to {@link shape_cast}.
+ * @type {import("../ecs/PhysicsSystem.js").PhysicsSystem|null}
+ */
+let _system = null;
+
+/**
+ * Packed body id of the swept body — excluded from its own sweep; -1 when the
+ * sweep has no owning body (then only the sensor rule applies).
  * @type {number}
  */
-let _exclude_entity = -1;
+let _self_body_id = -1;
 
 /**
- * Self-exclusion filter for the sweep: drop candidates owned by the moving
- * body's own entity (otherwise the body would "hit itself" at `t = 0`).
- * @param {number} entity
+ * Sweep filter, mirroring the discrete pipeline's pair acceptance:
+ *   - never the swept body itself. BODY-id exclusion: every collider of a
+ *     compound body carries the body id in the broadphase, including ones
+ *     attached to child entities — entity comparison missed those, the body
+ *     swept against itself at t = 0, and the t = 0 hit disabled its CCD;
+ *   - sensors are not solid surfaces — a sweep passes through a trigger
+ *     volume (same rule and rationale as {@link raycast});
+ *   - layer/mask + the user contact filter via `system.__pair_filter`, so CCD
+ *     never clamps a body onto geometry the discrete solver would not
+ *     collide it with.
+ *
+ * @param {number} entity candidate body's entity
+ * @param {Collider} collider candidate body's primary collider
+ * @param {number} body_id candidate's packed body id
  * @returns {boolean}
  */
-function _exclude_self(entity) {
-    return entity !== _exclude_entity;
+function _ccd_filter(entity, collider, body_id) {
+    if (body_id === _self_body_id) return false;
+    if (is_sensor(_system.__bodies[body_id_index(body_id)], collider)) return false;
+    if (_self_body_id !== -1 && !_system.__pair_filter(_self_body_id, body_id)) return false;
+    return true;
 }
 
 /**
  * Sweep `shape` (held at the fixed `rotation`) linearly from `(fx,fy,fz)` to
- * `(tx,ty,tz)` through both broadphase trees, ignoring colliders owned by
- * `exclude_entity`.
+ * `(tx,ty,tz)` through both broadphase trees, ignoring the BODY owned by
+ * `exclude_entity` (all its colliders, including ones attached to child
+ * entities), sensors, and any pair the system's layer/mask + user contact
+ * filter rejects.
  *
  * Returns the traversable fraction of the segment in `[0, 1]`: `1` means the
  * path is clear; a value `< 1` means a blocker was hit at that fraction and
@@ -112,7 +145,8 @@ function _exclude_self(entity) {
  * @param {number} tx
  * @param {number} ty
  * @param {number} tz
- * @param {number} exclude_entity entity to ignore (the swept body itself)
+ * @param {number} exclude_entity entity owning the swept body (the body is
+ *   resolved and excluded by BODY id); -1 for an unowned sweep
  * @param {PhysicsSurfacePoint} result populated on hit; untouched on a clear path
  * @returns {number} traversable fraction in [0, 1]
  */
@@ -128,21 +162,29 @@ export function ccd_sweep_segment(
     if (len === 0) return 1;
 
     const inv = 1 / len;
-    _ray[0] = fx; _ray[1] = fy; _ray[2] = fz;
-    _ray[3] = dx * inv; _ray[4] = dy * inv; _ray[5] = dz * inv;
-    _ray[6] = len; // tMax in metres — direction is unit length
+    _ray.origin_x = fx; _ray.origin_y = fy; _ray.origin_z = fz;
+    _ray.direction_x = dx * inv; _ray.direction_y = dy * inv; _ray.direction_z = dz * inv;
+    _ray.tMax = len; // tMax in metres — direction is unit length
 
-    _exclude_entity = exclude_entity;
-    if (!shape_cast(system, _ray, shape, rotation, result, _exclude_self)) {
+    // Resolve the swept body once: self-exclusion compares packed BODY ids in
+    // the filter (broadphase leaves carry body ids), and the pair filter needs
+    // the id pair.
+    const storage = system.storage;
+    const self_idx = exclude_entity >= 0 ? storage.index_of_entity(exclude_entity) : BODY_INDEX_ABSENT;
+    _self_body_id = self_idx === BODY_INDEX_ABSENT ? -1 : pack_body_id(self_idx, storage.generation_at(self_idx));
+    _system = system;
+
+    // skip_initial_overlaps: a candidate already overlapping at the segment
+    // start is a resting / sliding contact the discrete solver owns, not a
+    // tunnel — the cast steps over it PER CANDIDATE and keeps scanning, so a
+    // body sliding on the ground still gets swept against every real blocker
+    // along its path. (A whole-sweep "t ≈ 0 means resting" bail-out is wrong
+    // twice over: one resting contact would disable CCD against everything
+    // else, and a genuine first impact a hair ahead would be dropped too.)
+    if (!shape_cast(system, _ray, shape, rotation, result, _ccd_filter, true)) {
         return 1;
     }
 
-    // An impact at t ≈ 0 means the swept shape was already overlapping the
-    // target at the segment start — a resting / sliding contact, not a tunnel.
-    // The discrete solver owns it; clamping here would freeze a body onto a
-    // surface it is sitting or sliding on. Treat as a clear path.
-    if (result.t <= CCD_INITIAL_OVERLAP_EPS) return 1;
-
     // result.t is the impact distance along the unit direction; normalise to a
     // segment fraction. shape_cast reports the just-SEPARATING side of its
     // bisection, so the swept shape at `result.t` is provably not overlapping —
@@ -160,8 +202,15 @@ export function ccd_sweep_segment(
  *
  * Start-of-step positions are captured into `system.__ccd_start_pos` (3 doubles
  * per body index) before the substep loop; this pass reads the final pose from
- * the live Transform. Iterates the awake list in storage order, so it is
- * deterministic.
+ * the live Transform.
+ *
+ * Bodies are processed in ENTITY order, not awake-list order. CCD order is
+ * outcome-coupled: an earlier body's clamp moves the pose a later body's
+ * sweep tests against, so two mutually-blocking CCD movers resolve
+ * differently under different orders. The awake list encodes wake/sleep
+ * HISTORY (swap-remove + append), which two engines holding identical body
+ * state need not share; entity order is derivable from state alone — the
+ * determinism contract.
  *
  * @param {import("../ecs/PhysicsSystem.js").PhysicsSystem} system
  */
@@ -172,6 +221,8 @@ export function ccd_resolve(system) {
     const start = system.__ccd_start_pos;
     const CCD = RigidBodyFlags.CCD;
 
+    // Collect the CCD-eligible awake bodies…
+    let n = 0;
     for (let i = 0; i < count; i++) {
         const idx = storage.awake_at(i);
 
@@ -182,6 +233,32 @@ export function ccd_resolve(system) {
 
         const list = lists[idx];
         if (list === undefined || list.length === 0) continue;
+
+        if (n === _ccd_order.length) {
+            const next = new Uint32Array(_ccd_order.length * 2);
+            next.set(_ccd_order);
+            _ccd_order = next;
+        }
+        _ccd_order[n++] = idx;
+    }
+    if (n === 0) return;
+
+    // …and order them by entity (insertion sort; CCD bodies are few).
+    for (let i = 1; i < n; i++) {
+        const idx = _ccd_order[i];
+        const key = storage.entity_at(idx);
+        let j = i - 1;
+        while (j >= 0 && storage.entity_at(_ccd_order[j]) > key) {
+            _ccd_order[j + 1] = _ccd_order[j];
+            j--;
+        }
+        _ccd_order[j + 1] = idx;
+    }
+
+    for (let i = 0; i < n; i++) {
+        const idx = _ccd_order[i];
+        const rb = system.__bodies[idx];
+        const list = lists[idx];
         const primary = list[0];
         const tr = primary.transform;
         const p = tr.position;
@@ -203,15 +280,20 @@ export function ccd_resolve(system) {
         // jitter) — avoids a degenerate sweep and the query cost. NOT tied to
         // body size: a body tunnels a thin obstacle at speeds well below its
         // own extent, so the threshold is a small absolute slop. A resting /
-        // sliding body that does clear it is still safe — the sweep ignores its
-        // initial-overlap contact (see CCD_INITIAL_OVERLAP_EPS).
+        // sliding body that does clear it is still safe — the cast skips
+        // candidates it already overlaps at the start (skip_initial_overlaps),
+        // sweeping only against real blockers along the path.
         if (disp2 <= CCD_MIN_SWEEP_DISTANCE * CCD_MIN_SWEEP_DISTANCE) continue;
 
         const shape = primary.collider.shape;
+        // Exclude by the body's OWN entity (which resolves to its body id) —
+        // NOT primary.entity: a compound body's primary collider can live on a
+        // CHILD entity, and excluding that child would leave the body's other
+        // leaves visible to its own sweep (self-hit at t = 0).
         const frac = ccd_sweep_segment(
             system, shape, tr.rotation,
             sx, sy, sz, ex, ey, ez,
-            primary.entity, _hit,
+            storage.entity_at(idx), _hit,
         );
         if (frac >= 1) continue; // clear path — no tunnelling this step