@woosh/meep-engine 3.22.0 → 3.23.0

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

@@ -1,254 +1,283 @@
-import { ClothDynamics } from "./ClothDynamics.js";
-import { ClothDynamicsFlags } from "./ClothDynamicsFlags.js";
-
-/**
- * # The library — points in the parameter space that are known to be good
- *
- * Seven frozen {@link ClothDynamics} instances. Assign one directly and it is
- * shared, immutable and free; `.clone()` it and you own a copy to edit. They
- * are a set of points rather than a mechanism: nothing here is computed, and
- * nothing here is a preset system that has to be re-applied when a field
- * changes.
- *
- * ```js
- * rope_top.add(Cloth.from(CLOTH_ROPE));
- *
- * const wet = CLOTH_ROPE.clone();
- * wet.damping = 0.4;
- * ```
- *
- * ## Every entry is sized to the measured frame budget
- *
- * M0 measured the §17 workload — 1,024 particles at 2 substeps × 4 iterations —
- * at 3.48 ms against a 2 ms target and priced three levers that each closed it
- * on their own. **M1 changed that arithmetic**, because M1 added rows: a
- * strain-limit row per link, a tether per particle, and a slack row per
- * particle for any fabric that follows an animated pose. The same 1,024
- * particles at 2×4 now cost **4.61 ms**, and no single lever reaches 2 ms from
- * there — 1,024 at 2×2 is 2.38 ms and 484 at 2×4 is 2.53 ms, both still over.
- * Every garment entry below therefore spends **two** levers, and the numbers
- * are from `__fixtures__/cloth_library_bench.mjs`, which builds precisely the
- * row set `cloth_seed_subtree` builds and runs precisely the budgets this file
- * ships. `MEASUREMENTS.md` §10.
- *
- * The chains are two orders of magnitude cheaper and can afford the full
- * budget and more; the garments are where the levers are spent.
- *
- * ## What `stretch` and `bend` mean here, and where `stretch` stops meaning it
- *
- * `stretch` is the strain the fabric may carry, log-mapped: `1` is a chain at a
- * tenth of a per cent, `0` is a knit at a quarter of its length. `bend` is a
- * ratio of the row's own inertial scale and **saturates at 1** — a soft row
- * stiffer than the top of the dissipative band stops coming to rest at all, so
- * leather is at the ceiling rather than above it. `cloth_dynamics_map.js`
- * carries both derivations.
- *
- * `stretch` is also the weakest field in the set, and the entries say so by
- * which of them set `ClothDynamicsFlags.StrainLimit`. Measured on a 24-link
- * rope dropped through ninety degrees, the strain-limit row removes about a
- * third of the peak over-stretch at every budget and **never reaches its own
- * allowance** — at `stretch = 1` it asks for 0.1% and delivers 5.9% at 1×1,
- * 2.2% at 2×2 and 0.9% at 2×4. It is a second hard row on an edge that already
- * has one, so it competes for the same trust region and the same penalty band
- * as the row it is backing up. That makes it worth its 13–15% of a garment
- * frame where the residual is visible — a low iteration count — and not worth
- * it where the residual is already around one per cent. The entries at 2×4
- * clear the flag; the ones at 2×2, and the chains where it is free, keep it.
- *
- * @author Alex Goldring
- * @copyright Company Named Limited (c) 2026
- */
-
-/**
- * Silk, chiffon, a light banner. Barely resists folding, extends almost not at
- * all, and follows the animation loosely enough to flow.
- *
- * *Budget:* **400 particles at 2×4 — 1.49 ms.** Two levers: fewer particles,
- * and no strain-limit row. A silk garment is the one that most wants substeps
- * and iterations, so it keeps both and pays for them everywhere else; at 2×4
- * the fabric row is inside 1.4% of strain unaided and the strain-limit row
- * would buy half a per cent of that for 15% of the frame.
- * @type {Readonly<ClothDynamics>}
- */
-export const CLOTH_SILK = Object.freeze(ClothDynamics.from({
-    stretch: 0.85,
-    bend: 0.04,
-    damping: 0.06,
-    slack: 0.75,
-    thickness: 0.004,
-    inertia: 1,
-    drag: 0.45,
-    substeps: 2,
-    iterations: 4,
-    flags: ClothDynamicsFlags.None
-}));
-
-/**
- * Cotton, linen, a shirt. The default fabric, and the one every other entry is
- * a deviation from.
- *
- * *Budget:* **400 particles at 2×4 — 1.49 ms.** Fewer particles, and no
- * strain-limit row, for the same reason silk drops it.
- * @type {Readonly<ClothDynamics>}
- */
-export const CLOTH_COTTON = Object.freeze(ClothDynamics.from({
-    stretch: 0.8,
-    bend: 0.25,
-    damping: 0.12,
-    slack: 0.6,
-    thickness: 0.008,
-    inertia: 1,
-    drag: 0.2,
-    substeps: 2,
-    iterations: 4,
-    flags: ClothDynamicsFlags.None
-}));
-
-/**
- * Denim, canvas, a heavy coat. Stiff, quiet, and inclined to hold a fold.
- *
- * *Budget:* **576 particles at 2×2 — 1.28 ms.** Two levers: half the
- * iterations, and fewer particles. A heavy garment is large, so it spends more
- * of its allowance on particles than silk does and takes it back from the
- * iteration count; §5.1's whole claim is that a lower iteration count converges
- * less far towards the *same* answer rather than towards a different one, and a
- * stiff fabric is where that is least visible. It keeps the strain-limit row,
- * because at 2×2 the residual is 3.5% and the row takes a third of it.
- * @type {Readonly<ClothDynamics>}
- */
-export const CLOTH_DENIM = Object.freeze(ClothDynamics.from({
-    stretch: 0.93,
-    bend: 0.62,
-    damping: 0.25,
-    slack: 0.4,
-    thickness: 0.014,
-    inertia: 1,
-    drag: 0.08,
-    substeps: 2,
-    iterations: 2
-}));
-
-/**
- * Leather, oilcloth, armour skirting. The stiffest fabric this solver can hold
- * and still come to rest — `bend` is at the ceiling of the dissipative band,
- * not merely high.
- *
- * *Budget:* **576 particles at 2×2 — 1.28 ms**, as denim, and for the same
- * reasons.
- * @type {Readonly<ClothDynamics>}
- */
-export const CLOTH_LEATHER = Object.freeze(ClothDynamics.from({
-    stretch: 0.97,
-    bend: 1,
-    damping: 0.35,
-    slack: 0.3,
-    thickness: 0.02,
-    inertia: 1,
-    drag: 0.05,
-    substeps: 2,
-    iterations: 2
-}));
-
-/**
- * Rope, cable, a mooring line. No meaningful animated pose to follow — a rope
- * hangs where physics puts it — so `slack` is at 1, which by the derivation in
- * `cloth_seed_subtree.js` means the leash row is provably inactive and is not
- * built at all. The tether carries the inextensibility on its own.
- *
- * *Budget:* **40 links at the full 2×4 — 0.04 ms.** No lever at all: a chain
- * wants more of both than a sheet does and can simply afford it, because the
- * cost is close to linear in particles and a rope has two orders fewer. The
- * strain-limit row is free at this size and `stretch` is a rope's most
- * characteristic property, so it stays.
- * @type {Readonly<ClothDynamics>}
- */
-export const CLOTH_ROPE = Object.freeze(ClothDynamics.from({
-    stretch: 0.98,
-    bend: 0.06,
-    damping: 0.1,
-    slack: 1,
-    thickness: 0.015,
-    inertia: 1,
-    drag: 0.12,
-    substeps: 2,
-    iterations: 4
-}));
-
-/**
- * Chain, beads, a pull cord — links that barely extend and barely bend, but do
- * not flow the way a rope does.
- *
- * *Budget:* **40 links at 2×6 — 0.06 ms.** Depth is how far a constraint force
- * travels in one sweep, and a chain is the deepest thing this system simulates,
- * so this is the one entry that spends *more* than the nominal budget rather
- * than less. It can: at forty particles the whole step is a rounding error
- * against the frame.
- * @type {Readonly<ClothDynamics>}
- */
-export const CLOTH_CHAIN = Object.freeze(ClothDynamics.from({
-    stretch: 1,
-    bend: 0.15,
-    damping: 0.2,
-    slack: 1,
-    thickness: 0.012,
-    inertia: 1,
-    drag: 0.05,
-    substeps: 2,
-    iterations: 6
-}));
-
-/**
- * Hair, a ponytail, a horse's tail. Many shallow strands rather than one deep
- * one, which is why it is the only entry that asks for self-collision: strands
- * that pass through each other read as wrong in a way a single chain never
- * does.
- *
- * *Budget:* **400 particles across all strands at 2×4 — 1.49 ms**, the same
- * two levers silk takes. `ClothDynamicsFlags.SelfCollision` is a claim about
- * the fabric that M4 will have to re-price when it can honour it, and it is
- * the reason this entry has the least headroom in the library.
- * @type {Readonly<ClothDynamics>}
- */
-export const CLOTH_HAIR = Object.freeze(ClothDynamics.from({
-    stretch: 0.95,
-    bend: 0.2,
-    damping: 0.18,
-    slack: 0.55,
-    thickness: 0.006,
-    inertia: 1,
-    drag: 0.3,
-    substeps: 2,
-    iterations: 4,
-    flags: ClothDynamicsFlags.SelfCollision
-}));
-
-/**
- * Every entry, in one frozen array — for a tool that wants to show them all,
- * and for the spec that holds the whole library to the value semantics and the
- * budget.
- * @type {ReadonlyArray<Readonly<ClothDynamics>>}
- */
-export const CLOTH_DYNAMICS_LIBRARY = Object.freeze([
-    CLOTH_SILK,
-    CLOTH_COTTON,
-    CLOTH_DENIM,
-    CLOTH_LEATHER,
-    CLOTH_ROPE,
-    CLOTH_CHAIN,
-    CLOTH_HAIR
-]);
-
-/**
- * The library entries by name, for a tool, a serialiser or a playground that
- * has a string and wants the entry.
- * @type {Readonly<Object<string, Readonly<ClothDynamics>>>}
- */
-export const CLOTH_DYNAMICS_BY_NAME = Object.freeze({
-    SILK: CLOTH_SILK,
-    COTTON: CLOTH_COTTON,
-    DENIM: CLOTH_DENIM,
-    LEATHER: CLOTH_LEATHER,
-    ROPE: CLOTH_ROPE,
-    CHAIN: CLOTH_CHAIN,
-    HAIR: CLOTH_HAIR
-});
+import { ClothDynamics } from "./ClothDynamics.js";
+import { ClothDynamicsFlags } from "./ClothDynamicsFlags.js";
+
+/**
+ * # The library — points in the parameter space that are known to be good
+ *
+ * Seven frozen {@link ClothDynamics} instances. Assign one directly and it is
+ * shared, immutable and free; `.clone()` it and you own a copy to edit. They
+ * are a set of points rather than a mechanism: nothing here is computed, and
+ * nothing here is a preset system that has to be re-applied when a field
+ * changes.
+ *
+ * ```js
+ * rope_top.add(Cloth.from(CLOTH_ROPE));
+ *
+ * const wet = CLOTH_ROPE.clone();
+ * wet.damping = 0.4;
+ * ```
+ *
+ * ## Every entry is sized to the measured frame budget
+ *
+ * M0 measured the §17 workload — 1,024 particles at 2 substeps × 4 iterations —
+ * at 3.48 ms against a 2 ms target and priced three levers that each closed it
+ * on their own. **M1 changed that arithmetic**, because M1 added rows: a
+ * strain-limit row per link, a tether per particle, and a slack row per
+ * particle for any fabric that follows an animated pose. The same 1,024
+ * particles at 2×4 now cost **4.61 ms**, and no single lever reaches 2 ms from
+ * there — 1,024 at 2×2 is 2.38 ms and 484 at 2×4 is 2.53 ms, both still over.
+ * Every garment entry below therefore spends **two** levers, and the numbers
+ * are from `__fixtures__/cloth_library_bench.mjs`, which builds precisely the
+ * row set `cloth_seed_subtree` builds and runs precisely the budgets this file
+ * ships. `MEASUREMENTS.md` §10.
+ *
+ * The chains are two orders of magnitude cheaper and can afford the full
+ * budget and more; the garments are where the levers are spent.
+ *
+ * ## What `stretch` and `bend` mean here, and where `stretch` stops meaning it
+ *
+ * `stretch` is the strain the fabric may carry, log-mapped: `1` is a chain at a
+ * tenth of a per cent, `0` is a knit at a quarter of its length. `bend` is a
+ * ratio of the row's own inertial scale and **saturates at 1** — a soft row
+ * stiffer than the top of the dissipative band stops coming to rest at all, so
+ * leather is at the ceiling rather than above it. `cloth_dynamics_map.js`
+ * carries both derivations.
+ *
+ * ## Which entries collide with themselves, and why the list moved
+ *
+ * §9 said the flag belongs on "skirts, long coats, hair" — a list of what the
+ * garment *is*. **M4 measured that what decides is `bend`.** On a folding sheet
+ * at each entry's own bending: silk, hair and cotton pass through themselves 8
+ * to 11 times a sample unaided and the row removes 71% to 81% of it; denim
+ * tangles a third as much; leather does not tangle at all — 0.18 crossings a
+ * sample — and the row makes it marginally worse, because the handful of pairs
+ * it finds on a fabric that will not fold are noise it is adding.
+ *
+ * So `CLOTH_SILK`, `CLOTH_COTTON` and `CLOTH_HAIR` set it and nothing else
+ * does. It costs each of them about a fifth of their frame and all three stay
+ * inside 2 ms. The chains have no surface to pass through and a coiling rope is
+ * a case that measurement does not cover. `MEASUREMENTS.md` §33.
+ *
+ * `stretch` is also the weakest field in the set, and the entries say so by
+ * which of them set `ClothDynamicsFlags.StrainLimit`. Measured on a 24-link
+ * rope dropped through ninety degrees, the strain-limit row removes about a
+ * third of the peak over-stretch at every budget and **never reaches its own
+ * allowance** — at `stretch = 1` it asks for 0.1% and delivers 5.9% at 1×1,
+ * 2.2% at 2×2 and 0.9% at 2×4. It is a second hard row on an edge that already
+ * has one, so it competes for the same trust region and the same penalty band
+ * as the row it is backing up. That makes it worth its 13–15% of a garment
+ * frame where the residual is visible — a low iteration count — and not worth
+ * it where the residual is already around one per cent. The entries at 2×4
+ * clear the flag; the ones at 2×2, and the chains where it is free, keep it.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+
+/**
+ * Silk, chiffon, a light banner. Barely resists folding, extends almost not at
+ * all, and follows the animation loosely enough to flow.
+ *
+ * *Budget:* **400 particles at 2×4 — 1.49 ms.** Two levers: fewer particles,
+ * and no strain-limit row. A silk garment is the one that most wants substeps
+ * and iterations, so it keeps both and pays for them everywhere else; at 2×4
+ * the fabric row is inside 1.4% of strain unaided and the strain-limit row
+ * would buy half a per cent of that for 15% of the frame.
+ *
+ * *Self-collision:* **on, and it is the third lever's worth.** 1.46 ms to
+ * 1.78 ms, +22%, still inside. Silk is the floppiest fabric in the set and a
+ * folding sheet of it passes through itself 8 times a sample without the row;
+ * with it, 2.4. `MEASUREMENTS.md` §33.
+ * @type {Readonly<ClothDynamics>}
+ */
+export const CLOTH_SILK = Object.freeze(ClothDynamics.from({
+    stretch: 0.85,
+    bend: 0.04,
+    damping: 0.06,
+    slack: 0.75,
+    thickness: 0.004,
+    inertia: 1,
+    drag: 0.45,
+    substeps: 2,
+    iterations: 4,
+    flags: ClothDynamicsFlags.SelfCollision
+}));
+
+/**
+ * Cotton, linen, a shirt. The default fabric, and the one every other entry is
+ * a deviation from.
+ *
+ * *Budget:* **400 particles at 2×4 — 1.49 ms.** Fewer particles, and no
+ * strain-limit row, for the same reason silk drops it.
+ *
+ * *Self-collision:* **on.** 1.51 ms to 1.82 ms, +21%, still inside. This is
+ * the entry every other one is a deviation from, and a default that passes
+ * through itself nine times a sample while it moves is a bad default.
+ * `MEASUREMENTS.md` §33.
+ * @type {Readonly<ClothDynamics>}
+ */
+export const CLOTH_COTTON = Object.freeze(ClothDynamics.from({
+    stretch: 0.8,
+    bend: 0.25,
+    damping: 0.12,
+    slack: 0.6,
+    thickness: 0.008,
+    inertia: 1,
+    drag: 0.2,
+    substeps: 2,
+    iterations: 4,
+    flags: ClothDynamicsFlags.SelfCollision
+}));
+
+/**
+ * Denim, canvas, a heavy coat. Stiff, quiet, and inclined to hold a fold.
+ *
+ * *Budget:* **576 particles at 2×2 — 1.28 ms.** Two levers: half the
+ * iterations, and fewer particles. A heavy garment is large, so it spends more
+ * of its allowance on particles than silk does and takes it back from the
+ * iteration count; §5.1's whole claim is that a lower iteration count converges
+ * less far towards the *same* answer rather than towards a different one, and a
+ * stiff fabric is where that is least visible. It keeps the strain-limit row,
+ * because at 2×2 the residual is 3.5% and the row takes a third of it.
+ * @type {Readonly<ClothDynamics>}
+ */
+export const CLOTH_DENIM = Object.freeze(ClothDynamics.from({
+    stretch: 0.93,
+    bend: 0.62,
+    damping: 0.25,
+    slack: 0.4,
+    thickness: 0.014,
+    inertia: 1,
+    drag: 0.08,
+    substeps: 2,
+    iterations: 2
+}));
+
+/**
+ * Leather, oilcloth, armour skirting. The stiffest fabric this solver can hold
+ * and still come to rest — `bend` is at the ceiling of the dissipative band,
+ * not merely high.
+ *
+ * *Budget:* **576 particles at 2×2 — 1.28 ms**, as denim, and for the same
+ * reasons.
+ * @type {Readonly<ClothDynamics>}
+ */
+export const CLOTH_LEATHER = Object.freeze(ClothDynamics.from({
+    stretch: 0.97,
+    bend: 1,
+    damping: 0.35,
+    slack: 0.3,
+    thickness: 0.02,
+    inertia: 1,
+    drag: 0.05,
+    substeps: 2,
+    iterations: 2
+}));
+
+/**
+ * Rope, cable, a mooring line. No meaningful animated pose to follow — a rope
+ * hangs where physics puts it — so `slack` is at 1, which by the derivation in
+ * `cloth_seed_subtree.js` means the leash row is provably inactive and is not
+ * built at all. The tether carries the inextensibility on its own.
+ *
+ * *Budget:* **40 links at the full 2×4 — 0.04 ms.** No lever at all: a chain
+ * wants more of both than a sheet does and can simply afford it, because the
+ * cost is close to linear in particles and a rope has two orders fewer. The
+ * strain-limit row is free at this size and `stretch` is a rope's most
+ * characteristic property, so it stays.
+ * @type {Readonly<ClothDynamics>}
+ */
+export const CLOTH_ROPE = Object.freeze(ClothDynamics.from({
+    stretch: 0.98,
+    bend: 0.06,
+    damping: 0.1,
+    slack: 1,
+    thickness: 0.015,
+    inertia: 1,
+    drag: 0.12,
+    substeps: 2,
+    iterations: 4
+}));
+
+/**
+ * Chain, beads, a pull cord — links that barely extend and barely bend, but do
+ * not flow the way a rope does.
+ *
+ * *Budget:* **40 links at 2×6 — 0.06 ms.** Depth is how far a constraint force
+ * travels in one sweep, and a chain is the deepest thing this system simulates,
+ * so this is the one entry that spends *more* than the nominal budget rather
+ * than less. It can: at forty particles the whole step is a rounding error
+ * against the frame.
+ * @type {Readonly<ClothDynamics>}
+ */
+export const CLOTH_CHAIN = Object.freeze(ClothDynamics.from({
+    stretch: 1,
+    bend: 0.15,
+    damping: 0.2,
+    slack: 1,
+    thickness: 0.012,
+    inertia: 1,
+    drag: 0.05,
+    substeps: 2,
+    iterations: 6
+}));
+
+/**
+ * Hair, a ponytail, a horse's tail. Many shallow strands rather than one deep
+ * one, which is why it is the only entry that asks for self-collision: strands
+ * that pass through each other read as wrong in a way a single chain never
+ * does.
+ *
+ * *Budget:* **400 particles across all strands at 2×4 — 1.49 ms**, the same
+ * two levers silk takes.
+ *
+ * *Self-collision:* **on, and M4 priced it.** 1.53 ms to 1.81 ms, +19%, still
+ * inside. This was the only entry that set the flag before there was anything
+ * to honour it, and the measurement agrees with the claim: hair passes through
+ * itself 10.6 times a sample unaided, the most of any entry, and the row
+ * removes 81% of that. `MEASUREMENTS.md` §33.
+ * @type {Readonly<ClothDynamics>}
+ */
+export const CLOTH_HAIR = Object.freeze(ClothDynamics.from({
+    stretch: 0.95,
+    bend: 0.2,
+    damping: 0.18,
+    slack: 0.55,
+    thickness: 0.006,
+    inertia: 1,
+    drag: 0.3,
+    substeps: 2,
+    iterations: 4,
+    flags: ClothDynamicsFlags.SelfCollision
+}));
+
+/**
+ * Every entry, in one frozen array — for a tool that wants to show them all,
+ * and for the spec that holds the whole library to the value semantics and the
+ * budget.
+ * @type {ReadonlyArray<Readonly<ClothDynamics>>}
+ */
+export const CLOTH_DYNAMICS_LIBRARY = Object.freeze([
+    CLOTH_SILK,
+    CLOTH_COTTON,
+    CLOTH_DENIM,
+    CLOTH_LEATHER,
+    CLOTH_ROPE,
+    CLOTH_CHAIN,
+    CLOTH_HAIR
+]);
+
+/**
+ * The library entries by name, for a tool, a serialiser or a playground that
+ * has a string and wants the entry.
+ * @type {Readonly<Object<string, Readonly<ClothDynamics>>>}
+ */
+export const CLOTH_DYNAMICS_BY_NAME = Object.freeze({
+    SILK: CLOTH_SILK,
+    COTTON: CLOTH_COTTON,
+    DENIM: CLOTH_DENIM,
+    LEATHER: CLOTH_LEATHER,
+    ROPE: CLOTH_ROPE,
+    CHAIN: CLOTH_CHAIN,
+    HAIR: CLOTH_HAIR
+});

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

@@ -0,0 +1,59 @@
+/**
+ * # Bringing the world's colliders into a cloth's frame
+ *
+ * The index holds every live cloth collider in **world** coordinates; the
+ * solver works in the cloth's own **local** frame (§12 — garment-sized
+ * coordinates are what makes `Float32` particle state ample, and the local
+ * frame is what makes §7 P7's inertia model natural). So once per cloth per
+ * step, the colliders that could touch it are queried out of the index and
+ * rewritten into its frame.
+ *
+ * ## Both poses go into the *current* anchor frame
+ *
+ * A record carries where the collider was and where it is. Both are converted
+ * using the anchor's pose **now**, not each with the anchor pose of its own
+ * step, so what the sweep interpolates is the collider's motion *relative to
+ * the cloth's frame*. That is the motion the particles actually see: the frame
+ * change has already been applied to them by `move_local_frame`, scaled by
+ * `ClothDynamics#inertia`, before the step begins.
+ *
+ * The alternative — converting each pose in its own frame — would make a
+ * collider appear to move whenever the anchor did, so a character running past
+ * a static wall would sweep the wall through their own cape.
+ *
+ * ## The query box
+ *
+ * The cloth's own particle bounds, fattened by how far a contact reaches, and
+ * then by how far the solver will let a particle travel in one step. The second
+ * term is what stops a fast cloth outrunning its own broadphase within the step
+ * it was gathered for; it is the velocity clamp of §7 P1 read as a distance,
+ * which is the quantity it was built out of.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+/**
+ * Query the index and rewrite the overlapping colliders into the cloth's frame.
+ *
+ * @param {ClothInstance} instance filled in place — `collider_table`,
+ *   `collider_key` and `collider_count`
+ * @param {ClothColliderIndex} index
+ * @param {number} reach how far a particle may travel this step, metres
+ * @returns {number} how many colliders were gathered
+ */
+export function cloth_gather_colliders(instance: ClothInstance, index: ClothColliderIndex, reach: number): number;
+/**
+ * Whether any collider overlapping this cloth moved between the previous step
+ * and this one — §7 P5's "wake on collider motion", asked without waking.
+ *
+ * A sleeping cloth is not stepped and not written back, so something has to
+ * notice when the world it was resting against moves. This is that something,
+ * and it is a broadphase query plus a pose comparison: cheaper than a step by
+ * three orders of magnitude, which is what makes sleep worth having at all.
+ *
+ * @param {ClothInstance} instance
+ * @param {ClothColliderIndex} index
+ * @returns {boolean}
+ */
+export function cloth_colliders_moved(instance: ClothInstance, index: ClothColliderIndex): boolean;
+//# sourceMappingURL=cloth_gather_colliders.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"cloth_gather_colliders.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/ecs/cloth_gather_colliders.js"],"names":[],"mappings":"AA8BA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAEH;;;;;;;;GAQG;AACH,kGAHW,MAAM,GACJ,MAAM,CAsJlB;AAgDD;;;;;;;;;;;;GAYG;AACH,2FAFa,OAAO,CAsBnB"}