@woosh/meep-engine 3.22.0 → 3.23.0

package/src/engine/physics/cloth/solver/cloth_self_find.js

@@ -0,0 +1,448 @@
+import { PointHashGrid3 } from "../../../../core/geom/3d/hash-grid/PointHashGrid3.js";
+
+/**
+ * # Finding the self-collision pairs, once per step
+ *
+ * A uniform hash grid over the particles in the cloth's own frame, then for each
+ * particle the ones near it that are not already governed by a row. Rebuilt
+ * whole every step, exactly like the contact set (`cloth_contact_find.js`) and
+ * for the same reasons: one pass in a fixed order, so the step is deterministic.
+ *
+ * ## Adjacent pairs are excluded, and "adjacent" means "shares a row"
+ *
+ * §9: "Pairs sharing a triangle or an edge are excluded, since they are already
+ * governed by stretch and bend rows and would otherwise fight them." The exact
+ * form of that here is **sharing any row at all** — a stretch row, a bend
+ * stencil, or a chain's skip row, which is a stretch row too. Two particles a
+ * stretch row already holds at 5 cm do not also need a repulsion telling them to
+ * be 8 mm apart, and a bend stencil's four particles are a fold the bend row is
+ * the model of.
+ *
+ * The exclusion set is built **once, at seed**, from the row tables the state
+ * already carries: `cloth_self_exclusions` walks them and produces a sorted CSR
+ * list per particle. Testing a candidate is then a short scan over a handful of
+ * neighbours, which at typical garment topology is 16.8 entries a particle
+ * (`MEASUREMENTS.md` §8) — small enough that a scan beats a hash.
+ *
+ * ## The cell is the row's own diameter, and that fixes the neighbourhood
+ *
+ * Two particles interact when they are closer than `2·self_radius`, so a cell of
+ * exactly that makes the 27-cell walk necessary and sufficient. A larger cell
+ * would visit more candidates for nothing; a smaller one would need a wider
+ * walk, which is the same candidates through more buckets.
+ *
+ * **That radius is the proxy's resolution rather than the fabric's thickness**,
+ * and `ClothState#self_radius` carries why.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+
+/**
+ * Pairs one particle may **originate**, before the rest are dropped.
+ *
+ * A particle in a fold has a few neighbours across the fold and a few along it;
+ * eight is generous for a garment and is what bounds the pair list so a cloth
+ * that crumples into a ball cannot allocate its way out of a frame budget. A
+ * particle at the limit keeps the eight it found first in grid order, which is
+ * arbitrary among equals — and they are equals, because every one of them is
+ * inside the same radius.
+ *
+ * **"Originate", not "is in".** The search emits a pair once, from its lower
+ * index, so this caps how many pairs a particle starts and not how many it ends
+ * up in: a particle can be the *higher* index of any number of them. What the
+ * cap does bound exactly — and the only thing `ClothState` needs it to — is the
+ * length of the whole list, at this many per particle, because every pair is
+ * charged to exactly one of its two ends.
+ * @type {number}
+ */
+export const CLOTH_SELF_PAIRS_PER_PARTICLE = 8;
+
+/**
+ * Build the exclusion lists from a state's persistent rows.
+ *
+ * @param {ClothState} state
+ * @returns {{offset: Int32Array, partner: Int32Array}} CSR, sorted within each particle
+ */
+export function cloth_self_exclusions(state) {
+    const particle_count = state.particle_count;
+
+    /** @type {Set<number>[]} */
+    const sets = new Array(particle_count);
+
+    for (let i = 0; i < particle_count; i++) {
+        sets[i] = new Set();
+    }
+
+    /**
+     * @param {number} a
+     * @param {number} b
+     */
+    const link = (a, b) => {
+        if (a === b) {
+            return;
+        }
+
+        sets[a].add(b);
+        sets[b].add(a);
+    };
+
+    for (let row = 0; row < state.stretch_count; row++) {
+        link(state.stretch_particle[row * 2], state.stretch_particle[row * 2 + 1]);
+    }
+
+    for (let row = 0; row < state.bend_count; row++) {
+        const base = row * 4;
+
+        for (let a = 0; a < 4; a++) {
+            for (let b = a + 1; b < 4; b++) {
+                link(state.bend_particle[base + a], state.bend_particle[base + b]);
+            }
+        }
+    }
+
+    const offset = new Int32Array(particle_count + 1);
+
+    let total = 0;
+
+    for (let i = 0; i < particle_count; i++) {
+        total += sets[i].size;
+
+        offset[i + 1] = total;
+    }
+
+    const partner = new Int32Array(total);
+
+    for (let i = 0; i < particle_count; i++) {
+        const sorted = Array.from(sets[i]).sort((a, b) => a - b);
+
+        partner.set(sorted, offset[i]);
+    }
+
+    return { offset, partner };
+}
+
+/**
+ * The closest two particles get **without a row between them**, in whatever pose
+ * the state is in.
+
+ * This is the length that decides how wide a self-collision row may be written,
+ * and it has to be measured rather than assumed. On a triangulated sheet it is
+ * two hops — one hop is a stretch row, the mesh diagonal is a stretch row, and
+ * the two vertices across a diagonal are a bend stencil — so it comes out at
+ * twice the shortest row and the analytic answer and this one agree.
+ *
+ * **A rigged garment is not a sheet and the two do not agree.** Its proxy is a
+ * set of *strips*, and nothing connects one strip to the next: every pair across
+ * the gap between two strips is ungoverned, at whatever distance the artist
+ * placed the joints. That distance has nothing to do with the link length along
+ * a strip, which is what `shortest_row` measures. On the playground's cape they
+ * differ by a factor of two — 8.5 cm across the gap against the 16 cm a sheet's
+ * topology would predict — and a ceiling derived from the link length instead of
+ * measured left the settled cape with three permanently active pairs.
+ * `MEASUREMENTS.md` §37.
+ *
+ * Pinned particles are skipped, exactly as {@link cloth_self_find} skips them,
+ * so this measures the pairs the row can actually act on and nothing else.
+ *
+ * @param {ClothState} state
+ * @param {{offset: Int32Array, partner: Int32Array}} exclusions from {@link cloth_self_exclusions}
+ * @param {number} search only pairs closer than this are looked for; the walk is
+ *   bounded by it, and a proxy with nothing that close gets `Infinity` — which is
+ *   the right answer, because then no radius inside the bound can touch anything
+ * @returns {number} metres, or `Infinity`
+ */
+export function cloth_self_closest_free_pair(state, exclusions, search) {
+    const particle_count = state.particle_count;
+
+    if (!(search > 0) || particle_count < 2) {
+        return Infinity;
+    }
+
+    GRID.build(state.position, particle_count, search);
+
+    const position = state.position;
+    const mass_inverse = state.mass_inverse;
+
+    const offset = exclusions.offset;
+    const partner = exclusions.partner;
+
+    const grid_offset = GRID.offset;
+    const grid_point = GRID.point;
+
+    const inverse = 1 / search;
+
+    // The walk is a *maybe*: two cells can hash into one bucket, so a bucket can
+    // hand back a point from anywhere. Without this the answer would be the
+    // closest ungoverned pair the table happened to collide into view, which is
+    // a real distance but not the one `search` was asked for.
+    let closest_squared = search * search;
+
+    for (let i = 0; i < particle_count; i++) {
+        if (mass_inverse[i] === 0) {
+            continue;
+        }
+
+        const a = i * 3;
+
+        const x = position[a];
+        const y = position[a + 1];
+        const z = position[a + 2];
+
+        const cx = Math.floor(x * inverse);
+        const cy = Math.floor(y * inverse);
+        const cz = Math.floor(z * inverse);
+
+        const exclude_start = offset[i];
+        const exclude_end = offset[i + 1];
+
+        let visited = 0;
+
+        for (let dz = -1; dz <= 1; dz++) {
+            for (let dy = -1; dy <= 1; dy++) {
+                for (let dx = -1; dx <= 1; dx++) {
+                    const bucket = GRID.bucketOf(cx + dx, cy + dy, cz + dz);
+
+                    let seen = false;
+
+                    for (let v = 0; v < visited; v++) {
+                        if (VISITED[v] === bucket) {
+                            seen = true;
+
+                            break;
+                        }
+                    }
+
+                    if (seen) {
+                        continue;
+                    }
+
+                    VISITED[visited++] = bucket;
+
+                    const end = grid_offset[bucket + 1];
+
+                    for (let at = grid_offset[bucket]; at < end; at++) {
+                        const j = grid_point[at];
+
+                        if (j <= i || mass_inverse[j] === 0) {
+                            continue;
+                        }
+
+                        const b = j * 3;
+
+                        const ddx = x - position[b];
+                        const ddy = y - position[b + 1];
+                        const ddz = z - position[b + 2];
+
+                        const distance_squared = ddx * ddx + ddy * ddy + ddz * ddz;
+
+                        if (distance_squared >= closest_squared) {
+                            continue;
+                        }
+
+                        let excluded = false;
+
+                        for (let e = exclude_start; e < exclude_end; e++) {
+                            if (partner[e] === j) {
+                                excluded = true;
+
+                                break;
+                            }
+
+                            if (partner[e] > j) {
+                                break;
+                            }
+                        }
+
+                        if (excluded) {
+                            continue;
+                        }
+
+                        closest_squared = distance_squared;
+                    }
+                }
+            }
+        }
+    }
+
+    return closest_squared === search * search ? Infinity : Math.sqrt(closest_squared);
+}
+
+/**
+ * Rebuild the pair list.
+ *
+ * @param {ClothState} state pairs written into `self_pair`, count into `self_count`
+ * @param {{offset: Int32Array, partner: Int32Array}} exclusions from {@link cloth_self_exclusions}
+ * @returns {number} how many pairs were found
+ */
+export function cloth_self_find(state, exclusions) {
+    const particle_count = state.particle_count;
+
+    const radius = state.self_radius * 2;
+
+    if (radius <= 0) {
+        state.self_count = 0;
+
+        return 0;
+    }
+
+    GRID.build(state.position, particle_count, radius);
+
+    const position = state.position;
+    const mass_inverse = state.mass_inverse;
+
+    const pair = state.self_pair;
+
+    const capacity = pair.length / 2;
+
+    const offset = exclusions.offset;
+    const partner = exclusions.partner;
+
+    let count = 0;
+
+    const grid_offset = GRID.offset;
+    const grid_point = GRID.point;
+
+    const inverse = 1 / radius;
+
+    const radius_squared = radius * radius;
+
+    for (let i = 0; i < particle_count; i++) {
+        if (mass_inverse[i] === 0) {
+            // A pinned particle cannot be pushed, so a pair on it is a force
+            // assembled and thrown away for one end and doubled for the other.
+            continue;
+        }
+
+        const a = i * 3;
+
+        const x = position[a];
+        const y = position[a + 1];
+        const z = position[a + 2];
+
+        const cx = Math.floor(x * inverse);
+        const cy = Math.floor(y * inverse);
+        const cz = Math.floor(z * inverse);
+
+        const exclude_start = offset[i];
+        const exclude_end = offset[i + 1];
+
+        let found = 0;
+
+        let visited = 0;
+
+        for (let dz = -1; dz <= 1 && found < CLOTH_SELF_PAIRS_PER_PARTICLE; dz++) {
+            for (let dy = -1; dy <= 1 && found < CLOTH_SELF_PAIRS_PER_PARTICLE; dy++) {
+                for (let dx = -1; dx <= 1 && found < CLOTH_SELF_PAIRS_PER_PARTICLE; dx++) {
+                    const bucket = GRID.bucketOf(cx + dx, cy + dy, cz + dz);
+
+                    let seen = false;
+
+                    for (let v = 0; v < visited; v++) {
+                        if (VISITED[v] === bucket) {
+                            seen = true;
+
+                            break;
+                        }
+                    }
+
+                    if (seen) {
+                        continue;
+                    }
+
+                    VISITED[visited++] = bucket;
+
+                    const end = grid_offset[bucket + 1];
+
+                    for (let at = grid_offset[bucket]; at < end; at++) {
+                        const j = grid_point[at];
+
+                        // Each pair once, and never a particle against itself.
+                        // The `j > i` test is what halves the work and it is also
+                        // what makes the list order a function of the particle
+                        // numbering rather than of the grid's.
+                        if (j <= i) {
+                            continue;
+                        }
+
+                        if (mass_inverse[j] === 0) {
+                            continue;
+                        }
+
+                        const b = j * 3;
+
+                        const ddx = x - position[b];
+                        const ddy = y - position[b + 1];
+                        const ddz = z - position[b + 2];
+
+                        if (ddx * ddx + ddy * ddy + ddz * ddz >= radius_squared) {
+                            continue;
+                        }
+
+                        let excluded = false;
+
+                        for (let e = exclude_start; e < exclude_end; e++) {
+                            if (partner[e] === j) {
+                                excluded = true;
+
+                                break;
+                            }
+
+                            if (partner[e] > j) {
+                                // Sorted, so nothing further can match.
+                                break;
+                            }
+                        }
+
+                        if (excluded) {
+                            continue;
+                        }
+
+                        if (count >= capacity) {
+                            // The list is full. Dropping the rest is bounded and
+                            // visible — `ClothInstance#self_count` against the
+                            // capacity says so — and is the alternative to a
+                            // crumpled garment growing an allocation per frame.
+                            state.self_count = count;
+
+                            return count;
+                        }
+
+                        pair[count * 2] = i;
+                        pair[count * 2 + 1] = j;
+
+                        count++;
+                        found++;
+
+                        if (found >= CLOTH_SELF_PAIRS_PER_PARTICLE) {
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    state.self_count = count;
+
+    return count;
+}
+
+/**
+ * The grid, module-level and reused across every cloth and by both of the walks
+ * in this file. One cloth is stepped at a time and neither walk outlives its own
+ * call — {@link cloth_self_find} runs before the step and
+ * {@link cloth_self_closest_free_pair} runs once at seed — so a grid per instance
+ * would be one allocation per garment for no benefit. Neither may call the other.
+ * @type {PointHashGrid3}
+ * @private
+ */
+const GRID = new PointHashGrid3();
+
+/**
+ * Buckets the 27-cell walk has already visited, shared by both walks for the
+ * same reason {@link GRID} is: at most 27, never nested.
+ * @type {Int32Array}
+ * @private
+ */
+const VISITED = new Int32Array(27);

package/src/engine/physics/cloth/solver/cloth_solve_vertex.d.ts

@@ -8,6 +8,9 @@
  * @param {ClothState} state
  * @param {number} particle
  * @param {number} inverse_h_squared `1/h²` for the substep in progress
+ * @param {Float32Array|Float64Array|null} [collider_table] packed colliders in
+ *   the cloth's own frame, posed at this substep. `null` — the M0 and M1 case —
+ *   skips the contact rows entirely rather than looping over empty slots.
  */
-export function cloth_solve_vertex(state: ClothState, particle: number, inverse_h_squared: number): void;
+export function cloth_solve_vertex(state: ClothState, particle: number, inverse_h_squared: number, collider_table?: Float32Array | Float64Array | null): void;
 //# sourceMappingURL=cloth_solve_vertex.d.ts.map

package/src/engine/physics/cloth/solver/cloth_solve_vertex.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cloth_solve_vertex.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/solver/cloth_solve_vertex.js"],"names":[],"mappings":"AA6EA;;;;;;;;;;GAUG;AACH,gEAHW,MAAM,qBACN,MAAM,QAkHhB"}
+{"version":3,"file":"cloth_solve_vertex.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/solver/cloth_solve_vertex.js"],"names":[],"mappings":"AAgFA;;;;;;;;;;;;;GAaG;AACH,gEANW,MAAM,qBACN,MAAM,mBACN,YAAY,GAAC,YAAY,GAAC,IAAI,QA6HxC"}

package/src/engine/physics/cloth/solver/cloth_solve_vertex.js

@@ -1,6 +1,9 @@
 import { assert } from "../../../../core/assert.js";
+import { cloth_backstop_accumulate } from "./constraint/cloth_backstop_row.js";
 import { cloth_bend_accumulate } from "./constraint/cloth_bend_row.js";
+import { cloth_contact_accumulate } from "./constraint/cloth_contact_row.js";
 import { cloth_leash_accumulate } from "./constraint/cloth_leash_row.js";
+import { cloth_self_accumulate } from "./constraint/cloth_self_row.js";
 import { cloth_stretch_accumulate } from "./constraint/cloth_stretch_row.js";
 import {
     CVA_F_X,
@@ -85,8 +88,11 @@ const ACCUMULATOR = new Float64Array(CVA_STRIDE);
  * @param {ClothState} state
  * @param {number} particle
  * @param {number} inverse_h_squared `1/h²` for the substep in progress
+ * @param {Float32Array|Float64Array|null} [collider_table] packed colliders in
+ *   the cloth's own frame, posed at this substep. `null` — the M0 and M1 case —
+ *   skips the contact rows entirely rather than looping over empty slots.
  */
-export function cloth_solve_vertex(state, particle, inverse_h_squared) {
+export function cloth_solve_vertex(state, particle, inverse_h_squared, collider_table = null) {
     const inverse_mass = state.mass_inverse[particle];
 
     if (inverse_mass === 0) {
@@ -120,6 +126,15 @@ export function cloth_solve_vertex(state, particle, inverse_h_squared) {
     cloth_stretch_accumulate(accumulator, state, particle);
     cloth_bend_accumulate(accumulator, state, particle);
     cloth_leash_accumulate(accumulator, state, particle);
+    cloth_backstop_accumulate(accumulator, state, particle);
+
+    if (collider_table !== null) {
+        cloth_contact_accumulate(accumulator, state, particle, collider_table);
+    }
+
+    if (state.self_count > 0) {
+        cloth_self_accumulate(accumulator, state, particle);
+    }
 
     const a = accumulator[CVA_H_XX];
     const b = accumulator[CVA_H_XY];

package/src/engine/physics/cloth/solver/cloth_solver_constants.d.ts

@@ -49,10 +49,26 @@
  * for **transient** rows — a contact that should arrive soft and stiffen rather
  * than shock the mesh on its first frame — and M0 has none.
  *
- * **`β` could not be chosen from M0 data.** Above about 1e4 every M0 scenario
- * gives an identical answer, and with the band collapsed it has no effect at
- * all. The value below is a placeholder that M2 must replace with a
- * measurement against real contacts.
+ * **`β` is M2's, and it is 1e3 rather than M0's 1e5 placeholder.** M0 could not
+ * choose it: above about 1e4 every M0 scenario gave an identical answer, and
+ * with the band collapsed it had no effect at all. M2's contacts are the first
+ * transient rows in the system and the ramp is finally live. Measured on a
+ * 400-particle sheet landing on the ground, both ends of the range are worse
+ * than the middle: **no ramp at all** leaves a fast arrival's penalty at the
+ * floor and the multiplier alone to carry it, which settles at 1.95 J of
+ * residual kinetic energy against 0.12 J at 1e3; a **fast** ramp reaches the
+ * ceiling on violations of a millimetre and gives up most of what the low floor
+ * bought, settling three orders of magnitude worse on a gentle landing
+ * (6.4e-5 J against 3.2e-8 J). `MEASUREMENTS.md` §17.
+ *
+ * The scale-dependence the paragraph above warns of is real and is stated
+ * rather than removed: `β` has units of N/m², so it is a stiffness *per metre
+ * of violation*, and 1e3 against a ceiling of `8·(m/h²)` means the ramp is
+ * inert for a millimetre of penetration and reaches the ceiling within a step
+ * for a decimetre of it. That shape — gentle where the contact is grazing,
+ * immediate where it is a real interpenetration — is what the measurement
+ * picked, and a ratio-valued `β` that removed the dependence would have to
+ * choose the reference length that shape is built out of.
  *
  * @author Alex Goldring
  * @copyright Company Named Limited (c) 2026
@@ -63,7 +79,8 @@
  */
 export const CLOTH_ALPHA: number;
 /**
- * Penalty ramp.
+ * Penalty ramp, N/m². See the module docblock — measured at M2, against the
+ * first transient rows the system has.
  * @type {number}
  */
 export const CLOTH_BETA: number;
@@ -82,6 +99,96 @@ export const CLOTH_K_MIN_RATIO: number;
  * @type {number}
  */
 export const CLOTH_K_MAX_RATIO: number;
+/**
+ * Penalty floor for a **contact** row, as a multiple of the row's `m/h²`.
+ *
+ * Separate from {@link CLOTH_K_MIN_RATIO}, which is pinned to the ceiling,
+ * because a contact is the one row kind that *arrives*: a persistent row has
+ * been converging since the cloth was seeded and wants the stiffest penalty the
+ * step is stable at, and a contact that starts there shocks the mesh on its
+ * first frame.
+ *
+ * **A thirty-second of the ceiling**, measured. The floor is what decides how
+ * hard a new contact hits, and the measurement is unambiguous about the
+ * direction: on a sheet landing at 3 m/s, the peak contact force falls from
+ * 18.9 N at the ceiling to 0.16 N at an eighth of it and the settled kinetic
+ * energy falls by six orders of magnitude, while the penetration *improves*
+ * from 1.6 cm to 1.1 cm. Below about an eighth the numbers stop moving — every
+ * floor from ×1/8 down to ×1/128 gives the same penetration to three figures —
+ * so the value is a margin decision the same way `α·γ` was, and ×1/32 sits in
+ * the middle of the flat region with two decades of ramp above it.
+ *
+ * The reason the floor matters so little to the *residual* is the augmented
+ * Lagrangian working as designed: the multiplier carries the load and the
+ * penalty only has to be large enough to generate one. See MEASUREMENTS §17.
+ * @type {number}
+ */
+export const CLOTH_CONTACT_K_MIN_RATIO: number;
+/**
+ * Penalty stiffness for a **self-collision** row, as a multiple of the row's
+ * own `m_eff/h²`.
+ *
+ * It is a plain penalty rather than a hard row because the load it carries is
+ * cloth against cloth. `MEASUREMENTS.md` §18 measured why a *collider* contact
+ * cannot be soft — 376 N for a sheet arriving at 8 m/s against the 4.6 N a soft
+ * row inside M0's dissipative band can deliver — and a self-collision row never
+ * sees anything of the kind: what it holds apart weighs grams and is moving at
+ * the speed cloth moves relative to itself.
+ *
+ * **Eight, and the dissipative band is not the reason.** Eight is where M0's
+ * band tops out and it would be natural to read this as the same ceiling, but
+ * `MEASUREMENTS.md` §32 swept the ratio from 1 to 64 and found no energy growth
+ * anywhere: the band was measured on rows that are *on every step*, and a
+ * one-sided row that vanishes the instant it is satisfied has no standing spring
+ * to pump. What picks eight is the crossing count — it is the joint minimum of
+ * the mean, and a stiffer row makes the *worst* case steadily worse by throwing
+ * a particle hard enough to put the sheet through itself elsewhere.
+ *
+ * The consequence is a row with no multiplier, no warm start and no identity
+ * across steps, which is what makes rebuilding the pair list from scratch every
+ * step affordable. `MEASUREMENTS.md` §33.
+ * @type {number}
+ */
+export const CLOTH_SELF_RATIO: number;
+/**
+ * Smallest radius a self-collision row is written at, as a multiple of the
+ * cloth's shortest row — so the row's **diameter** is one particle spacing.
+ *
+ * `ClothState#self_radius` carries why the radius is a property of the proxy
+ * rather than of the fabric, and `MEASUREMENTS.md` §31 is the sweep: at the
+ * fabric's own thickness the row removes 21% of a folding sheet's
+ * self-intersections and here it removes 82%.
+ * @type {number}
+ */
+export const CLOTH_SELF_RADIUS_MIN_RATIO: number;
+/**
+ * Largest radius a self-collision row is written at, as a fraction of the
+ * closest two particles get **with no row between them** in the bind pose —
+ * `ClothInstance#closest_free_pair`. Two fifths of it, so the row's diameter is
+ * four fifths of the nearest thing it could touch and a cloth at rest is never
+ * in contact with itself.
+ *
+ * **A ceiling is needed because the floor is not always reachable.** A thick
+ * fabric on a coarse proxy takes its thickness rather than
+ * {@link CLOTH_SELF_RADIUS_MIN_RATIO}, and a diameter that reaches the nearest
+ * ungoverned pair puts a cloth that is not folded at all in permanent contact
+ * with itself — leather, 20 mm thick on a 20 mm proxy, found 1,398 pairs a step
+ * across 576 particles standing still. `MEASUREMENTS.md` §36.
+ *
+ * **And it is measured rather than derived, because a garment is not a sheet.**
+ * On a triangulated sheet the closest ungoverned pair is exactly two hops, so
+ * this comes out at four fifths of the shortest row and the analytic answer
+ * would have done — checked at two spacings, to the precision the proxy's
+ * Float32 positions carry. A rigged
+ * garment's proxy is *strips* with nothing joining one to the next, so every
+ * pair across the gap is ungoverned at whatever distance the artist put the
+ * joints, which the shortest row knows nothing about: the playground's cape has
+ * 8 cm links and 8.5 cm gaps, half what a sheet would imply. Derived from the
+ * link length the ceiling left that cape with three pairs permanently in
+ * contact at rest; measured, it has none. `MEASUREMENTS.md` §37.
+ * @type {number}
+ */
+export const CLOTH_SELF_RADIUS_MAX_RATIO: number;
 /**
  * The five constants as one frozen object, which is what {@link cloth_step}
  * takes. A sweep passes its own; nothing else should.

package/src/engine/physics/cloth/solver/cloth_solver_constants.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cloth_solver_constants.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/solver/cloth_solver_constants.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0DG;AAEH;;;GAGG;AACH,0BAFU,MAAM,CAEgB;AAEhC;;;GAGG;AACH,yBAFU,MAAM,CAEc;AAE9B;;;GAGG;AACH,0BAFU,MAAM,CAEa;AAE7B;;;GAGG;AACH,gCAFU,MAAM,CAEmB;AAEnC;;;GAGG;AACH,gCAFU,MAAM,CAEmB;AAEnC;;;;GAIG;AACH,kCAFU,SAAS;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,MAAM,CAAA;CAAC,CAAC,CAQvG"}
+{"version":3,"file":"cloth_solver_constants.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/solver/cloth_solver_constants.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0EG;AAEH;;;GAGG;AACH,0BAFU,MAAM,CAEgB;AAEhC;;;;GAIG;AACH,yBAFU,MAAM,CAEc;AAE9B;;;GAGG;AACH,0BAFU,MAAM,CAEa;AAE7B;;;GAGG;AACH,gCAFU,MAAM,CAEmB;AAEnC;;;GAGG;AACH,gCAFU,MAAM,CAEmB;AAEnC;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wCAFU,MAAM,CAE8B;AAE9C;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,+BAFU,MAAM,CAEkB;AAElC;;;;;;;;;GASG;AACH,0CAFU,MAAM,CAE+B;AAE/C;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,0CAFU,MAAM,CAE+B;AAE/C;;;;GAIG;AACH,kCAFU,SAAS;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,MAAM,CAAA;CAAC,CAAC,CAQvG"}