@woosh/meep-engine 2.145.0 → 2.147.0

package/src/engine/physics/ecs/PhysicsSystem.js

@@ -1,4 +1,5 @@
 import { assert } from "../../../core/assert.js";
+import { BinaryBuffer } from "../../../core/binary/BinaryBuffer.js";
 import { BVH } from "../../../core/bvh2/bvh3/BVH.js";
 import Signal from "../../../core/events/signal/Signal.js";
 import Vector3 from "../../../core/geom/Vector3.js";
@@ -21,6 +22,7 @@ import { narrowphase_step } from "../narrowphase/narrowphase_step.js";
 import { overlap_shape as overlap_shape_query } from "../queries/overlap_shape.js";
 import { raycast as raycast_query } from "../queries/raycast.js";
 import { shape_cast as shape_cast_query } from "../queries/shape_cast.js";
+import { ccd_resolve } from "../ccd/linear_sweep.js";
 import { returnTrue } from "../../../core/function/returnTrue.js";
 import {
     prepare_contacts,
@@ -46,6 +48,7 @@ import { Collider, COLLIDER_UNBOUND } from "./Collider.js";
 import { RIGID_BODY_UNALLOCATED, RigidBody } from "./RigidBody.js";
 import { RigidBodyFlags } from "./RigidBodyFlags.js";
 import { SleepState } from "./SleepState.js";
+import { Interpolated } from "../../interpolation/Interpolated.js";
 
 /**
  * Reusable scratch buffer for world-AABB construction so the link path is
@@ -294,6 +297,23 @@ export class PhysicsSystem extends System {
          */
         this.__pseudo_velocity = new Float64Array(0);
 
+        /**
+         * Master switch for the continuous-collision pass. When false the
+         * {@link RigidBodyFlags.CCD} flag is ignored and no swept queries run.
+         * @type {boolean}
+         */
+        this.ccdEnabled = true;
+
+        /**
+         * Start-of-step world positions for CCD-flagged bodies — 3 doubles per
+         * body slot index (`[x, y, z]`). Captured in Stage 1 before the substep
+         * loop integrates poses; the CCD pass ({@link ccd_resolve}) sweeps from
+         * here to the final pose. Grows to `storage.high_water_mark * 3`; only
+         * CCD-flagged slots are written each step.
+         * @type {Float64Array}
+         */
+        this.__ccd_start_pos = new Float64Array(0);
+
         /**
          * Bound reference to {@link __pair_filter} so we hand the same
          * callable to {@link generate_pairs} each step without per-step
@@ -301,6 +321,26 @@ export class PhysicsSystem extends System {
          * @private
          */
         this.__pair_filter_bound = (idA, idB) => this.__pair_filter(idA, idB);
+
+        /**
+         * Optional shared interpolation log to produce per-step pose snapshots
+         * into (the {@link InterpolationSystem}'s log). When set — and only then —
+         * each fixedUpdate restores every awake {@link Interpolated} body's live
+         * components from the previous tick (undoing render-time interpolation so
+         * the sim reads authoritative state), then records the post-step state
+         * under the current `entityManager.fixedStepTick`. Null on a headless /
+         * non-rendering world, where the producer work is skipped entirely.
+         * @type {InterpolationLog|null}
+         */
+        this.interpolationLog = null;
+
+        /**
+         * Reusable decode buffer for restoring interpolated snapshots.
+         * @private
+         * @type {BinaryBuffer}
+         */
+        this.__interp_scratch = new BinaryBuffer();
+        this.__interp_scratch.fromArrayBuffer(new ArrayBuffer(256));
     }
 
     /**
@@ -586,20 +626,16 @@ export class PhysicsSystem extends System {
     }
 
     /**
-     * Linear scan over body slots looking for the one whose entity matches.
-     * O(N) where N is the live body count — only called on the link/unlink
-     * paths, not during simulation, so the scan cost is bounded.
+     * Resolve an entity to its body index, or -1 if no live body owns it.
+     * O(1) via {@link BodyStorage#index_of_entity}'s entity → index map — used
+     * on the collider attach / detach and joint link paths.
      *
      * @private
      * @param {number} entity
      * @returns {number} body index or -1
      */
     __find_body_index_by_entity(entity) {
-        const hwm = this.storage.high_water_mark;
-        for (let i = 0; i < hwm; i++) {
-            if (this.storage.entity_at(i) === entity) return i;
-        }
-        return -1;
+        return this.storage.index_of_entity(entity);
     }
 
     /**
@@ -815,6 +851,50 @@ export class PhysicsSystem extends System {
         }
     }
 
+    /**
+     * Teleport a body to a new pose, bypassing integration: writes the body's
+     * Transform directly and wakes it. For an interpolated body this also flags a
+     * render `snap` on its {@link Interpolated} component, so the producer keeps
+     * this pose (rather than restoring the previous tick over it) and the
+     * renderer shows the new pose without sliding across the jump.
+     *
+     * This is the authoritative way to reposition an interpolated body — a raw
+     * `Transform` write would be undone by the per-step restore. Velocity is left
+     * as-is; zero it via {@link setLinearVelocity} if the teleport should also
+     * stop the body.
+     *
+     * @param {RigidBody} rigidBody
+     * @param {Vector3|{x:number,y:number,z:number}} position world position
+     * @param {Quaternion|{x:number,y:number,z:number,w:number}} rotation world unit-quaternion rotation
+     */
+    setPose(rigidBody, position, rotation) {
+        const idx = body_id_index(rigidBody._bodyId);
+        const transform = this.__transforms[idx];
+        if (transform === undefined) {
+            return;
+        }
+
+        transform.position.set(position.x, position.y, position.z);
+        transform.rotation.set(rotation.x, rotation.y, rotation.z, rotation.w);
+
+        this.__wake_body(rigidBody);
+
+        // Flag a snap on the body's Interpolated component, if any, so the
+        // interpolation producer (restore) and consumer (blend) treat this pose
+        // as authoritative this frame instead of interpolating across the jump.
+        const em = this.entityManager;
+        if (em !== null && em !== undefined) {
+            const dataset = em.dataset;
+            if (dataset !== null && dataset !== undefined) {
+                const entity = this.storage.entity_at(idx);
+                const interpolated = dataset.getComponent(entity, Interpolated);
+                if (interpolated !== undefined && interpolated !== null) {
+                    interpolated.snap = true;
+                }
+            }
+        }
+    }
+
     /**
      * Force the body awake. Static bodies are ignored.
      * @param {RigidBody} rigidBody
@@ -1259,7 +1339,103 @@ export class PhysicsSystem extends System {
         }
     }
 
+    /**
+     * Producer — restore pass. At the top of a fixed step, reset every awake
+     * {@link Interpolated} body's live components to their authoritative state
+     * from the previous tick's snapshot, undoing any render-time interpolation
+     * the {@link InterpolationSystem} wrote between frames so the sim integrates
+     * from truth, not an interpolated pose. A body with no previous snapshot
+     * (first step ever, or just woken) is left as-is — its live state is already
+     * authoritative. No-op unless {@link interpolationLog} is wired.
+     * @private
+     */
+    __interp_restore() {
+        const log = this.interpolationLog;
+        const em = this.entityManager;
+        if (log === null || em === null || em === undefined) return;
+        const dataset = em.dataset;
+        if (dataset === null || dataset === undefined) return;
+
+        const prev_tick = em.fixedStepTick - 1;
+        if (prev_tick < 0) return;
+
+        const storage = this.storage;
+        const count = storage.awake_count;
+        const scratch = this.__interp_scratch;
+
+        for (let i = 0; i < count; i++) {
+            const idx = storage.awake_at(i);
+            const entity = storage.entity_at(idx);
+            const interpolated = dataset.getComponent(entity, Interpolated);
+            if (interpolated === undefined || interpolated === null) continue;
+            // A teleported body (snap set, e.g. via setPose) keeps its live pose
+            // this step — restoring the previous tick would undo the teleport.
+            if (interpolated.snap) continue;
+            const key = interpolated.key;
+            if (key < 0) continue;
+
+            const interpolands = interpolated.interpolands;
+            for (let k = 0; k < interpolands.length; k++) {
+                const ip = interpolands[k];
+                scratch.position = 0;
+                // Snap to the previous tick's snapshot (both offsets equal → t irrelevant).
+                const ok = log.interpolate(scratch, key, ip.type_id, prev_tick, prev_tick, 0, ip.interpolation_adapter);
+                if (!ok) continue;
+                const target = dataset.getComponent(entity, ip.component_class);
+                if (target === undefined || target === null) continue;
+                scratch.position = 0;
+                ip.serialization_adapter.deserialize(scratch, target);
+            }
+        }
+    }
+
+    /**
+     * Producer — record pass. At the end of a fixed step, snapshot every awake
+     * {@link Interpolated} body's live components into the shared log under the
+     * current `entityManager.fixedStepTick`. The render-time
+     * {@link InterpolationSystem} blends consecutive ticks from these snapshots.
+     * Only awake (moving) bodies are recorded, so the log stays sparse. No-op
+     * unless {@link interpolationLog} is wired.
+     * @private
+     */
+    __interp_record() {
+        const log = this.interpolationLog;
+        const em = this.entityManager;
+        if (log === null || em === null || em === undefined) return;
+        const dataset = em.dataset;
+        if (dataset === null || dataset === undefined) return;
+
+        const tick = em.fixedStepTick;
+        const storage = this.storage;
+        const count = storage.awake_count;
+
+        log.begin_tick(tick);
+        for (let i = 0; i < count; i++) {
+            const idx = storage.awake_at(i);
+            const entity = storage.entity_at(idx);
+            const interpolated = dataset.getComponent(entity, Interpolated);
+            if (interpolated === undefined || interpolated === null) continue;
+            const key = interpolated.key;
+            if (key < 0) continue;
+
+            const interpolands = interpolated.interpolands;
+            for (let k = 0; k < interpolands.length; k++) {
+                const ip = interpolands[k];
+                const target = dataset.getComponent(entity, ip.component_class);
+                if (target === undefined || target === null) continue;
+                const buf = log.begin_record(key, ip.type_id);
+                ip.serialization_adapter.serialize(buf, target);
+                log.end_record();
+            }
+        }
+        log.end_tick();
+    }
+
     fixedUpdate(dt) {
+        // Producer: restore authoritative pose (undo render interpolation)
+        // before the sim reads any Transform this step.
+        this.__interp_restore();
+
         const gx = this.gravity.x;
         const gy = this.gravity.y;
         const gz = this.gravity.z;
@@ -1347,6 +1523,34 @@ export class PhysicsSystem extends System {
         const h = dt / N;
         const count_after_wake = this.storage.awake_count;
 
+        // CCD: capture start-of-step positions for flagged bodies over the
+        // post-wake awake set (poses are unchanged until the substep loop below
+        // integrates them). The CCD pass after the solver sweeps from here to
+        // each body's final pose. Reads the primary collider's transform so the
+        // start matches the end the resolve pass reads. Zero-cost when no body
+        // is flagged.
+        const ccd_on = this.ccdEnabled;
+        if (ccd_on) {
+            const ccd_need = this.storage.high_water_mark * 3;
+            if (this.__ccd_start_pos.length < ccd_need) {
+                this.__ccd_start_pos = new Float64Array(ccd_need);
+            }
+            const ccd_start = this.__ccd_start_pos;
+            for (let i = 0; i < count_after_wake; i++) {
+                const idx = this.storage.awake_at(i);
+                const rb = this.__bodies[idx];
+                if (rb.kind !== BodyKind.Dynamic) continue;
+                if ((rb.flags & RigidBodyFlags.CCD) === 0) continue;
+                const list = this.__body_collider_lists[idx];
+                if (list === undefined || list.length === 0) continue;
+                const cp = list[0].transform.position;
+                const cb = idx * 3;
+                ccd_start[cb] = cp[0];
+                ccd_start[cb + 1] = cp[1];
+                ccd_start[cb + 2] = cp[2];
+            }
+        }
+
         // Size the pseudo-velocity buffer ONCE (it may reallocate on growth),
         // then capture the reference. Inside the loop we only zero its live
         // region per substep — re-capturing is unnecessary since it won't
@@ -1403,6 +1607,21 @@ export class PhysicsSystem extends System {
         // the approach velocity captured at prepare time.
         apply_restitution(this.manifolds, this);
 
+        // Stage 8.5: continuous collision — sweep CCD-flagged fast movers along
+        // their net step translation and stop them at the first blocker, so they
+        // can't tunnel through thin geometry between discrete steps. Runs on the
+        // final post-solve poses, before the sleep test sees the clamped
+        // velocities. No-op when no awake body is flagged.
+        if (ccd_on) {
+            ccd_resolve(this);
+        }
+
+        // Producer: record the post-step authoritative pose of every awake
+        // interpolated body under this step's tick. Before the sleep test, so a
+        // body that settles this step still records its final pose for the last
+        // interpolation interval.
+        this.__interp_record();
+
         // Stage 9: sleep test.
         this.__sleep_test(dt);
 

package/src/engine/physics/ecs/RigidBodyFlags.d.ts

@@ -8,6 +8,11 @@
  *   component during solve.
  * - {@link DisableSleep }: this body never enters the sleeping set. Bodies near it
  *   may still sleep when stable.
+ * - {@link CCD }: opt-in continuous collision detection. After the solver, the
+ *   body's net step translation is shape-cast against the broadphase and the
+ *   body is stopped at the first blocker, so a fast mover can't tunnel through
+ *   thin geometry between discrete steps. Off by default — it costs one swept
+ *   query per fast-moving flagged body per step. See `ccd/linear_sweep.js`.
  */
 export type RigidBodyFlags = number;
 export namespace RigidBodyFlags {
@@ -17,5 +22,6 @@ export namespace RigidBodyFlags {
     let LockRotY: number;
     let LockRotZ: number;
     let DisableSleep: number;
+    let CCD: number;
 }
 //# sourceMappingURL=RigidBodyFlags.d.ts.map

package/src/engine/physics/ecs/RigidBodyFlags.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"RigidBodyFlags.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/ecs/RigidBodyFlags.js"],"names":[],"mappings":";;;;;;;;;;;6BAYU,MAAM"}
+{"version":3,"file":"RigidBodyFlags.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/ecs/RigidBodyFlags.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;6BAiBU,MAAM"}

package/src/engine/physics/ecs/RigidBodyFlags.js

@@ -8,6 +8,11 @@
  *   component during solve.
  * - {@link DisableSleep}: this body never enters the sleeping set. Bodies near it
  *   may still sleep when stable.
+ * - {@link CCD}: opt-in continuous collision detection. After the solver, the
+ *   body's net step translation is shape-cast against the broadphase and the
+ *   body is stopped at the first blocker, so a fast mover can't tunnel through
+ *   thin geometry between discrete steps. Off by default — it costs one swept
+ *   query per fast-moving flagged body per step. See `ccd/linear_sweep.js`.
  *
  * @readonly
  * @enum {number}
@@ -19,4 +24,5 @@ export const RigidBodyFlags = {
     LockRotY: 4,
     LockRotZ: 8,
     DisableSleep: 16,
+    CCD: 32,
 };