@woosh/meep-engine 3.36.0 → 3.38.0

package/src/engine/physics/cloth/ecs/ClothInstance.d.ts

@@ -443,8 +443,8 @@ export class ClothInstance {
      * The index handles this cloth last **stepped against**, in the order the
      * broadphase returned them, and how many of them are meaningful.
      *
-     * §7 P5's wake test compares each overlapping collider's previous pose with
-     * its current one, and `ClothColliderSystem#link` *places* a new collider —
+     * §7 P5's wake test compares each overlapping collider's revision with the
+     * last simulated step, and `ClothColliderSystem#link` *places* a new collider —
      * previous equals current — so a collider spawned around a sleeping cloth
      * is one that has not moved and never woke it. The set is the other half of
      * that question: a handle appearing or leaving is a change to the world the
@@ -456,6 +456,19 @@ export class ClothInstance {
      * @type {number}
      */
     collider_key_count: number;
+    /**
+     * Revision of each collider at the last simulated gather. Unlike comparing
+     * swept poses, this also detects a placement or a changed surface.
+     * @type {Uint32Array}
+     */
+    collider_revisions: Uint32Array;
+    /**
+     * Revisions captured alongside the current solver table. The remember
+     * operation copies this snapshot, so index edits after gathering still
+     * wake the cloth and the public two-argument remember API needs no index.
+     * @type {Uint32Array}
+     */
+    gathered_collider_revisions: Uint32Array;
     /**
      * The broadphase margin the last gather used, metres. The wake test has to
      * query with the same one, or it compares a set built under one reach with

package/src/engine/physics/cloth/ecs/ClothInstance.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ClothInstance.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/ecs/ClothInstance.js"],"names":[],"mappings":"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"}
+{"version":3,"file":"ClothInstance.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/ecs/ClothInstance.js"],"names":[],"mappings":"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"}

package/src/engine/physics/cloth/ecs/ClothInstance.js

@@ -498,8 +498,8 @@ export class ClothInstance {
      * The index handles this cloth last **stepped against**, in the order the
      * broadphase returned them, and how many of them are meaningful.
      *
-     * §7 P5's wake test compares each overlapping collider's previous pose with
-     * its current one, and `ClothColliderSystem#link` *places* a new collider —
+     * §7 P5's wake test compares each overlapping collider's revision with the
+     * last simulated step, and `ClothColliderSystem#link` *places* a new collider —
      * previous equals current — so a collider spawned around a sleeping cloth
      * is one that has not moved and never woke it. The set is the other half of
      * that question: a handle appearing or leaving is a change to the world the
@@ -513,6 +513,21 @@ export class ClothInstance {
      */
     collider_key_count = 0;
 
+    /**
+     * Revision of each collider at the last simulated gather. Unlike comparing
+     * swept poses, this also detects a placement or a changed surface.
+     * @type {Uint32Array}
+     */
+    collider_revisions = new Uint32Array(CLOTH_COLLIDER_SLOTS);
+
+    /**
+     * Revisions captured alongside the current solver table. The remember
+     * operation copies this snapshot, so index edits after gathering still
+     * wake the cloth and the public two-argument remember API needs no index.
+     * @type {Uint32Array}
+     */
+    gathered_collider_revisions = new Uint32Array(CLOTH_COLLIDER_SLOTS);
+
     /**
      * The broadphase margin the last gather used, metres. The wake test has to
      * query with the same one, or it compares a set built under one reach with

package/src/engine/physics/cloth/ecs/ClothWorld.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ClothWorld.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/ecs/ClothWorld.js"],"names":[],"mappings":"AA2DA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiFG;AACH;IAEI;;;OAGG;IACH,SAFU,YAAY,CAEoB;IAE1C;;;;;;;;;;;;OAYG;IACH,WAFU,aAAa,EAAE,CAEV;IAEf;;;;;;;;;;;;;;;OAeG;IACH,QAFU;QAAC,WAAW,SAAW,MAAM,KAAG,CAAC,iBAAe,IAAI,CAAC,CAAA;KAAC,GAAC,IAAI,CAEvD;IAEd;;OAEG;IACH,eAFU,gBAAc,IAAI,CAEP;IAErB;;OAEG;IACH,aAFU,yBAAyB,GAAC,IAAI,CAErB;IAEnB;;;;;;OAMG;IACH,WAFU,mBAAmB,GAAC,IAAI,CAEjB;IAEjB;;;;;;;;;;;;;;;;;;OAkBG;IACH,MAFU,oBAAkB,IAAI,CAEpB;IAEZ;;;;;;;;;;;;;;;;;;;OAmBG;IACH,MAFU,MAAM,CAEP;IAET;;;;;OAKG;IACH,uBAAmB;IAEnB;;;;;OAKG;IACH,cAFU,OAAO,CAEI;IAErB;;;OAGG;IACH,oBAAwB;IAExB;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,uBAKE;IAEF;;;;;OAKG;IACH,2CAiBC;IAED;;;;;OAKG;IACH,YALW,KAAK,kCAEL,MAAM,GACJ,aAAa,CAczB;IAED;;;;;;;;OAQG;IACH,iDAFa,IAAI,CAIhB;IAED;;;OAGG;IACH,iDAFa,IAAI,CAIhB;IAED;;;OAGG;IACH,eAHW,MAAM,GACJ,aAAa,GAAC,SAAS,CA0BnC;IAyED;;;;;;;;;;;OAWG;IACH,eAHW,MAAM,GACJ,aAAa,GAAC,SAAS,CAanC;IAED;;;;;;;OAOG;IACH,aAHW,MAAM,GACJ,IAAI,CAShB;IAED;;;OAGG;IACH,mBAHW,MAAM,GACJ,aAAa,GAAC,SAAS,CAInC;IAED;;;;;OAKG;IACH,uCAFW,MAAM,QAgBhB;IAED;;;;;;;;;OASG;IACH,wBANW,aAAa,mCAEb,MAAM,GACJ,OAAO,CA8BnB;IAED;;;;;;;OAOG;IACH,iBAJW,aAAa,gCAEX,IAAI,CA4ChB;IAwFD;;;;;;;;;;;OAWG;IACH,kBAPW,aAAa,MACb,MAAM,UACN,YAAY,UACZ,MAAM,GACJ,OAAO,CAgPnB;;CA8EJ;8BAj/B6B,oBAAoB;0CAjB3C,gEAAgE;oCAcnC,0BAA0B;sBA4BxC,YAAY"}
+{"version":3,"file":"ClothWorld.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/ecs/ClothWorld.js"],"names":[],"mappings":"AA2DA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiFG;AACH;IAEI;;;OAGG;IACH,SAFU,YAAY,CAEoB;IAE1C;;;;;;;;;;;;OAYG;IACH,WAFU,aAAa,EAAE,CAEV;IAEf;;;;;;;;;;;;;;;OAeG;IACH,QAFU;QAAC,WAAW,SAAW,MAAM,KAAG,CAAC,iBAAe,IAAI,CAAC,CAAA;KAAC,GAAC,IAAI,CAEvD;IAEd;;OAEG;IACH,eAFU,gBAAc,IAAI,CAEP;IAErB;;OAEG;IACH,aAFU,yBAAyB,GAAC,IAAI,CAErB;IAEnB;;;;;;OAMG;IACH,WAFU,mBAAmB,GAAC,IAAI,CAEjB;IAEjB;;;;;;;;;;;;;;;;;;OAkBG;IACH,MAFU,oBAAkB,IAAI,CAEpB;IAEZ;;;;;;;;;;;;;;;;;;;OAmBG;IACH,MAFU,MAAM,CAEP;IAET;;;;;OAKG;IACH,uBAAmB;IAEnB;;;;;OAKG;IACH,cAFU,OAAO,CAEI;IAErB;;;OAGG;IACH,oBAAwB;IAExB;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,uBAKE;IAEF;;;;;OAKG;IACH,2CAiBC;IAED;;;;;OAKG;IACH,YALW,KAAK,kCAEL,MAAM,GACJ,aAAa,CAczB;IAED;;;;;;;;OAQG;IACH,iDAFa,IAAI,CAIhB;IAED;;;OAGG;IACH,iDAFa,IAAI,CAIhB;IAED;;;OAGG;IACH,eAHW,MAAM,GACJ,aAAa,GAAC,SAAS,CA0BnC;IAyED;;;;;;;;;;;OAWG;IACH,eAHW,MAAM,GACJ,aAAa,GAAC,SAAS,CAanC;IAED;;;;;;;OAOG;IACH,aAHW,MAAM,GACJ,IAAI,CAShB;IAED;;;OAGG;IACH,mBAHW,MAAM,GACJ,aAAa,GAAC,SAAS,CAInC;IAED;;;;;OAKG;IACH,uCAFW,MAAM,QAgBhB;IAED;;;;;;;;;OASG;IACH,wBANW,aAAa,mCAEb,MAAM,GACJ,OAAO,CA8BnB;IAED;;;;;;;OAOG;IACH,iBAJW,aAAa,gCAEX,IAAI,CA4ChB;IAwFD;;;;;;;;;;;OAWG;IACH,kBAPW,aAAa,MACb,MAAM,UACN,YAAY,UACZ,MAAM,GACJ,OAAO,CAmPnB;;CA8EJ;8BAp/B6B,oBAAoB;0CAjB3C,gEAAgE;oCAcnC,0BAA0B;sBA4BxC,YAAY"}

package/src/engine/physics/cloth/ecs/ClothWorld.js

@@ -787,9 +787,8 @@ export class ClothWorld {
         if (instance.asleep && this.colliders !== null && instance.state !== null) {
             // §7 P5's "wake on collider motion". A sleeping cloth is neither
             // stepped nor written back, so something has to notice the world it
-            // was resting against moving out from under it, and a broadphase
-            // query plus a pose comparison is three orders of magnitude cheaper
-            // than the step it decides whether to skip.
+            // was resting against moving out from under it. Query handles and
+            // revisions without preparing the solver's local collider table.
             if (cloth_colliders_moved(instance, this.colliders.index)) {
                 instance.asleep = false;
                 instance.still_steps = 0;
@@ -822,7 +821,7 @@ export class ClothWorld {
             return false;
         }
 
-        if (instance.anchor_valid) {
+        if (moved) {
             const displacement = Math.hypot(tx - previous_translation[0], ty - previous_translation[1], tz - previous_translation[2]);
 
             const teleport = displacement > Math.max(
@@ -839,6 +838,10 @@ export class ClothWorld {
                     previous_translation, previous_rotation
                 );
             }
+        } else if (instance.anchor_valid && instance.cloth.dynamics.inertia > 0) {
+            // The frame is identical. Preserve the pinning side effect of
+            // move_local_frame without rewriting every free position/velocity.
+            pin_anchor(instance);
         }
 
         previous_translation[0] = tx;
@@ -879,8 +882,8 @@ export class ClothWorld {
             cloth_gather_colliders(instance, this.colliders.index, reach);
 
             // What this cloth is about to step against, for the next wake test
-            // to compare with. Here rather than inside the gather because the
-            // wake test gathers too, and what it asks about is the set the last
+            // to compare with. Here rather than inside the query because the
+            // wake test queries too, and what it asks about is the set the last
             // *step* saw.
             cloth_remember_colliders(instance, reach);
         } else {
@@ -1172,6 +1175,16 @@ function move_local_frame(
         velocity[p + 2] += inertia * (CARRIED[2] - velocity[p + 2]);
     }
 
+    pin_anchor(instance);
+}
+
+/**
+ * @param {ClothInstance} instance
+ * @private
+ */
+function pin_anchor(instance) {
+    const position = instance.state.position;
+    const velocity = instance.state.velocity;
     // The anchor is pinned and is the origin of the frame it anchors, so it is
     // the one particle that must not be carried anywhere.
     const anchor = instance.particle_of_node[0] * 3;

package/src/engine/physics/cloth/ecs/cloth_gather_colliders.d.ts

@@ -23,10 +23,10 @@
  *
  * ## The query box
  *
- * The cloth's own particle bounds, fattened by exactly what
- * `cloth_contact_find` will reach for — no more, because a broadphase that is
- * wider than its narrowphase is collecting colliders it will then throw away.
- * {@link cloth_gather_reach} is that quantity and carries the derivation.
+ * The cloth's particle bounds are fattened by its contact radius and particle
+ * travel; the index supplies each collider's motion and inflation. Both sides
+ * include an outward rounding allowance for the solver's Float32 conversion.
+ * {@link cloth_gather_reach} carries the reach derivation.
  *
  * It used to be the velocity clamp of §7 P1 read as a distance. That was wrong
  * in both directions at once. The clamp is `4 · shortest_row · substeps ·
@@ -66,17 +66,16 @@
  *
  * The gather has one job the solver depends on: the set it hands over must
  * contain every collider `cloth_contact_find` would draw a row against. So the
- * margin is that function's own reach, maximised over the things the gather
- * cannot yet know — which collider, and which particle:
+ * reach is split between the cloth query and each collider's indexed bounds:
  *
  *     (radius + inflation) · (1 + CLOTH_CONTACT_MARGIN)   the contact itself
  *   + collider travel                                     §20, the collider's approach
  *   + |v| · dt                                            §54, the particle's own
  *
- * The radius term is added by {@link cloth_gather_colliders}, which knows the
- * cloth's `contact_radius`; this supplies the rest. Inflation and collider
- * travel come from the index as maxima over every live record, because the
- * gather has not queried yet and so cannot know which records it will get.
+ * The radius term is added by {@link cloth_gather_colliders}. This function
+ * supplies particle travel. The index expands each collider's swept bounds
+ * by its own travel and inflation, so an intersection covers the same sum
+ * without allowing one remote outlier to widen every cloth's query.
  *
  * **The velocity is read before the step and the narrowphase reads it after
  * `damp`**, which only ever scales it down — so this is an upper bound on the
@@ -92,13 +91,10 @@
  */
 export function cloth_gather_reach(state: ClothState, index: ClothColliderIndex, dt: number): number;
 /**
- * Query the index and rewrite the overlapping colliders into the cloth's frame.
- *
- * @param {ClothInstance} instance read for its anchor pose and filter; its
- *   state's `collider_table`, `collider_key` and `collider_count` are filled
+ * Query the index and rewrite overlapping colliders into the cloth's frame.
+ * @param {ClothInstance} instance its state's collider table and keys are filled
  * @param {ClothColliderIndex} index
- * @param {number} reach how far past its particles the cloth has to look,
- *   metres — {@link cloth_gather_reach}
+ * @param {number} reach particle travel from {@link cloth_gather_reach}
  * @returns {number} how many colliders were gathered
  */
 export function cloth_gather_colliders(instance: ClothInstance, index: ClothColliderIndex, reach: number): number;
@@ -108,17 +104,19 @@ export function cloth_gather_colliders(instance: ClothInstance, index: ClothColl
  *
  * A sleeping cloth is not stepped and not written back, so something has to
  * notice when the world it was resting against changes. This is that something,
- * and it is a broadphase query plus two comparisons: cheaper than a step by
- * three orders of magnitude, which is what makes sleep worth having at all.
+ * and it queries handles and revisions without constructing a local collider
+ * table or changing solver memory.
  *
- * **Two comparisons, and the set is the one M2 did not have.** A pose
- * comparison answers "did anything move", and `ClothColliderSystem#link`
+ * **Two comparisons, and the set is the one M2 did not have.** A revision
+ * comparison answers "did anything change", and `ClothColliderSystem#link`
  * *places* a new collider rather than posing it — previous equals current — so
  * a sphere spawned around a sleeping rope is a collider that has not moved.
  * Measured: the rope slept through it and stayed asleep three hundred steps
  * later with four of its six links inside. A handle appearing in the gathered
  * set, or leaving it, is a change to the world the cloth went to sleep in
  * whatever the poses say, and it costs one integer compare per record.
+ * Revisions also detect placements (whose swept poses are equal), changed
+ * surfaces, and a removed handle reused while the cloth slept.
  *
  * The query uses the reach the cloth's last *step* gathered with, so the two
  * sets are answers to the same question. A set built at zero margin against one

package/src/engine/physics/cloth/ecs/cloth_gather_colliders.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cloth_gather_colliders.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/ecs/cloth_gather_colliders.js"],"names":[],"mappings":"AAgCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8DG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,qFAHW,MAAM,GACJ,MAAM,CAwBlB;AAED;;;;;;;;;GASG;AACH,kGAJW,MAAM,GAEJ,MAAM,CA6JlB;AAgDD;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,2FAFa,OAAO,CAoCnB;AAED;;;;;;;;GAQG;AACH,yEAHW,MAAM,GACJ,IAAI,CAehB"}
+{"version":3,"file":"cloth_gather_colliders.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/ecs/cloth_gather_colliders.js"],"names":[],"mappings":"AAuCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8DG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,qFAHW,MAAM,GACJ,MAAM,CAsBlB;AAyJD;;;;;;GAMG;AACH,kGAHW,MAAM,GACJ,MAAM,CAmBlB;AAgGD;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,2FAFa,OAAO,CAkBnB;AAED;;;;;;;;GAQG;AACH,yEAHW,MAAM,GACJ,IAAI,CAgBhB"}

package/src/engine/physics/cloth/ecs/cloth_gather_colliders.js

@@ -2,6 +2,12 @@ import { quat3_multiply } from "../../../../core/geom/3d/quaternion/quat3_multip
 import { v3_quaternion_apply } from "../../../../core/geom/vec3/v3_quaternion_apply.js";
 import { v3_quaternion_apply_inverse } from "../../../../core/geom/vec3/v3_quaternion_apply_inverse.js";
 import {
+    CCR_AABB_MAX_X,
+    CCR_AABB_MAX_Y,
+    CCR_AABB_MAX_Z,
+    CCR_AABB_MIN_X,
+    CCR_AABB_MIN_Y,
+    CCR_AABB_MIN_Z,
     CCR_FEATURE,
     CCR_FRICTION,
     CCR_INFLATION,
@@ -26,7 +32,8 @@ import {
     CCR_TY,
     CCR_TZ
 } from "../collider/ClothColliderRecord.js";
-import { cloth_collider_refit_bounds } from "../collider/cloth_collider_bounds.js";
+import { ClothColliderKind } from "../collider/ClothColliderKind.js";
+import { cloth_collider_refit_bounds, cloth_contact_rounding } from "../collider/cloth_collider_bounds.js";
 import { CLOTH_CONTACT_MARGIN } from "../solver/cloth_contact_find.js";
 import { CLOTH_COLLIDER_SLOTS } from "../solver/cloth_solver_constants.js";
 
@@ -55,10 +62,10 @@ import { CLOTH_COLLIDER_SLOTS } from "../solver/cloth_solver_constants.js";
  *
  * ## The query box
  *
- * The cloth's own particle bounds, fattened by exactly what
- * `cloth_contact_find` will reach for — no more, because a broadphase that is
- * wider than its narrowphase is collecting colliders it will then throw away.
- * {@link cloth_gather_reach} is that quantity and carries the derivation.
+ * The cloth's particle bounds are fattened by its contact radius and particle
+ * travel; the index supplies each collider's motion and inflation. Both sides
+ * include an outward rounding allowance for the solver's Float32 conversion.
+ * {@link cloth_gather_reach} carries the reach derivation.
  *
  * It used to be the velocity clamp of §7 P1 read as a distance. That was wrong
  * in both directions at once. The clamp is `4 · shortest_row · substeps ·
@@ -99,17 +106,16 @@ import { CLOTH_COLLIDER_SLOTS } from "../solver/cloth_solver_constants.js";
  *
  * The gather has one job the solver depends on: the set it hands over must
  * contain every collider `cloth_contact_find` would draw a row against. So the
- * margin is that function's own reach, maximised over the things the gather
- * cannot yet know — which collider, and which particle:
+ * reach is split between the cloth query and each collider's indexed bounds:
  *
  *     (radius + inflation) · (1 + CLOTH_CONTACT_MARGIN)   the contact itself
  *   + collider travel                                     §20, the collider's approach
  *   + |v| · dt                                            §54, the particle's own
  *
- * The radius term is added by {@link cloth_gather_colliders}, which knows the
- * cloth's `contact_radius`; this supplies the rest. Inflation and collider
- * travel come from the index as maxima over every live record, because the
- * gather has not queried yet and so cannot know which records it will get.
+ * The radius term is added by {@link cloth_gather_colliders}. This function
+ * supplies particle travel. The index expands each collider's swept bounds
+ * by its own travel and inflation, so an intersection covers the same sum
+ * without allowing one remote outlier to widen every cloth's query.
  *
  * **The velocity is read before the step and the narrowphase reads it after
  * `damp`**, which only ever scales it down — so this is an upper bound on the
@@ -142,22 +148,20 @@ export function cloth_gather_reach(state, index, dt) {
         }
     }
 
-    return dt * Math.sqrt(fastest_squared)
-        + index.max_collider_travel
-        + index.max_inflation * (1 + CLOTH_CONTACT_MARGIN);
+    return dt * Math.sqrt(fastest_squared);
 }
 
 /**
- * Query the index and rewrite the overlapping colliders into the cloth's frame.
+ * Query the index into HANDLES without touching the solver's collider table.
  *
- * @param {ClothInstance} instance read for its anchor pose and filter; its
- *   state's `collider_table`, `collider_key` and `collider_count` are filled
+ * @param {ClothInstance} instance read for its bounds, anchor pose and filter
  * @param {ClothColliderIndex} index
  * @param {number} reach how far past its particles the cloth has to look,
  *   metres — {@link cloth_gather_reach}
- * @returns {number} how many colliders were gathered
+ * @returns {number} how many handles fit in the collider table
+ * @private
  */
-export function cloth_gather_colliders(instance, index, reach) {
+function query_colliders(instance, index, reach) {
     const state = instance.state;
 
     const particle_count = state.particle_count;
@@ -186,22 +190,9 @@ export function cloth_gather_colliders(instance, index, reach) {
     }
 
     if (particle_count === 0) {
-        state.collider_count = 0;
-
         return 0;
     }
 
-    // The contact's own reach, on the same terms `cloth_contact_find` states
-    // it in, plus everything {@link cloth_gather_reach} already folded in.
-    const margin = reach + state.contact_radius * (1 + CLOTH_CONTACT_MARGIN);
-
-    min_x -= margin;
-    min_y -= margin;
-    min_z -= margin;
-    max_x += margin;
-    max_y += margin;
-    max_z += margin;
-
     // The anchor pose the particles were carried into this step, not the live
     // component — those are the same value by the time this runs, and the
     // cached pair is the one `move_local_frame` used.
@@ -214,6 +205,20 @@ export function cloth_gather_colliders(instance, index, reach) {
     const qz = instance.anchor_rotation[2];
     const qw = instance.anchor_rotation[3];
 
+    const contact_reach = reach + state.contact_radius * (1 + CLOTH_CONTACT_MARGIN);
+    const local_scale = Math.max(Math.abs(min_x), Math.abs(max_x))
+        + Math.max(Math.abs(min_y), Math.abs(max_y))
+        + Math.max(Math.abs(min_z), Math.abs(max_z)) + contact_reach;
+    const world_scale = local_scale + Math.abs(anchor_x) + Math.abs(anchor_y) + Math.abs(anchor_z);
+    const margin = contact_reach + cloth_contact_rounding(local_scale, world_scale);
+
+    min_x -= margin;
+    min_y -= margin;
+    min_z -= margin;
+    max_x += margin;
+    max_y += margin;
+    max_z += margin;
+
     // The local box's eight corners, in world. A rotated box is not a box, so
     // the world query volume is the bounds of the rotated one rather than the
     // rotation of the bounds.
@@ -247,12 +252,37 @@ export function cloth_gather_colliders(instance, index, reach) {
 
     const cloth = instance.cloth;
 
-    const overlapping = index.query(
+    const candidates = index.query(
         HANDLES, world_min_x, world_min_y, world_min_z,
         world_max_x, world_max_y, world_max_z,
-        cloth.layer, cloth.mask
+        cloth.layer, cloth.mask, true
     );
 
+    // A half-space has no bounded world-space conversion allowance, so the
+    // index keeps every plane. Reject separated planes in the exact Float32
+    // frame used by the solver, BEFORE applying the table limit. Otherwise
+    // distant floors can consume all slots and hide a real nearby contact.
+    let overlapping = 0;
+    const source = index.table;
+    for (let i = 0; i < candidates; i++) {
+        const handle = HANDLES[i];
+        if (source[handle * CCR_STRIDE + CCR_KIND] === ClothColliderKind.Plane) {
+            localise_record(PLANE_RECORD, 0, source, handle, instance);
+            const extra = Math.max(0, PLANE_RECORD[CCR_INFLATION]) * (1 + CLOTH_CONTACT_MARGIN)
+                + Math.hypot(
+                    PLANE_RECORD[CCR_TX] - PLANE_RECORD[CCR_PREV_TX],
+                    PLANE_RECORD[CCR_TY] - PLANE_RECORD[CCR_PREV_TY],
+                    PLANE_RECORD[CCR_TZ] - PLANE_RECORD[CCR_PREV_TZ]
+                );
+            if (max_x + extra < PLANE_RECORD[CCR_AABB_MIN_X] || min_x - extra > PLANE_RECORD[CCR_AABB_MAX_X]
+                || max_y + extra < PLANE_RECORD[CCR_AABB_MIN_Y] || min_y - extra > PLANE_RECORD[CCR_AABB_MAX_Y]
+                || max_z + extra < PLANE_RECORD[CCR_AABB_MIN_Z] || min_z - extra > PLANE_RECORD[CCR_AABB_MAX_Z]) {
+                continue;
+            }
+        }
+        HANDLES[overlapping++] = handle;
+    }
+
     let found = overlapping;
 
     if (found > CLOTH_COLLIDER_SLOTS) {
@@ -269,44 +299,28 @@ export function cloth_gather_colliders(instance, index, reach) {
         }
     }
 
+    return found;
+}
+
+/**
+ * Query the index and rewrite overlapping colliders into the cloth's frame.
+ * @param {ClothInstance} instance its state's collider table and keys are filled
+ * @param {ClothColliderIndex} index
+ * @param {number} reach particle travel from {@link cloth_gather_reach}
+ * @returns {number} how many colliders were gathered
+ */
+export function cloth_gather_colliders(instance, index, reach) {
+    const found = query_colliders(instance, index, reach);
+    const state = instance.state;
     const table = state.collider_table;
     const keys = state.collider_key;
-
     const source = index.table;
 
     for (let i = 0; i < found; i++) {
         const handle = HANDLES[i];
-
-        const from = handle * CCR_STRIDE;
-        const to = i * CCR_STRIDE;
-
         keys[i] = handle;
-
-        table[to + CCR_KIND] = source[from + CCR_KIND];
-        table[to + CCR_PARAM_0] = source[from + CCR_PARAM_0];
-        table[to + CCR_PARAM_1] = source[from + CCR_PARAM_1];
-        table[to + CCR_PARAM_2] = source[from + CCR_PARAM_2];
-        table[to + CCR_PARAM_3] = source[from + CCR_PARAM_3];
-        table[to + CCR_FEATURE] = source[from + CCR_FEATURE];
-        table[to + CCR_FRICTION] = source[from + CCR_FRICTION];
-        table[to + CCR_INFLATION] = source[from + CCR_INFLATION];
-
-        localise(
-            table, to + CCR_TX, to + CCR_QX,
-            source[from + CCR_TX], source[from + CCR_TY], source[from + CCR_TZ],
-            source[from + CCR_QX], source[from + CCR_QY], source[from + CCR_QZ], source[from + CCR_QW],
-            anchor_x, anchor_y, anchor_z, qx, qy, qz, qw
-        );
-
-        localise(
-            table, to + CCR_PREV_TX, to + CCR_PREV_QX,
-            source[from + CCR_PREV_TX], source[from + CCR_PREV_TY], source[from + CCR_PREV_TZ],
-            source[from + CCR_PREV_QX], source[from + CCR_PREV_QY],
-            source[from + CCR_PREV_QZ], source[from + CCR_PREV_QW],
-            anchor_x, anchor_y, anchor_z, qx, qy, qz, qw
-        );
-
-        cloth_collider_refit_bounds(table, i, CCR_STRIDE);
+        instance.gathered_collider_revisions[i] = index.revisionOf(handle);
+        localise_record(table, i, source, handle, instance);
     }
 
     state.collider_count = found;
@@ -314,6 +328,54 @@ export function cloth_gather_colliders(instance, index, reach) {
     return found;
 }
 
+/**
+ * Convert a complete record using the solver's storage precision. Shared with
+ * the plane prefilter so its bounds and travel match what discovery will read.
+ * @param {Float32Array} table
+ * @param {number} record
+ * @param {Float64Array} source
+ * @param {number} handle
+ * @param {ClothInstance} instance
+ * @private
+ */
+function localise_record(table, record, source, handle, instance) {
+    const anchor_x = instance.anchor_translation[0];
+    const anchor_y = instance.anchor_translation[1];
+    const anchor_z = instance.anchor_translation[2];
+    const qx = instance.anchor_rotation[0];
+    const qy = instance.anchor_rotation[1];
+    const qz = instance.anchor_rotation[2];
+    const qw = instance.anchor_rotation[3];
+    const from = handle * CCR_STRIDE;
+    const to = record * CCR_STRIDE;
+
+    table[to + CCR_KIND] = source[from + CCR_KIND];
+    table[to + CCR_PARAM_0] = source[from + CCR_PARAM_0];
+    table[to + CCR_PARAM_1] = source[from + CCR_PARAM_1];
+    table[to + CCR_PARAM_2] = source[from + CCR_PARAM_2];
+    table[to + CCR_PARAM_3] = source[from + CCR_PARAM_3];
+    table[to + CCR_FEATURE] = source[from + CCR_FEATURE];
+    table[to + CCR_FRICTION] = source[from + CCR_FRICTION];
+    table[to + CCR_INFLATION] = source[from + CCR_INFLATION];
+
+    localise(
+        table, to + CCR_TX, to + CCR_QX,
+        source[from + CCR_TX], source[from + CCR_TY], source[from + CCR_TZ],
+        source[from + CCR_QX], source[from + CCR_QY], source[from + CCR_QZ], source[from + CCR_QW],
+        anchor_x, anchor_y, anchor_z, qx, qy, qz, qw
+    );
+
+    localise(
+        table, to + CCR_PREV_TX, to + CCR_PREV_QX,
+        source[from + CCR_PREV_TX], source[from + CCR_PREV_TY], source[from + CCR_PREV_TZ],
+        source[from + CCR_PREV_QX], source[from + CCR_PREV_QY],
+        source[from + CCR_PREV_QZ], source[from + CCR_PREV_QW],
+        anchor_x, anchor_y, anchor_z, qx, qy, qz, qw
+    );
+
+    cloth_collider_refit_bounds(table, record, CCR_STRIDE);
+}
+
 /**
  * Write a world pose into a record's translation and rotation slots, expressed
  * in the anchor's frame.
@@ -366,17 +428,19 @@ function localise(
  *
  * A sleeping cloth is not stepped and not written back, so something has to
  * notice when the world it was resting against changes. This is that something,
- * and it is a broadphase query plus two comparisons: cheaper than a step by
- * three orders of magnitude, which is what makes sleep worth having at all.
+ * and it queries handles and revisions without constructing a local collider
+ * table or changing solver memory.
  *
- * **Two comparisons, and the set is the one M2 did not have.** A pose
- * comparison answers "did anything move", and `ClothColliderSystem#link`
+ * **Two comparisons, and the set is the one M2 did not have.** A revision
+ * comparison answers "did anything change", and `ClothColliderSystem#link`
  * *places* a new collider rather than posing it — previous equals current — so
  * a sphere spawned around a sleeping rope is a collider that has not moved.
  * Measured: the rope slept through it and stayed asleep three hundred steps
  * later with four of its six links inside. A handle appearing in the gathered
  * set, or leaving it, is a change to the world the cloth went to sleep in
  * whatever the poses say, and it costs one integer compare per record.
+ * Revisions also detect placements (whose swept poses are equal), changed
+ * surfaces, and a removed handle reused while the cloth slept.
  *
  * The query uses the reach the cloth's last *step* gathered with, so the two
  * sets are answers to the same question. A set built at zero margin against one
@@ -387,9 +451,7 @@ function localise(
  * @returns {boolean}
  */
 export function cloth_colliders_moved(instance, index) {
-    const found = cloth_gather_colliders(instance, index, instance.gather_reach);
-
-    const keys = instance.state.collider_key;
+    const found = query_colliders(instance, index, instance.gather_reach);
 
     if (found !== instance.collider_key_count) {
         return true;
@@ -398,23 +460,7 @@ export function cloth_colliders_moved(instance, index) {
     const seen = instance.collider_keys;
 
     for (let i = 0; i < found; i++) {
-        if (keys[i] !== seen[i]) {
-            return true;
-        }
-    }
-
-    const table = instance.state.collider_table;
-
-    for (let i = 0; i < found; i++) {
-        const r = i * CCR_STRIDE;
-
-        if (table[r + CCR_TX] !== table[r + CCR_PREV_TX]
-            || table[r + CCR_TY] !== table[r + CCR_PREV_TY]
-            || table[r + CCR_TZ] !== table[r + CCR_PREV_TZ]
-            || table[r + CCR_QX] !== table[r + CCR_PREV_QX]
-            || table[r + CCR_QY] !== table[r + CCR_PREV_QY]
-            || table[r + CCR_QZ] !== table[r + CCR_PREV_QZ]
-            || table[r + CCR_QW] !== table[r + CCR_PREV_QW]) {
+        if (HANDLES[i] !== seen[i] || index.revisionOf(HANDLES[i]) !== instance.collider_revisions[i]) {
             return true;
         }
     }
@@ -440,6 +486,7 @@ export function cloth_remember_colliders(instance, reach) {
 
     for (let i = 0; i < count; i++) {
         seen[i] = keys[i];
+        instance.collider_revisions[i] = instance.gathered_collider_revisions[i];
     }
 
     instance.collider_key_count = count;
@@ -452,6 +499,9 @@ export function cloth_remember_colliders(instance, reach) {
  */
 const HANDLES = [];
 
+/** @type {Float32Array} @private */
+const PLANE_RECORD = new Float32Array(CCR_STRIDE);
+
 /**
  * @type {Float64Array}
  * @private

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

@@ -1 +1 @@
-{"version":3,"file":"PhysicsSystem.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/ecs/PhysicsSystem.js"],"names":[],"mappings":"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"}
+{"version":3,"file":"PhysicsSystem.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/ecs/PhysicsSystem.js"],"names":[],"mappings":"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"}