@woosh/meep-engine 3.36.0 → 3.38.0

package/src/engine/physics/cloth/collider/ClothColliderIndex.d.ts

@@ -104,25 +104,16 @@ export class ClothColliderIndex {
     /**
      * The widest {@link CCR_INFLATION} any live record carries, metres.
      *
-     * A gather's margin has to cover what the narrowphase will ask for, and
-     * `cloth_contact_find` reaches `(radius + inflation) · (1 + margin)` from
-     * each particle. The gather cannot know which colliders it is about to find,
-     * so it takes the widest in the index — which is why this is here rather
-     * than derived per query.
-     *
-     * Exact after {@link advance}, and only ever raised between advances by
-     * {@link add} and {@link setSurface}. Stale-high is a wider margin; the
-     * other direction is a missed contact, so the maximum is never lowered
-     * inside a step.
+     * Diagnostic upper bound, exact after {@link advance} and only raised
+     * between advances. Contact queries use each collider's own reach instead.
      * @type {number}
      */
     max_inflation: number;
     /**
      * The furthest any live collider has moved since {@link advance}, metres.
      *
-     * The narrowphase adds each collider's own travel to its reach on top of
-     * testing the swept bounds, so the gather's margin has to carry it too or
-     * the set it hands over is smaller than the set the rows are drawn from.
+     * Diagnostic upper bound. Contact queries carry travel on each collider's
+     * leaf, so a remote outlier cannot widen every cloth's query.
      * @type {number}
      */
     max_collider_travel: number;
@@ -154,6 +145,11 @@ export class ClothColliderIndex {
      * @returns {boolean}
      */
     isLive(handle: number): boolean;
+    /**
+     * @param {number} handle
+     * @returns {number} revision of the live record
+     */
+    revisionOf(handle: number): number;
     /**
      * Roll every live record's current pose into its previous one. Called once
      * per fixed step, before any pose for this step is written.
@@ -235,9 +231,12 @@ export class ClothColliderIndex {
      * @param {number} max_z
      * @param {number} layer the querier's layer
      * @param {number} mask the querier's mask
+     * @param {boolean} [contact] include each collider's own travel and contact
+     *   inflation and conversion allowance; the caller supplies particle radius,
+     *   travel and its local-coordinate conversion allowance in the query box
      * @returns {number} how many handles were written
      */
-    query(out: number[], min_x: number, min_y: number, min_z: number, max_x: number, max_y: number, max_z: number, layer: number, mask: number): number;
+    query(out: number[], min_x: number, min_y: number, min_z: number, max_x: number, max_y: number, max_z: number, layer: number, mask: number, contact?: boolean): number;
     #private;
 }
 //# sourceMappingURL=ClothColliderIndex.d.ts.map

package/src/engine/physics/cloth/collider/ClothColliderIndex.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ClothColliderIndex.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/collider/ClothColliderIndex.js"],"names":[],"mappings":"AAuCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgFG;AACH;IAEI;;;;;;OAMG;IACH,OAFU,YAAY,CAEM;IAE5B;;;;;OAKG;IACH,MAFU,UAAU,CAEK;IAEzB;;;;OAIG;IACH,OAFU,MAAM,CAEN;IAEV;;;;;;;;;;;;;;OAcG;IACH,eAFU,MAAM,CAEE;IAElB;;;;;;;OAOG;IACH,qBAFU,MAAM,CAEQ;IAmExB;;;;;;;;;;;OAWG;IACH,sCAPW,MAAM,aACN,MAAM,SACN,MAAM,QACN,MAAM,UACN,MAAM,GACJ,MAAM,CA6DlB;IAED;;;;;;;OAOG;IACH,eAHW,MAAM,GACJ,IAAI,CAoChB;IAED;;;;OAIG;IACH,eAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;;OAIG;IACH,WAFa,IAAI,CA0ChB;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH,gBAVW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,IAAI,CAkFhB;IAyCD;;;;;;;;;;;;;;;OAeG;IACH,kBAVW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,IAAI,CAiBhB;IAED;;;;;;;;OAQG;IACH,mBALW,MAAM,YACN,MAAM,aACN,MAAM,GACJ,IAAI,CAchB;IAED;;;;;OAKG;IACH,kBALW,MAAM,SACN,MAAM,QACN,MAAM,GACJ,IAAI,CAOhB;IAED;;;OAGG;IACH,iBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;;;;;;;;;;;;;;OAkBG;IACH,WAXW,MAAM,EAAE,SACR,MAAM,SACN,MAAM,SACN,MAAM,SACN,MAAM,SACN,MAAM,SACN,MAAM,SACN,MAAM,QACN,MAAM,GACJ,MAAM,CA6DlB;;CA+FJ"}
+{"version":3,"file":"ClothColliderIndex.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/collider/ClothColliderIndex.js"],"names":[],"mappings":"AA2CA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgFG;AACH;IAEI;;;;;;OAMG;IACH,OAFU,YAAY,CAEM;IAE5B;;;;;OAKG;IACH,MAFU,UAAU,CAEK;IAEzB;;;;OAIG;IACH,OAFU,MAAM,CAEN;IAEV;;;;;;OAMG;IACH,eAFU,MAAM,CAEE;IAElB;;;;;;OAMG;IACH,qBAFU,MAAM,CAEQ;IAoFxB;;;;;;;;;;;OAWG;IACH,sCAPW,MAAM,aACN,MAAM,SACN,MAAM,QACN,MAAM,UACN,MAAM,GACJ,MAAM,CA8DlB;IAED;;;;;;;OAOG;IACH,eAHW,MAAM,GACJ,IAAI,CAoChB;IAED;;;;OAIG;IACH,eAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;OAGG;IACH,mBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;OAIG;IACH,WAFa,IAAI,CAuDhB;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH,gBAVW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,IAAI,CA2BhB;IAwID;;;;;;;;;;;;;;;OAeG;IACH,kBAVW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,IAAI,CAiBhB;IAED;;;;;;;;OAQG;IACH,mBALW,MAAM,YACN,MAAM,aACN,MAAM,GACJ,IAAI,CAoBhB;IAED;;;;;OAKG;IACH,kBALW,MAAM,SACN,MAAM,QACN,MAAM,GACJ,IAAI,CAWhB;IAED;;;OAGG;IACH,iBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,WAdW,MAAM,EAAE,SACR,MAAM,SACN,MAAM,SACN,MAAM,SACN,MAAM,SACN,MAAM,SACN,MAAM,SACN,MAAM,QACN,MAAM,YACN,OAAO,GAGL,MAAM,CA6DlB;;CA6GJ"}

package/src/engine/physics/cloth/collider/ClothColliderIndex.js

@@ -17,6 +17,9 @@ import {
     CCR_META_MASK,
     CCR_META_STRIDE,
     CCR_KIND,
+    CCR_PARAM_0,
+    CCR_PARAM_1,
+    CCR_PARAM_2,
     CCR_PREV_QW,
     CCR_PREV_QX,
     CCR_PREV_QY,
@@ -33,9 +36,10 @@ import {
     CCR_TY,
     CCR_TZ
 } from "./ClothColliderRecord.js";
-import { cloth_collider_refit_bounds } from "./cloth_collider_bounds.js";
+import { cloth_collider_refit_bounds, cloth_contact_rounding } from "./cloth_collider_bounds.js";
 import { cloth_collider_pack } from "./cloth_collider_pack.js";
 import { ClothColliderKind } from "./ClothColliderKind.js";
+import { CLOTH_CONTACT_MARGIN } from "../solver/cloth_contact_find.js";
 
 /**
  * # The index of live cloth colliders
@@ -147,16 +151,8 @@ export class ClothColliderIndex {
     /**
      * The widest {@link CCR_INFLATION} any live record carries, metres.
      *
-     * A gather's margin has to cover what the narrowphase will ask for, and
-     * `cloth_contact_find` reaches `(radius + inflation) · (1 + margin)` from
-     * each particle. The gather cannot know which colliders it is about to find,
-     * so it takes the widest in the index — which is why this is here rather
-     * than derived per query.
-     *
-     * Exact after {@link advance}, and only ever raised between advances by
-     * {@link add} and {@link setSurface}. Stale-high is a wider margin; the
-     * other direction is a missed contact, so the maximum is never lowered
-     * inside a step.
+     * Diagnostic upper bound, exact after {@link advance} and only raised
+     * between advances. Contact queries use each collider's own reach instead.
      * @type {number}
      */
     max_inflation = 0;
@@ -164,9 +160,8 @@ export class ClothColliderIndex {
     /**
      * The furthest any live collider has moved since {@link advance}, metres.
      *
-     * The narrowphase adds each collider's own travel to its reach on top of
-     * testing the swept bounds, so the gather's margin has to carry it too or
-     * the set it hands over is smaller than the set the rows are drawn from.
+     * Diagnostic upper bound. Contact queries carry travel on each collider's
+     * leaf, so a remote outlier cannot widen every cloth's query.
      * @type {number}
      */
     max_collider_travel = 0;
@@ -214,6 +209,23 @@ export class ClothColliderIndex {
      */
     #node = new Uint32Array(0);
 
+    /**
+     * Each collider's speculative contact reach: its own translation travel
+     * plus inflation. Stored on the leaf instead of widening every cloth's
+     * query by the largest motion anywhere in the world.
+     * @type {Float64Array}
+     * @private
+     */
+    #reach = new Float64Array(0);
+
+    /**
+     * Changes to a handle's identity, pose, surface or filter. A placement has
+     * equal previous/current poses but must still wake cloth resting against it.
+     * @type {Uint32Array}
+     * @private
+     */
+    #revision = new Uint32Array(0);
+
     /**
      * Handles of live half-spaces, which cannot go in the tree. Empty in every
      * scene this engine has; see the class docblock.
@@ -277,6 +289,7 @@ export class ClothColliderIndex {
         this.meta[m + CCR_META_ENTITY] = entity;
 
         this.#live[handle] = 1;
+        this.#revision[handle]++;
 
         // No pose yet, and a record with an uninitialised rotation is a
         // quaternion of all zeros — which normalises to nothing and poses
@@ -362,6 +375,14 @@ export class ClothColliderIndex {
         return handle >= 0 && handle < this.count && this.#live[handle] === 1;
     }
 
+    /**
+     * @param {number} handle
+     * @returns {number} revision of the live record
+     */
+    revisionOf(handle) {
+        return this.#revision[handle];
+    }
+
     /**
      * Roll every live record's current pose into its previous one. Called once
      * per fixed step, before any pose for this step is written.
@@ -398,6 +419,14 @@ export class ClothColliderIndex {
                 this.max_inflation = table[r + CCR_INFLATION];
             }
 
+            const moved = table[r + CCR_PREV_TX] !== table[r + CCR_TX]
+                || table[r + CCR_PREV_TY] !== table[r + CCR_TY]
+                || table[r + CCR_PREV_TZ] !== table[r + CCR_TZ]
+                || table[r + CCR_PREV_QX] !== table[r + CCR_QX]
+                || table[r + CCR_PREV_QY] !== table[r + CCR_QY]
+                || table[r + CCR_PREV_QZ] !== table[r + CCR_QZ]
+                || table[r + CCR_PREV_QW] !== table[r + CCR_QW];
+
             table[r + CCR_PREV_TX] = table[r + CCR_TX];
             table[r + CCR_PREV_TY] = table[r + CCR_TY];
             table[r + CCR_PREV_TZ] = table[r + CCR_TZ];
@@ -406,6 +435,11 @@ export class ClothColliderIndex {
             table[r + CCR_PREV_QY] = table[r + CCR_QY];
             table[r + CCR_PREV_QZ] = table[r + CCR_QZ];
             table[r + CCR_PREV_QW] = table[r + CCR_QW];
+
+            if (moved) {
+                cloth_collider_refit_bounds(table, handle, CCR_STRIDE);
+                this.#refit(handle);
+            }
         }
     }
 
@@ -434,6 +468,12 @@ export class ClothColliderIndex {
 
         const r = handle * CCR_STRIDE;
 
+        if (table[r + CCR_TX] !== tx || table[r + CCR_TY] !== ty || table[r + CCR_TZ] !== tz
+            || table[r + CCR_QX] !== qx || table[r + CCR_QY] !== qy
+            || table[r + CCR_QZ] !== qz || table[r + CCR_QW] !== qw) {
+            this.#revision[handle]++;
+        }
+
         table[r + CCR_TX] = tx;
         table[r + CCR_TY] = ty;
         table[r + CCR_TZ] = tz;
@@ -445,12 +485,37 @@ export class ClothColliderIndex {
 
         cloth_collider_refit_bounds(this.table, handle, CCR_STRIDE);
 
+        this.#refit(handle);
+    }
+
+    /**
+     * @param {number} handle
+     * @private
+     */
+    #refit(handle) {
+        const table = this.table;
+        const r = handle * CCR_STRIDE;
+
         const travel = Math.hypot(
-            tx - table[r + CCR_PREV_TX],
-            ty - table[r + CCR_PREV_TY],
-            tz - table[r + CCR_PREV_TZ]
+            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]
         );
 
+        const contact_reach = travel + Math.max(0, table[r + CCR_INFLATION]) * (1 + CLOTH_CONTACT_MARGIN);
+        // The sum of the bounded primitive's dimensions bounds its radius.
+        // Include conversion error in BOTH the tree leaf and the final test;
+        // the BVH's storage slack alone is discarded by the latter.
+        const geometry = table[r + CCR_KIND] === ClothColliderKind.Plane ? 0
+            : Math.abs(table[r + CCR_PARAM_0]) + Math.abs(table[r + CCR_PARAM_1])
+                + Math.abs(table[r + CCR_PARAM_2]);
+        const local_scale = geometry + contact_reach;
+        const world_scale = local_scale
+            + Math.abs(table[r + CCR_TX]) + Math.abs(table[r + CCR_TY]) + Math.abs(table[r + CCR_TZ])
+            + Math.abs(table[r + CCR_PREV_TX]) + Math.abs(table[r + CCR_PREV_TY]) + Math.abs(table[r + CCR_PREV_TZ]);
+        const reach = contact_reach + cloth_contact_rounding(local_scale, world_scale);
+        this.#reach[handle] = reach;
+
         if (travel > this.max_collider_travel) {
             this.max_collider_travel = travel;
         }
@@ -485,12 +550,20 @@ export class ClothColliderIndex {
         // tree.
         this.#bvh.node_get_aabb(node, STORED_AABB);
 
-        if (table[r + CCR_AABB_MIN_X] >= STORED_AABB[0]
-            && table[r + CCR_AABB_MIN_Y] >= STORED_AABB[1]
-            && table[r + CCR_AABB_MIN_Z] >= STORED_AABB[2]
-            && table[r + CCR_AABB_MAX_X] <= STORED_AABB[3]
-            && table[r + CCR_AABB_MAX_Y] <= STORED_AABB[4]
-            && table[r + CCR_AABB_MAX_Z] <= STORED_AABB[5]) {
+        let contained = true;
+        let oversized = false;
+        for (let axis = 0; axis < 3; axis++) {
+            const lower = table[r + CCR_AABB_MIN_X + axis] - reach;
+            const upper = table[r + CCR_AABB_MAX_X + axis] + reach;
+            if (lower < STORED_AABB[axis] || upper > STORED_AABB[axis + 3]) contained = false;
+            // A one-step outlier must not leave a scene-sized leaf behind once
+            // motion stops. Allow ordinary jitter to keep spending the slack.
+            if (STORED_AABB[axis + 3] - STORED_AABB[axis]
+                > 2 * (upper - lower + 2 * BVH_LEAF_SLACK
+                    + (Math.abs(lower) + Math.abs(upper)) * FLOAT32_ROUNDING)) oversized = true;
+        }
+
+        if (contained && !oversized) {
             return;
         }
 
@@ -510,8 +583,8 @@ export class ClothColliderIndex {
     }
 
     /**
-     * Write a record's swept bounds into {@link FAT_AABB} with the slack the
-     * refit skip spends, and store them on the leaf.
+     * Write a record's swept bounds plus its contact reach into {@link FAT_AABB}
+     * with the slack the refit skip spends, and store them on the leaf.
      *
      * The slack is also what makes the tree's `Float32` nodes safe to hold a
      * `Float64` world, and it has two terms because one is not enough. The
@@ -536,10 +609,11 @@ export class ClothColliderIndex {
      */
     #store_fat_aabb(node, r) {
         const table = this.table;
+        const reach = this.#reach[r / CCR_STRIDE];
 
         for (let axis = 0; axis < 3; axis++) {
-            const lower = table[r + CCR_AABB_MIN_X + axis];
-            const upper = table[r + CCR_AABB_MAX_X + axis];
+            const lower = table[r + CCR_AABB_MIN_X + axis] - reach;
+            const upper = table[r + CCR_AABB_MAX_X + axis] + reach;
 
             FAT_AABB[axis] = lower - BVH_LEAF_SLACK - Math.abs(lower) * FLOAT32_ROUNDING;
             FAT_AABB[axis + 3] = upper + BVH_LEAF_SLACK + Math.abs(upper) * FLOAT32_ROUNDING;
@@ -593,6 +667,10 @@ export class ClothColliderIndex {
     setSurface(handle, friction, inflation) {
         const r = handle * CCR_STRIDE;
 
+        if (this.table[r + CCR_FRICTION] !== friction || this.table[r + CCR_INFLATION] !== inflation) {
+            this.#revision[handle]++;
+        }
+
         this.table[r + CCR_FRICTION] = friction;
         this.table[r + CCR_INFLATION] = inflation;
 
@@ -602,6 +680,8 @@ export class ClothColliderIndex {
         if (inflation > this.max_inflation) {
             this.max_inflation = inflation;
         }
+
+        this.#refit(handle);
     }
 
     /**
@@ -613,6 +693,10 @@ export class ClothColliderIndex {
     setFilter(handle, layer, mask) {
         const m = handle * CCR_META_STRIDE;
 
+        if (this.meta[m + CCR_META_LAYER] !== (layer | 0) || this.meta[m + CCR_META_MASK] !== (mask | 0)) {
+            this.#revision[handle]++;
+        }
+
         this.meta[m + CCR_META_LAYER] = layer;
         this.meta[m + CCR_META_MASK] = mask;
     }
@@ -642,9 +726,12 @@ export class ClothColliderIndex {
      * @param {number} max_z
      * @param {number} layer the querier's layer
      * @param {number} mask the querier's mask
+     * @param {boolean} [contact] include each collider's own travel and contact
+     *   inflation and conversion allowance; the caller supplies particle radius,
+     *   travel and its local-coordinate conversion allowance in the query box
      * @returns {number} how many handles were written
      */
-    query(out, min_x, min_y, min_z, max_x, max_y, max_z, layer, mask) {
+    query(out, min_x, min_y, min_z, max_x, max_y, max_z, layer, mask, contact = false) {
         QUERY_AABB[0] = min_x;
         QUERY_AABB[1] = min_y;
         QUERY_AABB[2] = min_z;
@@ -676,9 +763,9 @@ export class ClothColliderIndex {
         for (let i = 0; i < candidate_count; i++) {
             const handle = candidates[i];
 
-            // The leaf carries slack and `Float32` rounding; the record is the
-            // exact `Float64` answer, and it is what the narrowphase will read.
-            if (this.#overlaps(handle, min_x, min_y, min_z, max_x, max_y, max_z, layer, mask)) {
+            // Raw queries use the exact record. Contact queries retain the
+            // conversion allowance needed by the solver's Float32 table.
+            if (this.#overlaps(handle, min_x, min_y, min_z, max_x, max_y, max_z, layer, mask, contact)) {
                 answer.push(handle);
             }
         }
@@ -688,7 +775,7 @@ export class ClothColliderIndex {
         for (let i = 0; i < planes.length; i++) {
             const handle = planes[i];
 
-            if (this.#overlaps(handle, min_x, min_y, min_z, max_x, max_y, max_z, layer, mask)) {
+            if (this.#overlaps(handle, min_x, min_y, min_z, max_x, max_y, max_z, layer, mask, contact)) {
                 answer.push(handle);
             }
         }
@@ -718,10 +805,11 @@ export class ClothColliderIndex {
      * @param {number} max_z
      * @param {number} layer
      * @param {number} mask
+     * @param {boolean} contact
      * @returns {boolean}
      * @private
      */
-    #overlaps(handle, min_x, min_y, min_z, max_x, max_y, max_z, layer, mask) {
+    #overlaps(handle, min_x, min_y, min_z, max_x, max_y, max_z, layer, mask, contact) {
         if (this.#live[handle] === 0) {
             return false;
         }
@@ -742,15 +830,22 @@ export class ClothColliderIndex {
 
         const r = handle * CCR_STRIDE;
 
-        if (table[r + CCR_AABB_MIN_X] > max_x || table[r + CCR_AABB_MAX_X] < min_x) {
+        // A plane has no finite radius with which to bound a rounded normal's
+        // displacement. Keep every filtered half-space; the gather can reject
+        // it using the solver's actual local bounds before applying its cap.
+        if (contact && table[r + CCR_KIND] === ClothColliderKind.Plane) return true;
+
+        const reach = contact ? this.#reach[handle] : 0;
+
+        if (table[r + CCR_AABB_MIN_X] - reach > max_x || table[r + CCR_AABB_MAX_X] + reach < min_x) {
             return false;
         }
 
-        if (table[r + CCR_AABB_MIN_Y] > max_y || table[r + CCR_AABB_MAX_Y] < min_y) {
+        if (table[r + CCR_AABB_MIN_Y] - reach > max_y || table[r + CCR_AABB_MAX_Y] + reach < min_y) {
             return false;
         }
 
-        if (table[r + CCR_AABB_MIN_Z] > max_z || table[r + CCR_AABB_MAX_Z] < min_z) {
+        if (table[r + CCR_AABB_MIN_Z] - reach > max_z || table[r + CCR_AABB_MAX_Z] + reach < min_z) {
             return false;
         }
 
@@ -784,11 +879,15 @@ export class ClothColliderIndex {
         const meta = new Int32Array(capacity * CCR_META_STRIDE);
         const live = new Uint8Array(capacity);
         const node = new Uint32Array(capacity);
+        const reach = new Float64Array(capacity);
+        const revision = new Uint32Array(capacity);
 
         table.set(this.table);
         meta.set(this.meta);
         live.set(this.#live);
         node.set(this.#node);
+        reach.set(this.#reach);
+        revision.set(this.#revision);
 
         node.fill(NULL_NODE, this.#node.length);
 
@@ -796,6 +895,8 @@ export class ClothColliderIndex {
         this.meta = meta;
         this.#live = live;
         this.#node = node;
+        this.#reach = reach;
+        this.#revision = revision;
     }
 
 }

package/src/engine/physics/cloth/collider/cloth_collider_bounds.d.ts

@@ -1,3 +1,33 @@
+/**
+ * Outward error allowance when a world-space query precedes the solver's
+ * Float32 conversion. Shared by the cloth query and the collider leaf: their
+ * allowances add, just as their speculative contact reaches do.
+ *
+ * Let u = 2^-24, P bound the particle's local distance from the anchor, G the
+ * shape radius, and L the sum of the contact and motion reaches. Rounding a
+ * localized translation contributes at most u times its length; rounding both
+ * swept translations adds at most u(2|t| + travel) to the measured travel.
+ * The relative quaternion is rounded, normalized and rounded again. Its
+ * error is less than 4u, so its inverse rotation/scale displaces a point by
+ * less than 9u times its radius. Shape parameters and inflation round once.
+ * Together these are bounded by 4u|t| + 16u(G + L). For an accepted contact,
+ * |t| <= P + G + L + error; substituting bounds that error by 32u(P + G + L).
+ * We spend 64u, including outward arithmetic rounding. P and the particle
+ * reach are paid by the query, G and collider reach by the index. No world
+ * coordinate is multiplied by a Float32 epsilon.
+ *
+ * World transforms/bounds use doubles: the separate world term covers their
+ * subtraction and rotation arithmetic, including cancellation far from the
+ * origin. The absolute term covers Float32 subnormals. Assumes finite solver
+ * values and rigid unit-quaternion input poses, as the collider API does.
+ * Unbounded planes cannot use a shape-radius bound and are always candidates
+ * for a contact query (their layer/mask still applies).
+ *
+ * @param {number} local_scale nonnegative local length bound
+ * @param {number} world_scale nonnegative world arithmetic magnitude bound
+ * @returns {number} metres of outward padding
+ */
+export function cloth_contact_rounding(local_scale: number, world_scale: number): number;
 /**
  * # The swept bounds of a packed collider
  *

package/src/engine/physics/cloth/collider/cloth_collider_bounds.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cloth_collider_bounds.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/collider/cloth_collider_bounds.js"],"names":[],"mappings":"AAqBA;;;;;;;;;;;;;;GAcG;AAEH;;;;;;;GAOG;AACH,mDALW,YAAY,GAAC,YAAY,UACzB,MAAM,UACN,MAAM,GACJ,IAAI,CAoBhB"}
+{"version":3,"file":"cloth_collider_bounds.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/collider/cloth_collider_bounds.js"],"names":[],"mappings":"AAqBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,oDAJW,MAAM,eACN,MAAM,GACJ,MAAM,CAIlB;AAED;;;;;;;;;;;;;;GAcG;AAEH;;;;;;;GAOG;AACH,mDALW,YAAY,GAAC,YAAY,UACzB,MAAM,UACN,MAAM,GACJ,IAAI,CAoBhB"}

package/src/engine/physics/cloth/collider/cloth_collider_bounds.js

@@ -19,6 +19,39 @@ import {
 } from "./ClothColliderRecord.js";
 import { cloth_collider_local_bounds } from "./cloth_collider_pack.js";
 
+/**
+ * Outward error allowance when a world-space query precedes the solver's
+ * Float32 conversion. Shared by the cloth query and the collider leaf: their
+ * allowances add, just as their speculative contact reaches do.
+ *
+ * Let u = 2^-24, P bound the particle's local distance from the anchor, G the
+ * shape radius, and L the sum of the contact and motion reaches. Rounding a
+ * localized translation contributes at most u times its length; rounding both
+ * swept translations adds at most u(2|t| + travel) to the measured travel.
+ * The relative quaternion is rounded, normalized and rounded again. Its
+ * error is less than 4u, so its inverse rotation/scale displaces a point by
+ * less than 9u times its radius. Shape parameters and inflation round once.
+ * Together these are bounded by 4u|t| + 16u(G + L). For an accepted contact,
+ * |t| <= P + G + L + error; substituting bounds that error by 32u(P + G + L).
+ * We spend 64u, including outward arithmetic rounding. P and the particle
+ * reach are paid by the query, G and collider reach by the index. No world
+ * coordinate is multiplied by a Float32 epsilon.
+ *
+ * World transforms/bounds use doubles: the separate world term covers their
+ * subtraction and rotation arithmetic, including cancellation far from the
+ * origin. The absolute term covers Float32 subnormals. Assumes finite solver
+ * values and rigid unit-quaternion input poses, as the collider API does.
+ * Unbounded planes cannot use a shape-radius bound and are always candidates
+ * for a contact query (their layer/mask still applies).
+ *
+ * @param {number} local_scale nonnegative local length bound
+ * @param {number} world_scale nonnegative world arithmetic magnitude bound
+ * @returns {number} metres of outward padding
+ */
+export function cloth_contact_rounding(local_scale, world_scale) {
+    return 64 * (2 ** -24 * local_scale + Number.EPSILON * world_scale + 2 ** -149);
+}
+
 /**
  * # The swept bounds of a packed collider
  *

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

@@ -24,7 +24,8 @@ export const ClothColliderFlags = {
      * the sweep degenerates to the pose it already had. Move the entity anyway
      * and the cloth will not notice: that is the trade, and it is why this is
      * an author's assertion rather than something derived from a pose that
-     * happens not to have changed yet.
+     * happens not to have changed yet. An explicit TRANSFORM64_EVENT_PLACED
+     * (including PhysicsSystem.setPose) does re-place a static proxy.
      */
     Static: 1
 };

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

@@ -63,7 +63,8 @@ export class ClothColliderSystem extends System<any> {
      * they were linked. Held rather than looked up per step for the same reason
      * `ClothInstance` holds its transforms: a refresh is a loop over live
      * colliders, not a query.
-     * @type {{collider: ClothCollider, transform: Transform64, entity: number, handle: number}[]}
+     * @type {{collider: ClothCollider, transform: Transform64, entity: number, handle: number,
+     *   linked: boolean, onPlaced: function(): void}[]}
      * @private
      */
     private __linked;
@@ -99,6 +100,14 @@ export class ClothColliderSystem extends System<any> {
      * @returns {void}
      */
     refreshSurface(entity: number): void;
+    /**
+     * Reset motion history at an explicitly published placement, including
+     * static proxies. The next refresh can still sweep any subsequent motion.
+     * @param {number} handle
+     * @param {Transform64} transform
+     * @private
+     */
+    private __place;
     /**
      * @param {number} entity
      * @returns {number} the index handle, or `undefined` if the entity is not indexed

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

@@ -1 +1 @@
-{"version":3,"file":"ClothColliderSystem.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/ecs/ClothColliderSystem.js"],"names":[],"mappings":"AAaA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH;;IAEI,8EAAsD;IAEtD,wKAIE;IAEF;;OAEG;IACH,OAFU,kBAAkB,CAEK;IAEjC;;;;;;OAMG;IACH,kBAAsB;IAEtB;;;;;;;OAOG;IACH,iBAAc;IAEd;;;;;OAKG;IACH,qBALW,aAAa,YACb,QAAQ,aACR,WAAW,UACX,MAAM,QAsChB;IAED;;;;;OAKG;IACH,uBALW,aAAa,YACb,QAAQ,aACR,WAAW,UACX,MAAM,QAmBhB;IAED;;;;;;OAMG;IACH,WAFa,IAAI,CAkChB;IAED;;;;;;;;OAQG;IACH,uBAHW,MAAM,GACJ,IAAI,CAyBhB;IAED;;;OAGG;IACH,iBAHW,MAAM,GACJ,MAAM,CAIlB;CACJ;uBAhPsB,wBAAwB;4BAKxC,uCAAuC;yBACrB,uBAAuB;8BAElB,oBAAoB;4CATN,uDAAuD;mCAQhE,mCAAmC"}
+{"version":3,"file":"ClothColliderSystem.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/ecs/ClothColliderSystem.js"],"names":[],"mappings":"AAcA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH;;IAEI,8EAAsD;IAEtD,wKAIE;IAEF;;OAEG;IACH,OAFU,kBAAkB,CAEK;IAEjC;;;;;;OAMG;IACH,kBAAsB;IAEtB;;;;;;;;OAQG;IACH,iBAAc;IAEd;;;;;OAKG;IACH,qBALW,aAAa,YACb,QAAQ,aACR,WAAW,UACX,MAAM,QAoChB;IAED;;;;;OAKG;IACH,uBALW,aAAa,YACb,QAAQ,aACR,WAAW,UACX,MAAM,QAqBhB;IAED;;;;;;OAMG;IACH,WAFa,IAAI,CAkChB;IAED;;;;;;;;OAQG;IACH,uBAHW,MAAM,GACJ,IAAI,CAyBhB;IAED;;;;;;OAMG;IACH,gBAWC;IAED;;;OAGG;IACH,iBAHW,MAAM,GACJ,MAAM,CAIlB;CACJ;uBAtQsB,wBAAwB;4BAMxC,uCAAuC;yBACrB,uBAAuB;8BAElB,oBAAoB;4CAVN,uDAAuD;mCAShE,mCAAmC"}

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

@@ -1,6 +1,7 @@
 import { ResourceAccessKind } from "../../../../core/model/ResourceAccessKind.js";
 import { ResourceAccessSpecification } from "../../../../core/model/ResourceAccessSpecification.js";
 import { System } from "../../../ecs/System.js";
+import { TRANSFORM64_EVENT_PLACED } from "../../../ecs/transform/TRANSFORM64_EVENT_PLACED.js";
 import {
     TRANSFORM64_ROTATION_OFFSET,
     TRANSFORM64_TRANSLATION_OFFSET,
@@ -84,7 +85,8 @@ export class ClothColliderSystem extends System {
      * they were linked. Held rather than looked up per step for the same reason
      * `ClothInstance` holds its transforms: a refresh is a loop over live
      * colliders, not a query.
-     * @type {{collider: ClothCollider, transform: Transform64, entity: number, handle: number}[]}
+     * @type {{collider: ClothCollider, transform: Transform64, entity: number, handle: number,
+     *   linked: boolean, onPlaced: function(): void}[]}
      * @private
      */
     __linked = [];
@@ -117,20 +119,18 @@ export class ClothColliderSystem extends System {
 
         this.__handles.set(entity, handle);
 
-        this.__linked.push({ collider: cloth_collider, transform, entity, handle });
+        const entry = { collider: cloth_collider, transform, entity, handle, linked: true, onPlaced: () => {
+            // Dispatch snapshots can retain this listener after unlink, even
+            // after both its entity id and index slot have been reused.
+            if (entry.linked) this.__place(handle, transform);
+        } };
+        this.__linked.push(entry);
+
+        this.entityManager.dataset.addEntityEventListener(entity, TRANSFORM64_EVENT_PLACED, entry.onPlaced);
 
         // Placed rather than posed, so its first step sweeps nothing. A
         // collider that has just appeared did not move.
-        this.index.placePose(
-            handle,
-            transform[TRANSFORM64_TRANSLATION_OFFSET],
-            transform[TRANSFORM64_TRANSLATION_OFFSET + 1],
-            transform[TRANSFORM64_TRANSLATION_OFFSET + 2],
-            transform[TRANSFORM64_ROTATION_OFFSET],
-            transform[TRANSFORM64_ROTATION_OFFSET + 1],
-            transform[TRANSFORM64_ROTATION_OFFSET + 2],
-            transform[TRANSFORM64_ROTATION_OFFSET + 3]
-        );
+        this.__place(handle, transform);
     }
 
     /**
@@ -148,9 +148,11 @@ export class ClothColliderSystem extends System {
 
         this.__handles.delete(entity);
         this.index.remove(handle);
-
         for (let i = 0; i < this.__linked.length; i++) {
-            if (this.__linked[i].entity === entity) {
+            const entry = this.__linked[i];
+            if (entry.entity === entity) {
+                entry.linked = false;
+                this.entityManager.dataset.removeEntityEventListener(entity, TRANSFORM64_EVENT_PLACED, entry.onPlaced);
                 this.__linked.splice(i, 1);
 
                 break;
@@ -233,6 +235,26 @@ export class ClothColliderSystem extends System {
         this.index.setFilter(handle, cloth_collider.layer, cloth_collider.mask);
     }
 
+    /**
+     * Reset motion history at an explicitly published placement, including
+     * static proxies. The next refresh can still sweep any subsequent motion.
+     * @param {number} handle
+     * @param {Transform64} transform
+     * @private
+     */
+    __place(handle, transform) {
+        this.index.placePose(
+            handle,
+            transform[TRANSFORM64_TRANSLATION_OFFSET],
+            transform[TRANSFORM64_TRANSLATION_OFFSET + 1],
+            transform[TRANSFORM64_TRANSLATION_OFFSET + 2],
+            transform[TRANSFORM64_ROTATION_OFFSET],
+            transform[TRANSFORM64_ROTATION_OFFSET + 1],
+            transform[TRANSFORM64_ROTATION_OFFSET + 2],
+            transform[TRANSFORM64_ROTATION_OFFSET + 3]
+        );
+    }
+
     /**
      * @param {number} entity
      * @returns {number} the index handle, or `undefined` if the entity is not indexed