@woosh/meep-engine 3.37.0 → 3.39.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,CA0PnB;;CA8EJ;8BA3/B6B,oBAAoB;0CAjB3C,gEAAgE;oCAcnC,0BAA0B;sBA4BxC,YAAY"}

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

@@ -1,8 +1,8 @@
 import { assert } from "../../../../core/assert.js";
-import { quat3_multiply } from "../../../../core/geom/3d/quaternion/quat3_multiply.js";
-import { quat3_nlerp } from "../../../../core/geom/3d/quaternion/quat3_nlerp.js";
-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 { quat3_multiply_array } from "../../../../core/geom/3d/quaternion/quat3_multiply.js";
+import { quat3_nlerp_array } from "../../../../core/geom/3d/quaternion/quat3_nlerp.js";
+import { v3_quaternion_apply_array } from "../../../../core/geom/vec3/v3_quaternion_apply.js";
+import { v3_quaternion_apply_inverse_array } from "../../../../core/geom/vec3/v3_quaternion_apply_inverse.js";
 import { EntityObserver } from "../../../ecs/EntityObserver.js";
 import {
     TransformAttachment
@@ -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(
@@ -833,12 +832,22 @@ export class ClothWorld {
             if (teleport) {
                 this.#teleport(instance);
             } else {
-                move_local_frame(
-                    instance,
-                    tx, ty, tz, qx, qy, qz, qw,
-                    previous_translation, previous_rotation
-                );
+                // the new pose goes in as an array: handed over as seven numbers, each was boxed
+                // wherever the call was not inlined
+                ANCHOR_POSE[0] = tx;
+                ANCHOR_POSE[1] = ty;
+                ANCHOR_POSE[2] = tz;
+                ANCHOR_POSE[3] = qx;
+                ANCHOR_POSE[4] = qy;
+                ANCHOR_POSE[5] = qz;
+                ANCHOR_POSE[6] = qw;
+
+                move_local_frame(instance, ANCHOR_POSE, 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;
@@ -859,7 +868,8 @@ export class ClothWorld {
         // Gravity is a world vector and the solve is in the anchor's frame.
         const gravity = this.gravity;
 
-        v3_quaternion_apply_inverse(LOCAL_GRAVITY, 0, gravity[0], gravity[1], gravity[2], qx, qy, qz, qw);
+        // `previous_rotation` has just been set to this step's `q`; vector and rotation go in as arrays
+        v3_quaternion_apply_inverse_array(LOCAL_GRAVITY, 0, gravity, 0, previous_rotation, 0);
 
         const state = instance.state;
 
@@ -879,8 +889,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 {
@@ -1057,6 +1067,28 @@ const LOCAL_GRAVITY = new Float64Array(3);
  */
 const FRAME = new Float64Array(8);
 
+/**
+ * The anchor's pose this step, `[tx, ty, tz, qx, qy, qz, qw]`, as {@link move_local_frame} takes it.
+ * @type {Float64Array}
+ * @private
+ */
+const ANCHOR_POSE = new Float64Array(7);
+
+/**
+ * {@link move_local_frame}'s `q_now⁻¹`, `[-qx, -qy, -qz, qw]`.
+ * @type {Float64Array}
+ * @private
+ */
+const POSE_CONJUGATE = new Float64Array(4);
+
+/**
+ * The identity rotation, `[0, 0, 0, 1]`, which {@link move_local_frame} limits a turn towards. Never
+ * written.
+ * @type {Float64Array}
+ * @private
+ */
+const IDENTITY_ROTATION = new Float64Array([0, 0, 0, 1]);
+
 /**
  * Carry the particles across a change of anchor pose, by however much of it the
  * fabric is willing to feel. §7 P7.
@@ -1073,23 +1105,17 @@ const FRAME = new Float64Array(8);
  * teleports a metre — or spins — something a cape *lags behind* rather than
  * something it is fired out of.
  *
+ * Every vector and quaternion goes to its function as an array and an offset: handed over as numbers,
+ * each was boxed into a heap object wherever the call was not inlined, which until V8 optimises this
+ * is every call, twice per particle per step of a moving anchor.
+ *
  * @param {ClothInstance} instance
- * @param {number} tx
- * @param {number} ty
- * @param {number} tz
- * @param {number} qx
- * @param {number} qy
- * @param {number} qz
- * @param {number} qw
+ * @param {Float64Array} pose the anchor's pose now, `[tx, ty, tz, qx, qy, qz, qw]`
  * @param {Float64Array} previous_translation
  * @param {Float64Array} previous_rotation
  * @private
  */
-function move_local_frame(
-    instance,
-    tx, ty, tz, qx, qy, qz, qw,
-    previous_translation, previous_rotation
-) {
+function move_local_frame(instance, pose, previous_translation, previous_rotation) {
     let inertia = instance.cloth.dynamics.inertia;
 
     if (inertia <= 0) {
@@ -1100,13 +1126,11 @@ function move_local_frame(
         inertia = 1;
     }
 
-    v3_quaternion_apply_inverse(
-        FRAME, 0,
-        previous_translation[0] - tx,
-        previous_translation[1] - ty,
-        previous_translation[2] - tz,
-        qx, qy, qz, qw
-    );
+    FRAME[0] = previous_translation[0] - pose[0];
+    FRAME[1] = previous_translation[1] - pose[1];
+    FRAME[2] = previous_translation[2] - pose[2];
+
+    v3_quaternion_apply_inverse_array(FRAME, 0, FRAME, 0, pose, 3);
 
     const travel_limit = CLOTH_ANCHOR_TRAVEL_REACH * instance.reach;
 
@@ -1120,11 +1144,12 @@ function move_local_frame(
         FRAME[2] *= scale;
     }
 
-    quat3_multiply(
-        FRAME, 4,
-        -qx, -qy, -qz, qw,
-        previous_rotation[0], previous_rotation[1], previous_rotation[2], previous_rotation[3]
-    );
+    POSE_CONJUGATE[0] = -pose[3];
+    POSE_CONJUGATE[1] = -pose[4];
+    POSE_CONJUGATE[2] = -pose[5];
+    POSE_CONJUGATE[3] = pose[6];
+
+    quat3_multiply_array(FRAME, 4, POSE_CONJUGATE, 0, previous_rotation, 0);
 
     // `|w|` is `cos(θ/2)`, so this is the angle test without an `acos`.
     const half_angle_cos = FRAME[7] < 0 ? -FRAME[7] : FRAME[7];
@@ -1132,12 +1157,7 @@ function move_local_frame(
     if (half_angle_cos < Math.cos(CLOTH_ANCHOR_ROTATION_LIMIT * 0.5)) {
         const angle = 2 * Math.acos(half_angle_cos > 1 ? 1 : half_angle_cos);
 
-        quat3_nlerp(
-            FRAME, 4,
-            0, 0, 0, 1,
-            FRAME[4], FRAME[5], FRAME[6], FRAME[7],
-            CLOTH_ANCHOR_ROTATION_LIMIT / angle
-        );
+        quat3_nlerp_array(FRAME, 4, IDENTITY_ROTATION, 0, FRAME, 4, CLOTH_ANCHOR_ROTATION_LIMIT / angle);
     }
 
     const state = instance.state;
@@ -1151,27 +1171,32 @@ function move_local_frame(
     const dy = FRAME[1];
     const dz = FRAME[2];
 
-    const rx = FRAME[4];
-    const ry = FRAME[5];
-    const rz = FRAME[6];
-    const rw = FRAME[7];
-
     for (let i = 0; i < particle_count; i++) {
         const p = i * 3;
 
-        v3_quaternion_apply(CARRIED, 0, position[p], position[p + 1], position[p + 2], rx, ry, rz, rw);
+        v3_quaternion_apply_array(CARRIED, 0, position, p, FRAME, 4);
 
         position[p] += inertia * (CARRIED[0] + dx - position[p]);
         position[p + 1] += inertia * (CARRIED[1] + dy - position[p + 1]);
         position[p + 2] += inertia * (CARRIED[2] + dz - position[p + 2]);
 
-        v3_quaternion_apply(CARRIED, 0, velocity[p], velocity[p + 1], velocity[p + 2], rx, ry, rz, rw);
+        v3_quaternion_apply_array(CARRIED, 0, velocity, p, FRAME, 4);
 
         velocity[p] += inertia * (CARRIED[0] - velocity[p]);
         velocity[p + 1] += inertia * (CARRIED[1] - velocity[p + 1]);
         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;AAwFD;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,2FAFa,OAAO,CAkBnB;AAED;;;;;;;;GAQG;AACH,yEAHW,MAAM,GACJ,IAAI,CAgBhB"}