@woosh/meep-engine 3.47.0 → 3.49.0

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

@@ -30,7 +30,6 @@ import {
     collect_entity_playbacks
 } from "../../../graphics3/pose/collect_entity_playbacks.js";
 import { MeshSkin } from "../../../graphics/ecs/mesh-v2/MeshSkin.js";
-import { CLOTH_SELF_RADIUS_MAX_RATIO, CLOTH_SELF_RADIUS_MIN_RATIO } from "../solver/cloth_solver_constants.js";
 import { cloth_air_changed, cloth_sample_air } from "../wind/cloth_sample_air.js";
 import { ClothStepParam } from "../solver/cloth_step_instance.js";
 import { ClothStepResult } from "../solver/ClothState.js";
@@ -1472,20 +1471,10 @@ export class ClothWorld {
         params[offset + ClothStepParam.COLLIDER_COUNT] = state.collider_count;
         params[offset + ClothStepParam.SELF_COLLISION] = self_collision ? 1 : 0;
 
-        // Half the shortest row, so the row's diameter is one particle
-        // spacing. `ClothState#self_radius` carries why the fabric's own
-        // thickness is the wrong length here and `MEASUREMENTS.md` §31 is the
-        // sweep that settled it. A fabric thicker than its proxy is coarse
-        // keeps its thickness — and is then clamped under the closest pair
-        // the proxy has with no row between them, because a diameter that
-        // reaches that pair puts a cloth which is not folded at all in
-        // permanent contact with itself (§36, §37).
-        params[offset + ClothStepParam.SELF_RADIUS] = self_collision
-            ? Math.min(
-                Math.max(dynamics.thickness, instance.shortest_row * CLOTH_SELF_RADIUS_MIN_RATIO),
-                instance.closest_free_pair * CLOTH_SELF_RADIUS_MAX_RATIO
-            )
-            : 0;
+        // The self-collision radius is each particle's own — half its shortest
+        // row, over the thickness, under two fifths of its closest free pair —
+        // and the step derives it from the thickness word above
+        // (`cloth_self_radius_update`), so nothing about it crosses here.
 
         // Ramp back from nothing over the window. The first step after a
         // reset is allowed no velocity at all, which is what stops a

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

@@ -88,7 +88,7 @@ export class WorkerClothSystem extends WorkerSystem {
         max_cloth_count?: number;
     });
     dependencies: (typeof Transform64 | typeof Cloth)[];
-    components_used: (ResourceAccessSpecification<typeof Transform64> | ResourceAccessSpecification<typeof TransformAttachment> | ResourceAccessSpecification<typeof GPUStateAuthority> | ResourceAccessSpecification<typeof ParentEntity> | ResourceAccessSpecification<typeof ClothCollider> | ResourceAccessSpecification<typeof Cloth> | ResourceAccessSpecification<typeof ClothExclude> | ResourceAccessSpecification<typeof ClothRig> | ResourceAccessSpecification<typeof ClothPin>)[];
+    components_used: (ResourceAccessSpecification<typeof Transform64> | ResourceAccessSpecification<typeof TransformAttachment> | ResourceAccessSpecification<typeof GPUStateAuthority> | ResourceAccessSpecification<typeof ParentEntity> | ResourceAccessSpecification<typeof ClothCollider> | ResourceAccessSpecification<typeof Cloth> | ResourceAccessSpecification<typeof ClothExclude> | ResourceAccessSpecification<typeof ClothRig> | ResourceAccessSpecification<typeof ClothPin> | ResourceAccessSpecification<typeof FluidComponent>)[];
     /**
      * The cloths, and everything about stepping one that is not arithmetic.
      * Shared with {@link ClothSystem}, which is what makes the two systems one
@@ -187,5 +187,6 @@ import { ClothCollider } from "./ClothCollider.js";
 import { ClothExclude } from "./ClothExclude.js";
 import { ClothRig } from "./ClothRig.js";
 import { ClothPin } from "./ClothPin.js";
+import { FluidComponent } from "../../fluid/ecs/FluidComponent.js";
 import { ClothWorld } from "./ClothWorld.js";
 //# sourceMappingURL=WorkerClothSystem.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"WorkerClothSystem.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/ecs/WorkerClothSystem.js"],"names":[],"mappings":"AA6BA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0EG;AACH;IAyEI;;;;;;;;OAQG;IACH;QAPiC,cAAc,EAApC,MAAM,MAAM;QAIK,eAAe,GAAhC,MAAM;OAYhB;IAzFD,oDAAoC;IAEpC,2dAYE;IAEF;;;;;OAKG;IACH,OAFU,UAAU,CAEK;IA6EzB;;OAEG;IACH,iCAEC;IAbD;;;OAGG;IACH,4BAEC;IAoBD;;OAEG;IACH,qBAEC;IAhBD;;;;;;OAMG;IACH,gBAEC;IASD;;OAEG;IACH,iCAEC;IA2BD;;;OAGG;IACH,wDAFa,IAAI,CAIhB;IAED;;;OAGG;IACH,wDAFa,IAAI,CAIhB;IAcD;;;;OAIG;IACH,YAJW,KAAK,aACL,WAAW,UACX,MAAM,QAIhB;IAED;;;;OAIG;IACH,cAJW,KAAK,aACL,WAAW,UACX,MAAM,QAQhB;IAED;;;;OAIG;IACH,eAHW,MAAM,GACJ,IAAI,CAIhB;IAED;;;;OAIG;IACH,aAHW,MAAM,GACJ,IAAI,CAIhB;IAED;;;OAGG;IACH,mBAHW,MAAM,GACJ,gBAAc,SAAS,CAInC;IAED;;;;;;OAMG;IACH,mBAJW,MAAM,UACN,MAAM,GACJ,MAAM,CAIlB;IAED;;;;OAIG;IACH,iCAEC;;CAmOJ;6BArkB4B,oCAAoC;4BAIrC,uCAAuC;sBAE7C,YAAY;4CAPU,uDAAuD;oCAI5F,0DAA0D;kCAQ/B,uCAAuC;6BAC5C,qCAAqC;8BALpC,oBAAoB;6BACrB,mBAAmB;yBAEvB,eAAe;yBADf,eAAe;2BAIb,iBAAiB"}
+{"version":3,"file":"WorkerClothSystem.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/ecs/WorkerClothSystem.js"],"names":[],"mappings":"AA8BA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0EG;AACH;IA6EI;;;;;;;;OAQG;IACH;QAPiC,cAAc,EAApC,MAAM,MAAM;QAIK,eAAe,GAAhC,MAAM;OAYhB;IA7FD,oDAAoC;IAEpC,ghBAgBE;IAEF;;;;;OAKG;IACH,OAFU,UAAU,CAEK;IA6EzB;;OAEG;IACH,iCAEC;IAbD;;;OAGG;IACH,4BAEC;IAoBD;;OAEG;IACH,qBAEC;IAhBD;;;;;;OAMG;IACH,gBAEC;IASD;;OAEG;IACH,iCAEC;IA2BD;;;OAGG;IACH,wDAFa,IAAI,CAIhB;IAED;;;OAGG;IACH,wDAFa,IAAI,CAIhB;IAcD;;;;OAIG;IACH,YAJW,KAAK,aACL,WAAW,UACX,MAAM,QAIhB;IAED;;;;OAIG;IACH,cAJW,KAAK,aACL,WAAW,UACX,MAAM,QAQhB;IAED;;;;OAIG;IACH,eAHW,MAAM,GACJ,IAAI,CAIhB;IAED;;;;OAIG;IACH,aAHW,MAAM,GACJ,IAAI,CAIhB;IAED;;;OAGG;IACH,mBAHW,MAAM,GACJ,gBAAc,SAAS,CAInC;IAED;;;;;;OAMG;IACH,mBAJW,MAAM,UACN,MAAM,GACJ,MAAM,CAIlB;IAED;;;;OAIG;IACH,iCAEC;;CAmOJ;6BA1kB4B,oCAAoC;4BAIrC,uCAAuC;sBAG7C,YAAY;4CARU,uDAAuD;oCAI5F,0DAA0D;kCAS/B,uCAAuC;6BAC5C,qCAAqC;8BALpC,oBAAoB;6BACrB,mBAAmB;yBAEvB,eAAe;yBADf,eAAe;+BALT,mCAAmC;2BASvC,iBAAiB"}

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

@@ -5,6 +5,7 @@ import {
     TransformAttachment
 } from "../../../ecs/transform-attachment/TransformAttachment.js";
 import { Transform64 } from "../../../ecs/transform/Transform64.js";
+import { FluidComponent } from "../../fluid/ecs/FluidComponent.js";
 import { ClothStepParam } from "../solver/cloth_step_instance.js";
 import { Cloth } from "./Cloth.js";
 import { ClothCollider } from "./ClothCollider.js";
@@ -117,7 +118,11 @@ export class WorkerClothSystem extends WorkerSystem {
         // model it belongs to and who composes its transform.
         ResourceAccessSpecification.from(ClothPin, ResourceAccessKind.Read),
         ResourceAccessSpecification.from(ParentEntity, ResourceAccessKind.Read),
-        ResourceAccessSpecification.from(GPUStateAuthority, ResourceAccessKind.Read)
+        ResourceAccessSpecification.from(GPUStateAuthority, ResourceAccessKind.Read),
+        // The air `ClothFluidWind` samples, on this thread in `collect`. As in
+        // `ClothSystem`, a cycle with the `Transform64` every fluid system reads,
+        // which the score decides for cloth (`cloth_wind.spec.js`).
+        ResourceAccessSpecification.from(FluidComponent, ResourceAccessKind.Read)
     ];
 
     /**

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

@@ -1 +1 @@
-{"version":3,"file":"cloth_build_rows.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/ecs/cloth_build_rows.js"],"names":[],"mappings":"AAqEA;;;;GAIG;AACH,+DAFa,IAAI,CAsBhB;AAED;;;;;;;;;;GAUG;AACH,2DAFa,IAAI,CA6BhB;AAED;;;;;;;;GAQG;AACH,8DAFa,IAAI,CAgDhB;AAED;;;;;;;;;;;;;;GAcG;AACH,4CAJW,YAAY,SACZ,MAAM,GACJ,MAAM,CAYlB;AAED;;;;;;;;;;;;;GAaG;AACH,8DAHW,MAAM,GACJ,IAAI,CAkOhB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,kEAHW,MAAM,GACJ,IAAI,CAiEhB;AAED;;;;;;;;;;;GAWG;AACH,iGAFa,OAAO,CAkBnB;AA/iBD;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH;;;;GAIG;AACH,kCAFU,MAAM,CAEwB;AAIxC;;;;;;;;;;;;;;;;;GAiBG;AACH,gCAFU,MAAM,CAEmB"}
+{"version":3,"file":"cloth_build_rows.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/ecs/cloth_build_rows.js"],"names":[],"mappings":"AAqEA;;;;GAIG;AACH,+DAFa,IAAI,CAsBhB;AAED;;;;;;;;;;GAUG;AACH,2DAFa,IAAI,CA6BhB;AAED;;;;;;;;GAQG;AACH,8DAFa,IAAI,CAgDhB;AAED;;;;;;;;;;;;;;GAcG;AACH,4CAJW,YAAY,SACZ,MAAM,GACJ,MAAM,CAYlB;AAED;;;;;;;;;;;;;GAaG;AACH,8DAHW,MAAM,GACJ,IAAI,CA4OhB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,kEAHW,MAAM,GACJ,IAAI,CAiEhB;AAED;;;;;;;;;;;GAWG;AACH,iGAFa,OAAO,CAkBnB;AAzjBD;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH;;;;GAIG;AACH,kCAFU,MAAM,CAEwB;AAIxC;;;;;;;;;;;;;;;;;GAiBG;AACH,gCAFU,MAAM,CAEmB"}

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

@@ -425,20 +425,30 @@ export function cloth_build_rows(instance, dt) {
     cloth_particle_of_source(particle_of_node, state.source_of_particle, node_count);
 
     // Everything derived from the rows, derived again — and from the bind pose,
-    // which is what `closest_free_pair` has to be measured in: the answer is a
-    // property of how the proxy was authored, not of whatever shape the solver
-    // happens to have the cloth in when self-collision is first switched on.
+    // which is what each particle's closest free pair has to be measured in: the
+    // answer is a property of how the proxy was authored, not of whatever shape
+    // the solver happens to have the cloth in when self-collision is first
+    // switched on.
     const exclusions = cloth_self_exclusions(state);
 
     instance.self_exclusions = exclusions;
 
-    // Bounded at twice the shortest row, which is where a sheet's answer lies,
-    // so the walk is 27 cells rather than the whole cloth. A proxy with nothing
-    // that close gets `Infinity`, and then no radius inside the floor can reach
-    // anything either.
-    instance.closest_free_pair = cloth_self_closest_free_pair(
-        state, exclusions, instance.shortest_row * 2
-    );
+    // Bounded at twice the longest of the particles' own shortest rows, which
+    // reaches every particle's two hops — a skirt's hem's as well as its
+    // waistband's — so the walk is 27 cells rather than the whole cloth. A
+    // particle with nothing that close gets `Infinity`, and then no radius
+    // inside its floor can reach anything either.
+    let longest_row = 0;
+
+    for (let i = 0; i < state.particle_count; i++) {
+        const row = state.self_row[i];
+
+        if (row < Infinity && row > longest_row) {
+            longest_row = row;
+        }
+    }
+
+    cloth_self_closest_free_pair(state, exclusions, longest_row * 2);
 
     instance.particle_of_node = particle_of_node;
     instance.blended_position = new Float64Array(node_count * 3);

package/src/engine/physics/cloth/playground/collide.html

@@ -146,11 +146,13 @@
     <h2>Contact band</h2>
     <p class="blurb">
         M0 could not choose these: the ramp only means something for a row that <b>arrives</b>, and a
-        contact is the first one in the system that does. Measured defaults are
-        k_min = k_max/32 and β = 1e3.
+        contact is the first one in the system that does. The ramp is the fraction of the band a
+        contact gains per offset of violation per iteration. Measured defaults are
+        k_min = k_max/32 and a ramp of 0.1; drag the ramp down to 0.003, which is what β = 1e3 was
+        worth on a garment, and sweep the capsule through.
     </p>
     <label><span>k_min ÷ k_max</span><input id="k_floor" type="range" min="-7" max="0" step="0.25"><output id="k_floor_out"></output></label>
-    <label><span>β</span><input id="beta" type="range" min="0" max="7" step="0.25"><output id="beta_out"></output></label>
+    <label><span>ramp</span><input id="ramp" type="range" min="-3" max="1" step="0.125"><output id="ramp_out"></output></label>
     <div class="buttons"><button id="defaults">measured defaults</button></div>
 
     <h2>Sweep</h2>

package/src/engine/physics/cloth/playground/collide_main.js

@@ -85,7 +85,7 @@ const control = {
     substeps: 2,
     iterations: 4,
     k_floor: 1 / 32,
-    beta: CLOTH_SOLVER_TUNING.beta,
+    ramp: CLOTH_SOLVER_TUNING.contact_ramp_ratio,
     swept: true,
     animate: true,
     running: true
@@ -166,10 +166,11 @@ function step_once() {
 
     const tuning = {
         alpha: CLOTH_SOLVER_TUNING.alpha,
-        beta: control.beta,
+        beta: CLOTH_SOLVER_TUNING.beta,
         gamma: CLOTH_SOLVER_TUNING.gamma,
         k_min_ratio: CLOTH_SOLVER_TUNING.k_max_ratio,
-        k_max_ratio: CLOTH_SOLVER_TUNING.k_max_ratio
+        k_max_ratio: CLOTH_SOLVER_TUNING.k_max_ratio,
+        contact_ramp_ratio: control.ramp
     };
 
     const started = performance.now();
@@ -548,27 +549,27 @@ floor_input.addEventListener('input', () => {
         : `1/${(1 / control.k_floor).toFixed(1)}`;
 });
 
-const beta_input = element('beta');
-const beta_output = element('beta_out');
+const ramp_input = element('ramp');
+const ramp_output = element('ramp_out');
 
-beta_input.value = String(Math.log10(control.beta));
-beta_output.textContent = control.beta.toExponential(0);
+ramp_input.value = String(Math.log10(control.ramp));
+ramp_output.textContent = control.ramp.toPrecision(2);
 
-beta_input.addEventListener('input', () => {
-    control.beta = Math.pow(10, Number(beta_input.value));
+ramp_input.addEventListener('input', () => {
+    control.ramp = Math.pow(10, Number(ramp_input.value));
 
-    beta_output.textContent = control.beta.toExponential(0);
+    ramp_output.textContent = control.ramp.toPrecision(2);
 });
 
 element('defaults').addEventListener('click', () => {
     control.k_floor = 1 / 32;
-    control.beta = CLOTH_SOLVER_TUNING.beta;
+    control.ramp = CLOTH_SOLVER_TUNING.contact_ramp_ratio;
 
     floor_input.value = String(Math.log2(control.k_floor));
     floor_output.textContent = '1/32';
 
-    beta_input.value = String(Math.log10(control.beta));
-    beta_output.textContent = control.beta.toExponential(0);
+    ramp_input.value = String(Math.log10(control.ramp));
+    ramp_output.textContent = control.ramp.toPrecision(2);
 });
 
 const sweep_button = element('sweep');

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

@@ -492,9 +492,37 @@ export class ClothState {
      * fabric's own 6 mm the row removes **21%** of the sheet's
      * self-intersections, and at half the shortest row **82%**.
      * `MEASUREMENTS.md` §31.
-     * @type {number}
+     *
+     * **And it is the particle's own.** A circle skirt's rows run from a
+     * centimetre at the waistband to five at the hem, and one radius per cloth
+     * gave the hem the waistband's — a row a fifth of its spacing wide, and
+     * flutes through each other at every sample. So the two lengths it is built
+     * from, {@link self_row} and {@link self_free_pair}, are measured per
+     * particle at seed, and `cloth_self_radius_update` fills this per step from
+     * the fabric's thickness. A pair's reach is the sum of its two radii.
+     * `MEASUREMENTS.md` §67, §68.
+     * @type {Float32Array}
+     */
+    self_radius: Float32Array;
+    /**
+     * The shortest stretch row incident on each particle, metres — the floor the
+     * self-collision radius is half of. `Infinity` for a particle no row touches.
+     * Written once, when the rows are.
+     * @type {Float32Array}
+     */
+    self_row: Float32Array;
+    /**
+     * How close each particle gets in the **bind pose** to a particle no row
+     * joins it to, metres — the length the radius's cap is two fifths of — or
+     * `Infinity` when nothing is within the search. Written once at seed by
+     * `cloth_self_closest_free_pair`, and measured rather than derived because
+     * a garment is not a sheet: on a rigged garment's strips the gap between
+     * strips is half what the link length would predict (`MEASUREMENTS.md` §37),
+     * and on a skirt it is the waistband's two hops at the waistband and the
+     * hem's at the hem.
+     * @type {Float32Array}
      */
-    self_radius: number;
+    self_free_pair: Float32Array;
     /**
      * Self-collision pairs, 2 per pair, rebuilt every step (§9).
      *

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

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

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

@@ -599,9 +599,39 @@ export class ClothState {
      * fabric's own 6 mm the row removes **21%** of the sheet's
      * self-intersections, and at half the shortest row **82%**.
      * `MEASUREMENTS.md` §31.
-     * @type {number}
+     *
+     * **And it is the particle's own.** A circle skirt's rows run from a
+     * centimetre at the waistband to five at the hem, and one radius per cloth
+     * gave the hem the waistband's — a row a fifth of its spacing wide, and
+     * flutes through each other at every sample. So the two lengths it is built
+     * from, {@link self_row} and {@link self_free_pair}, are measured per
+     * particle at seed, and `cloth_self_radius_update` fills this per step from
+     * the fabric's thickness. A pair's reach is the sum of its two radii.
+     * `MEASUREMENTS.md` §67, §68.
+     * @type {Float32Array}
      */
-    self_radius = 0;
+    self_radius = null;
+
+    /**
+     * The shortest stretch row incident on each particle, metres — the floor the
+     * self-collision radius is half of. `Infinity` for a particle no row touches.
+     * Written once, when the rows are.
+     * @type {Float32Array}
+     */
+    self_row = null;
+
+    /**
+     * How close each particle gets in the **bind pose** to a particle no row
+     * joins it to, metres — the length the radius's cap is two fifths of — or
+     * `Infinity` when nothing is within the search. Written once at seed by
+     * `cloth_self_closest_free_pair`, and measured rather than derived because
+     * a garment is not a sheet: on a rigged garment's strips the gap between
+     * strips is half what the link length would predict (`MEASUREMENTS.md` §37),
+     * and on a skirt it is the waistband's two hops at the waistband and the
+     * hem's at the hem.
+     * @type {Float32Array}
+     */
+    self_free_pair = null;
 
     /**
      * Self-collision pairs, 2 per pair, rebuilt every step (§9).
@@ -818,9 +848,31 @@ export class ClothState {
         state.inertial.set(state.position);
         state.kinematic_target.set(state.position);
 
+        // The two lengths a particle's self-collision radius is built from: its
+        // shortest row, from the rows below, and its closest free pair, which
+        // only a walk over the bind pose can measure (`cloth_self_closest_free_pair`)
+        // and which stays "nothing in reach" until one does.
+        state.self_row.fill(Infinity);
+        state.self_free_pair.fill(Infinity);
+
         for (let row = 0; row < stretch_count; row++) {
-            state.stretch_particle[row * 2] = particle_of_source[stretch_particle[row * 2]];
-            state.stretch_particle[row * 2 + 1] = particle_of_source[stretch_particle[row * 2 + 1]];
+            const a = particle_of_source[stretch_particle[row * 2]];
+            const b = particle_of_source[stretch_particle[row * 2 + 1]];
+
+            state.stretch_particle[row * 2] = a;
+            state.stretch_particle[row * 2 + 1] = b;
+
+            const rest = stretch_rest[row];
+
+            if (rest > 0) {
+                if (rest < state.self_row[a]) {
+                    state.self_row[a] = rest;
+                }
+
+                if (rest < state.self_row[b]) {
+                    state.self_row[b] = rest;
+                }
+            }
 
             const stiffness = stretch_stiffness[row];
 
@@ -1105,6 +1157,9 @@ function allocate(
         contact_count,          // contact_friction_lambda
         contact_count,          // contact_friction_penalty
         contact_count * 3,      // contact_anchor
+        particle_count,         // self_row
+        particle_count,         // self_free_pair
+        particle_count,         // self_radius
         self_capacity * 2,      // self_pair
         particle_count * 3,     // self_force
         particle_count * 6,     // self_hessian
@@ -1203,6 +1258,9 @@ function allocate(
     state.contact_friction_penalty = cut(Float32Array, contact_count);
     state.contact_anchor = cut(Float32Array, contact_count * 3);
 
+    state.self_row = cut(Float32Array, particle_count);
+    state.self_free_pair = cut(Float32Array, particle_count);
+    state.self_radius = cut(Float32Array, particle_count);
     state.self_pair = cut(Int32Array, self_capacity * 2);
     state.self_force = cut(Float32Array, particle_count * 3);
     state.self_hessian = cut(Float32Array, particle_count * 6);

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

@@ -35,12 +35,20 @@ export function cloth_self_exclusions(state: ClothState): {
  * is §36's permanently active pair. {@link cloth_self_find} pairs a held
  * particle with a free one for the same reason.
  *
+ * **And every particle gets its own.** The walk writes each particle's closest
+ * free pair into {@link ClothState#self_free_pair} — the cap on *that*
+ * particle's radius — and returns the closest over the cloth, which on a sheet
+ * is every particle's and on a skirt is the waistband's. One cap per cloth gave
+ * a skirt's hem the waistband's, which is `MEASUREMENTS.md` §67.
+ *
  * @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`
+ *   bounded by it, and a particle with nothing that close gets `Infinity` — which
+ *   is the right answer, because then no radius inside the bound can touch
+ *   anything. Twice the longest of the particles' shortest rows reaches every
+ *   particle's own two hops.
+ * @returns {number} metres, the closest over the cloth, or `Infinity`
  */
 export function cloth_self_closest_free_pair(state: ClothState, exclusions: {
     offset: Int32Array;

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

@@ -1 +1 @@
-{"version":3,"file":"cloth_self_find.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/solver/cloth_self_find.js"],"names":[],"mappings":"AA6DA;;;;;GAKG;AACH,0DAFa;IAAC,MAAM,EAAE,UAAU,CAAC;IAAC,OAAO,EAAE,UAAU,CAAA;CAAC,CAQrD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,4EANW;IAAC,MAAM,EAAE,UAAU,CAAC;IAAC,OAAO,EAAE,UAAU,CAAA;CAAC,UACzC,MAAM,GAGJ,MAAM,CAgHlB;AAED;;;;;;GAMG;AACH,+DAHW;IAAC,MAAM,EAAE,UAAU,CAAC;IAAC,OAAO,EAAE,UAAU,CAAA;CAAC,GACvC,MAAM,CAyJlB;AAxXD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AAEH;;;;;;;;;;;;;;;;;GAiBG;AACH,4CAFU,MAAM,CAE+B"}
+{"version":3,"file":"cloth_self_find.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/solver/cloth_self_find.js"],"names":[],"mappings":"AA6DA;;;;;GAKG;AACH,0DAFa;IAAC,MAAM,EAAE,UAAU,CAAC;IAAC,OAAO,EAAE,UAAU,CAAA;CAAC,CAQrD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,4EARW;IAAC,MAAM,EAAE,UAAU,CAAC;IAAC,OAAO,EAAE,UAAU,CAAA;CAAC,UACzC,MAAM,GAKJ,MAAM,CAmIlB;AAED;;;;;;GAMG;AACH,+DAHW;IAAC,MAAM,EAAE,UAAU,CAAC;IAAC,OAAO,EAAE,UAAU,CAAA;CAAC,GACvC,MAAM,CAuKlB;AAjaD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AAEH;;;;;;;;;;;;;;;;;GAiBG;AACH,4CAFU,MAAM,CAE+B"}

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

@@ -100,16 +100,28 @@ export function cloth_self_exclusions(state) {
  * is §36's permanently active pair. {@link cloth_self_find} pairs a held
  * particle with a free one for the same reason.
  *
+ * **And every particle gets its own.** The walk writes each particle's closest
+ * free pair into {@link ClothState#self_free_pair} — the cap on *that*
+ * particle's radius — and returns the closest over the cloth, which on a sheet
+ * is every particle's and on a skirt is the waistband's. One cap per cloth gave
+ * a skirt's hem the waistband's, which is `MEASUREMENTS.md` §67.
+ *
  * @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`
+ *   bounded by it, and a particle with nothing that close gets `Infinity` — which
+ *   is the right answer, because then no radius inside the bound can touch
+ *   anything. Twice the longest of the particles' shortest rows reaches every
+ *   particle's own two hops.
+ * @returns {number} metres, the closest over the cloth, or `Infinity`
  */
 export function cloth_self_closest_free_pair(state, exclusions, search) {
     const particle_count = state.particle_count;
 
+    const free_pair = state.self_free_pair;
+
+    free_pair.fill(Infinity);
+
     if (!(search > 0) || particle_count < 2) {
         return Infinity;
     }
@@ -131,7 +143,9 @@ export function cloth_self_closest_free_pair(state, exclusions, search) {
     // 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;
+    const search_squared = search * search;
+
+    let closest_squared = search_squared;
 
     for (let i = 0; i < particle_count; i++) {
         const a = i * 3;
@@ -187,7 +201,7 @@ export function cloth_self_closest_free_pair(state, exclusions, search) {
 
                         const distance_squared = ddx * ddx + ddy * ddy + ddz * ddz;
 
-                        if (distance_squared >= closest_squared) {
+                        if (distance_squared >= search_squared) {
                             continue;
                         }
 
@@ -209,14 +223,27 @@ export function cloth_self_closest_free_pair(state, exclusions, search) {
                             continue;
                         }
 
-                        closest_squared = distance_squared;
+                        const distance = Math.sqrt(distance_squared);
+
+                        // Both ends of the pair: the walk visits each pair once, from its lower index.
+                        if (distance < free_pair[i]) {
+                            free_pair[i] = distance;
+                        }
+
+                        if (distance < free_pair[j]) {
+                            free_pair[j] = distance;
+                        }
+
+                        if (distance_squared < closest_squared) {
+                            closest_squared = distance_squared;
+                        }
                     }
                 }
             }
         }
     }
 
-    return closest_squared === search * search ? Infinity : Math.sqrt(closest_squared);
+    return closest_squared === search_squared ? Infinity : Math.sqrt(closest_squared);
 }
 
 /**
@@ -229,7 +256,19 @@ export function cloth_self_closest_free_pair(state, exclusions, search) {
 export function cloth_self_find(state, exclusions) {
     const particle_count = state.particle_count;
 
-    const radius = state.self_radius * 2;
+    const self_radius = state.self_radius;
+
+    // The cell is the widest pair's reach, which is what makes the 27-cell walk
+    // sufficient for every pair; a pair's own reach is the sum of its two radii.
+    let largest = 0;
+
+    for (let i = 0; i < particle_count; i++) {
+        if (self_radius[i] > largest) {
+            largest = self_radius[i];
+        }
+    }
+
+    const radius = largest * 2;
 
     if (radius <= 0) {
         state.self_count = 0;
@@ -256,8 +295,6 @@ export function cloth_self_find(state, exclusions) {
 
     const inverse = 1 / radius;
 
-    const radius_squared = radius * radius;
-
     for (let i = 0; i < particle_count; i++) {
         // A held particle is paired with free ones and not with another held
         // one: it cannot be pushed, but it can be carried through the fabric —
@@ -275,6 +312,8 @@ export function cloth_self_find(state, exclusions) {
         const cy = Math.floor(y * inverse);
         const cz = Math.floor(z * inverse);
 
+        const radius_i = self_radius[i];
+
         const exclude_start = offset[i];
         const exclude_end = offset[i + 1];
 
@@ -326,7 +365,9 @@ export function cloth_self_find(state, exclusions) {
                         const ddy = y - position[b + 1];
                         const ddz = z - position[b + 2];
 
-                        if (ddx * ddx + ddy * ddy + ddz * ddz >= radius_squared) {
+                        const reach = radius_i + self_radius[j];
+
+                        if (ddx * ddx + ddy * ddy + ddz * ddz >= reach * reach) {
                             continue;
                         }
 

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

@@ -0,0 +1,42 @@
+/**
+ * # The self-collision radius, per particle
+ *
+ * §9's radius is built from two lengths of the proxy: half the shortest row,
+ * so the row's diameter is one particle spacing (`MEASUREMENTS.md` §31), capped
+ * at two fifths of the closest pair no row governs, so a cloth that is not
+ * folded is never in contact with itself (§36, §37). Both used to be measured
+ * over the whole cloth and the radius was one number for it.
+ *
+ * **Both lengths are the particle's own.** A circle skirt's rows run from a
+ * centimetre at the waistband to five at the hem, and one radius per cloth gave
+ * the hem the waistband's: six millimetres against fifty-four of spacing, a row
+ * a fifth of the spacing wide where §9 wants one spacing, and the hem's flutes
+ * passed through each other at every sample. With {@link ClothState#self_row}
+ * and {@link ClothState#self_free_pair} measured per particle at seed, this
+ * fills {@link ClothState#self_radius} per step from the fabric's thickness,
+ * and a pair's reach is the sum of its two radii. On a uniform sheet every
+ * particle gets the number the cloth used to get. `MEASUREMENTS.md` §67, §68.
+ *
+ * Per step rather than at seed because the thickness is `ClothDynamics`', which
+ * an author may change while the cloth runs; it is one multiply and two
+ * comparisons a particle, in the step itself so that the worker and the main
+ * thread derive the same bytes from the same words.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+/**
+ * Fill every particle's self-collision radius from its own two lengths and the
+ * fabric's thickness:
+ *
+ *     r_i = min( max(thickness, ½·self_row_i), 0.4·self_free_pair_i )
+ *
+ * A particle with no row has no floor above the thickness, and one with
+ * nothing in reach has no cap.
+ *
+ * @param {ClothState} state
+ * @param {number} thickness `ClothDynamics#thickness`, metres
+ * @returns {void}
+ */
+export function cloth_self_radius_update(state: ClothState, thickness: number): void;
+//# sourceMappingURL=cloth_self_radius.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"cloth_self_radius.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/solver/cloth_self_radius.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH;;;;;;;;;;;;GAYG;AACH,uEAHW,MAAM,GACJ,IAAI,CAsBhB"}

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

@@ -0,0 +1,64 @@
+import { CLOTH_SELF_RADIUS_MAX_RATIO, CLOTH_SELF_RADIUS_MIN_RATIO } from "./cloth_solver_constants.js";
+
+/**
+ * # The self-collision radius, per particle
+ *
+ * §9's radius is built from two lengths of the proxy: half the shortest row,
+ * so the row's diameter is one particle spacing (`MEASUREMENTS.md` §31), capped
+ * at two fifths of the closest pair no row governs, so a cloth that is not
+ * folded is never in contact with itself (§36, §37). Both used to be measured
+ * over the whole cloth and the radius was one number for it.
+ *
+ * **Both lengths are the particle's own.** A circle skirt's rows run from a
+ * centimetre at the waistband to five at the hem, and one radius per cloth gave
+ * the hem the waistband's: six millimetres against fifty-four of spacing, a row
+ * a fifth of the spacing wide where §9 wants one spacing, and the hem's flutes
+ * passed through each other at every sample. With {@link ClothState#self_row}
+ * and {@link ClothState#self_free_pair} measured per particle at seed, this
+ * fills {@link ClothState#self_radius} per step from the fabric's thickness,
+ * and a pair's reach is the sum of its two radii. On a uniform sheet every
+ * particle gets the number the cloth used to get. `MEASUREMENTS.md` §67, §68.
+ *
+ * Per step rather than at seed because the thickness is `ClothDynamics`', which
+ * an author may change while the cloth runs; it is one multiply and two
+ * comparisons a particle, in the step itself so that the worker and the main
+ * thread derive the same bytes from the same words.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+
+/**
+ * Fill every particle's self-collision radius from its own two lengths and the
+ * fabric's thickness:
+ *
+ *     r_i = min( max(thickness, ½·self_row_i), 0.4·self_free_pair_i )
+ *
+ * A particle with no row has no floor above the thickness, and one with
+ * nothing in reach has no cap.
+ *
+ * @param {ClothState} state
+ * @param {number} thickness `ClothDynamics#thickness`, metres
+ * @returns {void}
+ */
+export function cloth_self_radius_update(state, thickness) {
+    const particle_count = state.particle_count;
+
+    const row = state.self_row;
+    const free_pair = state.self_free_pair;
+    const radius = state.self_radius;
+
+    for (let i = 0; i < particle_count; i++) {
+        const floor = row[i] * CLOTH_SELF_RADIUS_MIN_RATIO;
+
+        let r = floor > thickness && floor < Infinity ? floor : thickness;
+
+        const cap = free_pair[i] * CLOTH_SELF_RADIUS_MAX_RATIO;
+
+        if (cap < r) {
+            r = cap;
+        }
+
+        radius[i] = r;
+    }
+}