@woosh/meep-engine 2.153.0 → 2.154.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,eAcC;CACJ"}
+{"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"}

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

@@ -238,11 +238,12 @@ export class SolverBodyState {
         const next_data = new Float64Array(cap * SBS_STRIDE);
         const next_stamp = new Int32Array(cap);
         const next_gathered = new Uint32Array(cap);
-        // No need to copy `data` — it is fully repopulated by `gather` each
-        // step before any read. `__stamp` must NOT carry stale gen values into
-        // the grown region; a fresh zero-filled array plus the live `__gen`
-        // (always >= 1 after begin) guarantees grown slots read as un-gathered.
-        next_stamp.set(this.__stamp);
+        // No need to copy `data` — it is fully repopulated by `gather` each step
+        // before any read. `__stamp` is intentionally NOT copied either: a fresh
+        // zero-filled array plus the live `__gen` (always >= 1 after begin's gen
+        // roll) makes every slot read as un-gathered, which is exactly what the
+        // grown region needs; copying stale gen values back in would be dead work
+        // (they are all < the live gen anyway).
         this.data = next_data;
         this.__stamp = next_stamp;
         this.__gathered = next_gathered;

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":"AAMA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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,oCA8EhD"}
+{"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"}

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

@@ -1,5 +1,6 @@
 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";
 
 const scratch_aabb = new Float64Array(6);
 const candidates = new Uint32Array(1024);
@@ -56,7 +57,7 @@ export function generate_pairs(
         if (list === undefined || list.length === 0) continue;
 
         const gen = storage.generation_at(body_idx);
-        const my_packed = (body_idx << 8) | gen;
+        const my_packed = pack_body_id(body_idx, gen); // single-source the bit layout
 
         for (let k = 0; k < list.length; k++) {
             const node = list[k].bvhNode;
@@ -73,6 +74,12 @@ export function generate_pairs(
             // 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;
             for (let c = 0; c < n; c++) {
                 const other = candidates[c];
                 if (other === my_packed) continue;
@@ -94,6 +101,7 @@ export function generate_pairs(
                 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)
             for (let c = 0; c < n; c++) {
                 const other = candidates[c];
                 const idA = my_packed < other ? my_packed : other;

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,QAwEzD;AAvOD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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":"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"}

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

@@ -1,238 +1,237 @@
-import { Ray3 } from "../../../core/geom/3d/ray/Ray3.js";
-import { BodyKind } from "../ecs/BodyKind.js";
-import { RigidBodyFlags } from "../ecs/RigidBodyFlags.js";
-import { PhysicsSurfacePoint } from "../queries/PhysicsSurfacePoint.js";
-import { shape_cast } from "../queries/shape_cast.js";
-
-/**
- * Continuous collision detection — linear shape-cast (the "speculative margin
- * floor, upgraded to an opt-in per-body sweep" item from PLAN.md).
- *
- * The discrete pipeline detects contacts by overlap at step boundaries: a body
- * that moves more than its own thickness in one step can start a step on one
- * side of a thin wall and end on the other, never overlapping it on any frame
- * the broadphase samples — it tunnels. The speculative fat-AABB margin
- * (`compute_fat_world_aabb`) covers moderate speeds; genuinely fast movers
- * (bullets, dropped debris, a body flung by an explosion) need a swept test.
- *
- * Approach (Box2D `b2_continuousPhysics`-style conservative advancement): after
- * the substep solver has produced each body's final pose, sweep a CCD-flagged
- * fast mover's primary collider along its NET step translation
- * (start-of-step → final pose) using the existing {@link shape_cast} TOI engine.
- * On the first blocker, clamp the body to the contact pose and remove the
- * inbound normal component of its velocity (an inelastic stop) — the next
- * discrete step then resolves the now-touching contact with the real
- * material / restitution.
- *
- * Scope (v1, deliberate):
- *   - LINEAR sweep only: the orientation is held fixed through the sweep (the
- *     per-step angular motion is small at the fixed-step rate).
- *   - PRIMARY same-entity collider: a compound body sweeps its first collider;
- *     child-entity colliders (whose transform is synced outside the step) are
- *     not swept.
- *   - EXACT against static geometry (the static BVH holds tight, never-moved
- *     leaves); APPROXIMATE against other dynamic bodies (they have moved this
- *     step too, but the sweep sees their start-of-step broadphase AABBs) — the
- *     speculative-margin floor for the dynamic-vs-dynamic case.
- *   - The CCD stop itself is inelastic; the impact does not bounce. Restitution
- *     applies on the next discrete contact.
- */
-
-/**
- * Minimum per-step displacement (metres) before a CCD sweep is worth running.
- * Its ONLY job is to skip a body that didn't meaningfully move — a resting /
- * sleeping-soon body whose displacement is sub-millimetre jitter — which avoids
- * a degenerate zero-length sweep and saves the query cost.
- *
- * It must NOT be tied to the body's own size. Tunnelling risk is governed by the
- * *obstacle's* thickness, not the mover's: a 2 m sphere drifting at 0.5 m/step
- * still passes clean through a 1 cm floor. A small absolute slop catches that;
- * gating on a fraction of the body's extent would (wrongly) wait until the body
- * moved more than its own radius and miss every thin-obstacle tunnel below that
- * speed. The discrete narrowphase still owns any obstacle thicker than a body's
- * per-step move, so CCD reliably prevents tunnelling of obstacles thicker than
- * this slop.
- * @type {number}
- */
-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();
-
-/** 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}.
- * @type {number}
- */
-let _exclude_entity = -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
- * @returns {boolean}
- */
-function _exclude_self(entity) {
-    return entity !== _exclude_entity;
-}
-
-/**
- * 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`.
- *
- * 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
- * `result` has been filled — `result.position` is the swept-shape centre at
- * first contact, `result.normal` is the blocker's outward surface normal
- * (B → A), `result.entity` / `result.body_id` the blocker.
- *
- * @param {import("../ecs/PhysicsSystem.js").PhysicsSystem} system
- * @param {import("../../../core/geom/3d/shape/AbstractShape3D.js").AbstractShape3D} shape
- * @param {{x:number,y:number,z:number,w:number}} rotation fixed orientation
- * @param {number} fx
- * @param {number} fy
- * @param {number} fz
- * @param {number} tx
- * @param {number} ty
- * @param {number} tz
- * @param {number} exclude_entity entity to ignore (the swept body itself)
- * @param {PhysicsSurfacePoint} result populated on hit; untouched on a clear path
- * @returns {number} traversable fraction in [0, 1]
- */
-export function ccd_sweep_segment(
-    system, shape, rotation,
-    fx, fy, fz, tx, ty, tz,
-    exclude_entity, result,
-) {
-    const dx = tx - fx;
-    const dy = ty - fy;
-    const dz = tz - fz;
-    const len = Math.sqrt(dx * dx + dy * dy + dz * dz);
-    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
-
-    _exclude_entity = exclude_entity;
-    if (!shape_cast(system, _ray, shape, rotation, result, _exclude_self)) {
-        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 —
-    // safe to place the body there.
-    const frac = result.t * inv;
-    return frac < 1 ? frac : 1;
-}
-
-/**
- * Post-solve continuous-collision pass over the awake set. For each awake
- * Dynamic body flagged {@link RigidBodyFlags.CCD} that moved more than
- * {@link CCD_MIN_SWEEP_DISTANCE} this step, sweep its primary collider along the
- * step's net translation and stop it at the first blocker (clamp pose + remove
- * inbound normal velocity).
- *
- * 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.
- *
- * @param {import("../ecs/PhysicsSystem.js").PhysicsSystem} system
- */
-export function ccd_resolve(system) {
-    const storage = system.storage;
-    const count = storage.awake_count;
-    const lists = system.__body_collider_lists;
-    const start = system.__ccd_start_pos;
-    const CCD = RigidBodyFlags.CCD;
-
-    for (let i = 0; i < count; i++) {
-        const idx = storage.awake_at(i);
-
-        const rb = system.__bodies[idx];
-        if (rb === undefined) continue;
-        if ((rb.flags & CCD) === 0) continue;
-        if (rb.kind !== BodyKind.Dynamic) continue;
-
-        const list = lists[idx];
-        if (list === undefined || list.length === 0) continue;
-        const primary = list[0];
-        const tr = primary.transform;
-        const p = tr.position;
-
-        const base = idx * 3;
-        const sx = start[base];
-        const sy = start[base + 1];
-        const sz = start[base + 2];
-        const ex = p[0];
-        const ey = p[1];
-        const ez = p[2];
-
-        const dx = ex - sx;
-        const dy = ey - sy;
-        const dz = ez - sz;
-        const disp2 = dx * dx + dy * dy + dz * dz;
-        if (disp2 === 0) continue;
-
-        // Motion gate: skip a body that barely moved (resting / negligible
-        // 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).
-        if (disp2 <= CCD_MIN_SWEEP_DISTANCE * CCD_MIN_SWEEP_DISTANCE) continue;
-
-        const shape = primary.collider.shape;
-        const frac = ccd_sweep_segment(
-            system, shape, tr.rotation,
-            sx, sy, sz, ex, ey, ez,
-            primary.entity, _hit,
-        );
-        if (frac >= 1) continue; // clear path — no tunnelling this step
-
-        // Clamp the body to the first-contact pose (swept-shape centre at the
-        // TOI), so it cannot end the step on the far side of the blocker.
-        const hp = _hit.position;
-        p.set(hp[0], hp[1], hp[2]);
-
-        // Remove the inbound normal component of velocity (inelastic stop).
-        // `_hit.normal` is the blocker's outward surface normal; the body is
-        // moving into it (v·n < 0). Zeroing that component leaves the tangential
-        // slide intact and never adds energy. The next discrete step applies the
-        // real restitution / friction on the established contact.
-        const n = _hit.normal;
-        const lv = rb.linearVelocity;
-        const vn = lv[0] * n[0] + lv[1] * n[1] + lv[2] * n[2];
-        if (vn < 0) {
-            lv[0] -= vn * n[0];
-            lv[1] -= vn * n[1];
-            lv[2] -= vn * n[2];
-        }
-    }
-}
+import { Ray3 } from "../../../core/geom/3d/ray/Ray3.js";
+import { BodyKind } from "../ecs/BodyKind.js";
+import { RigidBodyFlags } from "../ecs/RigidBodyFlags.js";
+import { PhysicsSurfacePoint } from "../queries/PhysicsSurfacePoint.js";
+import { shape_cast } from "../queries/shape_cast.js";
+
+/**
+ * Continuous collision detection — linear shape-cast (the "speculative margin
+ * floor, upgraded to an opt-in per-body sweep" item from PLAN.md).
+ *
+ * The discrete pipeline detects contacts by overlap at step boundaries: a body
+ * that moves more than its own thickness in one step can start a step on one
+ * side of a thin wall and end on the other, never overlapping it on any frame
+ * the broadphase samples — it tunnels. The speculative fat-AABB margin
+ * (`compute_fat_world_aabb`) covers moderate speeds; genuinely fast movers
+ * (bullets, dropped debris, a body flung by an explosion) need a swept test.
+ *
+ * Approach (Box2D `b2_continuousPhysics`-style conservative advancement): after
+ * the substep solver has produced each body's final pose, sweep a CCD-flagged
+ * fast mover's primary collider along its NET step translation
+ * (start-of-step → final pose) using the existing {@link shape_cast} TOI engine.
+ * On the first blocker, clamp the body to the contact pose and remove the
+ * inbound normal component of its velocity (an inelastic stop) — the next
+ * discrete step then resolves the now-touching contact with the real
+ * material / restitution.
+ *
+ * Scope (v1, deliberate):
+ *   - LINEAR sweep only: the orientation is held fixed through the sweep (the
+ *     per-step angular motion is small at the fixed-step rate).
+ *   - PRIMARY same-entity collider: a compound body sweeps its first collider;
+ *     child-entity colliders (whose transform is synced outside the step) are
+ *     not swept.
+ *   - EXACT against static geometry (the static BVH holds tight, never-moved
+ *     leaves); APPROXIMATE against other dynamic bodies (they have moved this
+ *     step too, but the sweep sees their start-of-step broadphase AABBs) — the
+ *     speculative-margin floor for the dynamic-vs-dynamic case.
+ *   - The CCD stop itself is inelastic; the impact does not bounce. Restitution
+ *     applies on the next discrete contact.
+ */
+
+/**
+ * Minimum per-step displacement (metres) before a CCD sweep is worth running.
+ * Its ONLY job is to skip a body that didn't meaningfully move — a resting /
+ * sleeping-soon body whose displacement is sub-millimetre jitter — which avoids
+ * a degenerate zero-length sweep and saves the query cost.
+ *
+ * It must NOT be tied to the body's own size. Tunnelling risk is governed by the
+ * *obstacle's* thickness, not the mover's: a 2 m sphere drifting at 0.5 m/step
+ * still passes clean through a 1 cm floor. A small absolute slop catches that;
+ * gating on a fraction of the body's extent would (wrongly) wait until the body
+ * moved more than its own radius and miss every thin-obstacle tunnel below that
+ * speed. The discrete narrowphase still owns any obstacle thicker than a body's
+ * per-step move, so CCD reliably prevents tunnelling of obstacles thicker than
+ * this slop.
+ * @type {number}
+ */
+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();
+
+/** 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}.
+ * @type {number}
+ */
+let _exclude_entity = -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
+ * @returns {boolean}
+ */
+function _exclude_self(entity) {
+    return entity !== _exclude_entity;
+}
+
+/**
+ * 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`.
+ *
+ * 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
+ * `result` has been filled — `result.position` is the swept-shape centre at
+ * first contact, `result.normal` is the blocker's outward surface normal
+ * (B → A), `result.entity` / `result.body_id` the blocker.
+ *
+ * @param {import("../ecs/PhysicsSystem.js").PhysicsSystem} system
+ * @param {import("../../../core/geom/3d/shape/AbstractShape3D.js").AbstractShape3D} shape
+ * @param {{x:number,y:number,z:number,w:number}} rotation fixed orientation
+ * @param {number} fx
+ * @param {number} fy
+ * @param {number} fz
+ * @param {number} tx
+ * @param {number} ty
+ * @param {number} tz
+ * @param {number} exclude_entity entity to ignore (the swept body itself)
+ * @param {PhysicsSurfacePoint} result populated on hit; untouched on a clear path
+ * @returns {number} traversable fraction in [0, 1]
+ */
+export function ccd_sweep_segment(
+    system, shape, rotation,
+    fx, fy, fz, tx, ty, tz,
+    exclude_entity, result,
+) {
+    const dx = tx - fx;
+    const dy = ty - fy;
+    const dz = tz - fz;
+    const len = Math.sqrt(dx * dx + dy * dy + dz * dz);
+    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
+
+    _exclude_entity = exclude_entity;
+    if (!shape_cast(system, _ray, shape, rotation, result, _exclude_self)) {
+        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 —
+    // safe to place the body there.
+    const frac = result.t * inv;
+    return frac < 1 ? frac : 1;
+}
+
+/**
+ * Post-solve continuous-collision pass over the awake set. For each awake
+ * Dynamic body flagged {@link RigidBodyFlags.CCD} that moved more than
+ * {@link CCD_MIN_SWEEP_DISTANCE} this step, sweep its primary collider along the
+ * step's net translation and stop it at the first blocker (clamp pose + remove
+ * inbound normal velocity).
+ *
+ * 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.
+ *
+ * @param {import("../ecs/PhysicsSystem.js").PhysicsSystem} system
+ */
+export function ccd_resolve(system) {
+    const storage = system.storage;
+    const count = storage.awake_count;
+    const lists = system.__body_collider_lists;
+    const start = system.__ccd_start_pos;
+    const CCD = RigidBodyFlags.CCD;
+
+    for (let i = 0; i < count; i++) {
+        const idx = storage.awake_at(i);
+
+        const rb = system.__bodies[idx];
+        if (rb === undefined) continue;
+        if ((rb.flags & CCD) === 0) continue;
+        if (rb.kind !== BodyKind.Dynamic) continue;
+
+        const list = lists[idx];
+        if (list === undefined || list.length === 0) continue;
+        const primary = list[0];
+        const tr = primary.transform;
+        const p = tr.position;
+
+        const base = idx * 3;
+        const sx = start[base];
+        const sy = start[base + 1];
+        const sz = start[base + 2];
+        const ex = p[0];
+        const ey = p[1];
+        const ez = p[2];
+
+        const dx = ex - sx;
+        const dy = ey - sy;
+        const dz = ez - sz;
+        const disp2 = dx * dx + dy * dy + dz * dz;
+
+        // Motion gate: skip a body that barely moved (resting / negligible
+        // 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).
+        if (disp2 <= CCD_MIN_SWEEP_DISTANCE * CCD_MIN_SWEEP_DISTANCE) continue;
+
+        const shape = primary.collider.shape;
+        const frac = ccd_sweep_segment(
+            system, shape, tr.rotation,
+            sx, sy, sz, ex, ey, ez,
+            primary.entity, _hit,
+        );
+        if (frac >= 1) continue; // clear path — no tunnelling this step
+
+        // Clamp the body to the first-contact pose (swept-shape centre at the
+        // TOI), so it cannot end the step on the far side of the blocker.
+        const hp = _hit.position;
+        p.set(hp[0], hp[1], hp[2]);
+
+        // Remove the inbound normal component of velocity (inelastic stop).
+        // `_hit.normal` is the blocker's outward surface normal; the body is
+        // moving into it (v·n < 0). Zeroing that component leaves the tangential
+        // slide intact and never adds energy. The next discrete step applies the
+        // real restitution / friction on the established contact.
+        const n = _hit.normal;
+        const lv = rb.linearVelocity;
+        const vn = lv[0] * n[0] + lv[1] * n[1] + lv[2] * n[2];
+        if (vn < 0) {
+            lv[0] -= vn * n[0];
+            lv[1] -= vn * n[1];
+            lv[2] -= vn * n[2];
+        }
+    }
+}

package/src/engine/physics/computeInterceptPoint.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"computeInterceptPoint.d.ts","sourceRoot":"","sources":["../../../../src/engine/physics/computeInterceptPoint.js"],"names":[],"mappings":"AASA;;;;;;;;;GASG;AACH,+HAHW,MAAM,GACL,OAAO,CAyDlB"}
+{"version":3,"file":"computeInterceptPoint.d.ts","sourceRoot":"","sources":["../../../../src/engine/physics/computeInterceptPoint.js"],"names":[],"mappings":"AASA;;;;;;;;;GASG;AACH,+HAHW,MAAM,GACL,OAAO,CA8DlB"}

package/src/engine/physics/computeInterceptPoint.js

@@ -60,9 +60,14 @@ export function computeInterceptPoint(
 
         if (t >= 0) {
 
-            result.copy(targetVelocity);
-            result.multiplyScalar(t);
-            result.add(target);
+            // Single write, computed from the inputs up front, so it is correct
+            // even when `result` aliases `target` (a copy-then-add would read
+            // `target` after overwriting it, doubling the velocity term).
+            result.set(
+                target.x + targetVelocity.x * t,
+                target.y + targetVelocity.y * t,
+                target.z + targetVelocity.z * t,
+            );
 
             return true;
 

package/src/engine/physics/contact/ManifoldStore.d.ts

@@ -82,7 +82,6 @@ export class ManifoldStore {
     __high_water: number;
     __data: Float64Array;
     __meta: Uint32Array;
-    __slot_axis: Float64Array;
     __pair_index: PairUint32Map;
     __live_slots: Uint32Array;
     __live_pos: Int32Array;
@@ -268,21 +267,6 @@ export class ManifoldStore {
      * @returns {Float64Array}
      */
     get data_buffer(): Float64Array;
-    /**
-     * Per-slot cached GJK separating axis buffer. Hot-path GJK callers
-     * pass this together with {@link slot_axis_offset} to
-     * `gjk_with_axis(...)` so the cached axis seeds the next iteration.
-     * Buffer identity is stable until grow.
-     * @returns {Float64Array}
-     */
-    get slot_axis_buffer(): Float64Array;
-    /**
-     * Float offset into {@link slot_axis_buffer} where this slot's
-     * cached axis lives (3 floats: x, y, z).
-     * @param {number} slot
-     * @returns {number}
-     */
-    slot_axis_offset(slot: number): number;
     /**
      * Word offset into {@link data_buffer} where the first contact of `slot`
      * begins. Subsequent contacts within the slot are at

package/src/engine/physics/contact/ManifoldStore.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ManifoldStore.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/contact/ManifoldStore.js"],"names":[],"mappings":"AAGA;;;;;GAKG;AACH,wCAFU,MAAM,CAE2B;AAE3C;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,6BAFU,MAAM,CAEiB;AAEjC;;;;GAIG;AACH,wCAFU,MAAM,CAE4B;AAE5C;;;GAGG;AACH,+BAFU,MAAM,CAE2D;AAyB3E;;;GAGG;AACH,mCAFU,MAAM,CAEuB;AAIvC;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH;IAEI;;OAEG;IACH,+BAFW,MAAM,EA6BhB;IAzBG,mBAA+C;IAC/C,qBAAqB;IAErB,qBAAkE;IAClE,oBAAiE;IAQjE,0BAAwD;IAExD,4BAA0D;IAG1D,0BAAoD;IACpD,uBAAiD;IAEjD,qBAAqB;IAGrB,yBAAmD;IACnD,qBAAqB;IAGzB;;OAEG;IACH,oBAEC;IAED;;OAEG;IACH,uBAEC;IAED;;;;;;;OAOG;IACH,UAJW,MAAM,OACN,MAAM,GACJ,MAAM,CAKlB;IAED;;;;;;;;OAQG;IACH,aAJW,MAAM,OACN,MAAM,GACJ,MAAM,CA+BlB;IAED;;;OAGG;IACH,YAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;OAGG;IACH,YAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;OAGG;IACH,oBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;OAGG;IACH,iBAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;OAGG;IACH,uBAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;;;OAKG;IACH,WAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;OAKG;IACH,qBAFW,MAAM,QAQhB;IAED;;;;;;;;;;;;;OAaG;IACH,mBAFW,MAAM,QAKhB;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IACH,kBAnBW,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,SACN,MAAM,eACN,MAAM,aAGN,MAAM,gBAEN,MAAM,QAwBhB;IAED;;;;;OAKG;IACH,kBAJW,MAAM,OACN,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;OAKG;IACH,qBAJW,MAAM,OACN,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;;;;;;;;;;;OAeG;IACH,qBAHW,MAAM,OACN,MAAM,QAOhB;IAED;;;;;OAKG;IACH,oBAJW,MAAM,OACN,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;;OAMG;IACH,kBALW,MAAM,OACN,MAAM,OACN,MAAM,EAAE,GAAC,YAAY,cACrB,MAAM,QAOhB;IAED;;;;;;OAMG;IACH,uBAJW,MAAM,OACN,MAAM,GACJ,MAAM,CAIlB;IAED,iEAAiE;IACjE,uBADY,MAAM,OAAe,MAAM,GAAgB,MAAM,CAG5D;IAED,iEAAiE;IACjE,uBADY,MAAM,OAAe,MAAM,GAAgB,MAAM,CAG5D;IAED,iEAAiE;IACjE,oBADY,MAAM,OAAe,MAAM,GAAgB,MAAM,CAG5D;IAED;;;;;OAKG;IACH,gCAEC;IAED;;;;;;OAMG;IACH,qCAEC;IAED;;;;;OAKG;IACH,uBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;;OAMG;IACH,uBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;OAGG;IACH,sBA6BC;IAED;;;OAGG;IACH,wBAcC;IAED;;;OAGG;IACH,uBAkBC;IAED;;OAEG;IACH,eA+BC;IAED;;;OAGG;IACH,oBAaC;IAED;;;OAGG;IACH,mBAqBC;CACJ;8BAhoBqD,2CAA2C"}
+{"version":3,"file":"ManifoldStore.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/contact/ManifoldStore.js"],"names":[],"mappings":"AAGA;;;;;GAKG;AACH,wCAFU,MAAM,CAE2B;AAE3C;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,6BAFU,MAAM,CAEiB;AAEjC;;;;GAIG;AACH,wCAFU,MAAM,CAE4B;AAE5C;;;GAGG;AACH,+BAFU,MAAM,CAE2D;AAyB3E;;;GAGG;AACH,mCAFU,MAAM,CAEuB;AAIvC;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH;IAEI;;OAEG;IACH,+BAFW,MAAM,EAqBhB;IAjBG,mBAA+C;IAC/C,qBAAqB;IAErB,qBAAkE;IAClE,oBAAiE;IAEjE,4BAA0D;IAG1D,0BAAoD;IACpD,uBAAiD;IAEjD,qBAAqB;IAGrB,yBAAmD;IACnD,qBAAqB;IAGzB;;OAEG;IACH,oBAEC;IAED;;OAEG;IACH,uBAEC;IAED;;;;;;;OAOG;IACH,UAJW,MAAM,OACN,MAAM,GACJ,MAAM,CAKlB;IAED;;;;;;;;OAQG;IACH,aAJW,MAAM,OACN,MAAM,GACJ,MAAM,CAwBlB;IAED;;;OAGG;IACH,YAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;OAGG;IACH,YAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;OAGG;IACH,oBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;OAGG;IACH,iBAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;OAGG;IACH,uBAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;;;OAKG;IACH,WAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;OAKG;IACH,qBAFW,MAAM,QAQhB;IAED;;;;;;;;;;;;;OAaG;IACH,mBAFW,MAAM,QAKhB;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IACH,kBAnBW,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,SACN,MAAM,eACN,MAAM,aAGN,MAAM,gBAEN,MAAM,QAwBhB;IAED;;;;;OAKG;IACH,kBAJW,MAAM,OACN,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;OAKG;IACH,qBAJW,MAAM,OACN,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;;;;;;;;;;;OAeG;IACH,qBAHW,MAAM,OACN,MAAM,QAOhB;IAED;;;;;OAKG;IACH,oBAJW,MAAM,OACN,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;;OAMG;IACH,kBALW,MAAM,OACN,MAAM,OACN,MAAM,EAAE,GAAC,YAAY,cACrB,MAAM,QAOhB;IAED;;;;;;OAMG;IACH,uBAJW,MAAM,OACN,MAAM,GACJ,MAAM,CAIlB;IAED,iEAAiE;IACjE,uBADY,MAAM,OAAe,MAAM,GAAgB,MAAM,CAG5D;IAED,iEAAiE;IACjE,uBADY,MAAM,OAAe,MAAM,GAAgB,MAAM,CAG5D;IAED,iEAAiE;IACjE,oBADY,MAAM,OAAe,MAAM,GAAgB,MAAM,CAG5D;IAED;;;;;OAKG;IACH,gCAEC;IAED;;;;;;OAMG;IACH,uBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;OAGG;IACH,sBA6BC;IAED;;;OAGG;IACH,wBAcC;IAED;;;OAGG;IACH,uBAkBC;IAED;;OAEG;IACH,eA8BC;IAED;;;OAGG;IACH,oBAaC;IAED;;;OAGG;IACH,mBAqBC;CACJ;8BA3lBqD,2CAA2C"}