@woosh/meep-engine 3.47.0 → 3.50.0

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

@@ -1,6 +1,12 @@
 import { EntityComponentDataset } from "../../../ecs/EntityComponentDataset.js";
+import { EntityManager } from "../../../ecs/EntityManager.js";
 import { FluidComponent } from "../../fluid/ecs/FluidComponent.js";
+import { FluidEffectorsComponent } from "../../fluid/ecs/FluidEffectorsComponent.js";
+import { FluidEffectorsSystem } from "../../fluid/ecs/FluidEffectorsSystem.js";
 import { fluid_build_world_to_grid } from "../../fluid/ecs/fluid_build_world_to_grid.js";
+import { fluid_apply_atmosphere } from "../../fluid/fluid_apply_atmosphere.js";
+import { fluid_atmosphere_to_grid } from "../../fluid/fluid_atmosphere_to_grid.js";
+import { FLUID_ATMOSPHERE_WORDS } from "../../fluid/FluidAtmosphere.js";
 import { fluid_sample_velocity_world_mps } from "../../fluid/ecs/fluid_sample_velocity_world_mps.js";
 import { CLOTH_DYNAMICS_BY_NAME } from "../ecs/cloth_dynamics_library.js";
 import { cloth_bend_ratio, cloth_drag_response } from "../ecs/cloth_dynamics_map.js";
@@ -25,7 +31,10 @@ import { build_wind_tunnel, place_wind_post } from "./wind_build.js";
  * prevailing flow, and a solid post standing in it; the deficit and the turning
  * behind the post are the incompressible projection's answer, and the banner
  * reads them through exactly the `ClothFluidWind` and `cloth_sample_air` a game
- * scene would use.
+ * scene would use. The global acts as a scene's do: `FluidEffectorsSystem` folds
+ * it into the far field once a step, the field is brought to that far field
+ * (`fluid_apply_atmosphere`), and the cloth reads the same far field outside the
+ * volume — one wind, gust included (GPU_FLUID_CASCADES_PROPOSAL_2026_10_16.md G2).
  * That is §10's whole argument — this engine already has something better than a
  * wind zone — put where it can be watched instead of read.
  *
@@ -47,10 +56,10 @@ import { build_wind_tunnel, place_wind_post } from "./wind_build.js";
  *   shedding street — it is a steady deficit, and the free corner moves twelve
  *   times as far per step with the post as without rather than fluttering.
  *
- * And **"ambient only"** is §10's fallback: a constant plus a band-limited
- * gust, uniform over the whole banner, read through the same interface. It
- * costs one sample for the whole cloth instead of one per particle, which the
- * readout shows as the sample time dropping by a factor of twenty-five.
+ * And **"far field only"** is §10's fallback: the global's wind and its gust,
+ * uniform over the whole banner, read through the same interface. It costs one
+ * sample for the whole cloth instead of one per particle, which the readout
+ * shows as the sample time dropping by a factor of twenty-five.
  *
  * @author Alex Goldring
  * @copyright Company Named Limited (c) 2026
@@ -107,13 +116,32 @@ let cloth = null;
 /** @type {ReturnType<build_wind_tunnel>} */
 let tunnel = null;
 
-/** @type {ClothFluidWind} */
-const wind = new ClothFluidWind();
-
-/** The dataset the wind source reads its fields out of — one component in it. */
+/** The dataset the wind source reads its fields out of: the volume, and the global on it. */
 const ecd = new EntityComponentDataset();
 
-ecd.setComponentTypeMap([FluidComponent]);
+ecd.setComponentTypeMap([FluidComponent, FluidEffectorsComponent]);
+
+/** What folds the global into the far field, once a step, as in a scene. */
+const effectors = new FluidEffectorsSystem();
+
+{
+    const em = new EntityManager();
+
+    em.addSystem(effectors);
+    em.attachDataset(ecd);
+
+    await new Promise((resolve, reject) => em.startup(resolve, reject));
+}
+
+/** The far field, world units, and in the volume's grid units. */
+const atmosphere_world = new Float64Array(FLUID_ATMOSPHERE_WORDS);
+const atmosphere_grid = new Float64Array(FLUID_ATMOSPHERE_WORDS);
+
+/** No effector is applied by itself: the global acts through the far field. */
+const NO_EFFECTORS = [];
+
+/** @type {ClothFluidWind} */
+const wind = new ClothFluidWind(effectors);
 
 let fluid_entity = -1;
 
@@ -181,6 +209,12 @@ function rebuild_tunnel() {
 
     ecd.addComponentToEntity(fluid_entity, tunnel.component);
 
+    const air = new FluidEffectorsComponent();
+
+    air.addEffector(tunnel.effector);
+
+    ecd.addComponentToEntity(fluid_entity, air);
+
     refresh_post();
 }
 
@@ -211,23 +245,28 @@ function step_once() {
     tunnel.effector.wind[1] = 0;
     tunnel.effector.wind[2] = Math.cos(angle) * control.speed;
 
-    wind.ambient.wind[0] = tunnel.effector.wind[0];
-    wind.ambient.wind[1] = 0;
-    wind.ambient.wind[2] = tunnel.effector.wind[2];
-
-    wind.ambient.gust = control.gust;
-    wind.ambient.period = 1.6;
+    // The gust is the global's, so the far field carries it inside the volume
+    // and outside alike.
+    tunnel.effector.gust = control.gust;
+    tunnel.effector.gust_period = 1.6;
 
-    // 1. The air. A real fluid step, with the post's wake in it.
+    // 1. The air. The far field folded, then a real fluid step brought to it,
+    //    with the post's wake in it — what `FluidSystem` does for a scene.
     const fluid_started = performance.now();
 
+    effectors.fixedUpdate(FIXED_STEP);
+    effectors.read_atmosphere(atmosphere_world, 0);
+
     fluid_build_world_to_grid(tunnel.world_to_grid, tunnel.component);
 
     tunnel.component.enabled = control.source === 'field';
 
     if (tunnel.component.enabled) {
+        fluid_atmosphere_to_grid(atmosphere_grid, 0, atmosphere_world, 0, tunnel.world_to_grid);
+        fluid_apply_atmosphere(tunnel.component.field, FIXED_STEP, atmosphere_grid, 0);
+
         tunnel.simulator.step(
-            tunnel.component.field, FIXED_STEP, [tunnel.effector], tunnel.world_to_grid
+            tunnel.component.field, FIXED_STEP, NO_EFFECTORS, tunnel.world_to_grid
         );
     }
 
@@ -235,7 +274,7 @@ function step_once() {
 
     // 2. The cloth reads it. `begin` once a step, then one sample per particle
     //    — or one for the whole banner where no field reaches, which is what
-    //    "ambient only" turns this page into.
+    //    "far field only" turns this page into.
     const sample_started = performance.now();
 
     wind.begin(time, ecd);

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;
+    }
+}