@woosh/meep-engine 3.45.0 → 3.47.0

package/src/shade/renderer/water/surface/particles/GPUWaterParticles.js

@@ -14,15 +14,15 @@ import {
     shader_water_particles_bin,
     shader_water_particles_bounds,
     shader_water_particles_clear,
+    shader_water_particles_cut,
     shader_water_particles_emit,
     shader_water_particles_finalize,
-    shader_water_particles_fronts,
-    shader_water_particles_groups,
+    shader_water_particles_keep,
+    shader_water_particles_links,
+    shader_water_particles_mark,
     shader_water_particles_nest,
     shader_water_particles_rank,
-    shader_water_particles_runs,
     shader_water_particles_scatter,
-    shader_water_particles_share,
     shader_water_particles_split,
     shader_water_particles_total,
     shader_water_particles_update,
@@ -58,17 +58,15 @@ export class GPUWaterParticles {
     #children = null;
     #child_sums = null;
     #images = null;
-    #fronts = null;
-    #front_sums = null;
-    #runs = null;
-    #draw = null;
+    #links = null;
+    #reaches = null;
+    #shown = null;
     #buckets = null;
     #offsets = null;
     #slots = null;
     #bucket_amplitude = null;
-    #bucket_weight = null;
+    #bucket_crowd = null;
     #bucket_nest = null;
-    #visible = null;
     #staging = null;
     #entries = null;
     #body_bounds = null;
@@ -114,22 +112,21 @@ export class GPUWaterParticles {
             this.#child_sums = buffer('child sums', sums(capacity));
             // per particle the mirror image the step left beside it at the outline
             this.#images = buffer('images', capacity * WATER_PARTICLE_STRUCT.size);
-            // per particle whether it starts a run, then the scanned run it is in; per run its first particle and its
-            // share; per particle its run and how it is drawn
-            this.#fronts = buffer('fronts', 16 + capacity * 4);
-            this.#front_sums = buffer('front sums', sums(capacity));
-            this.#runs = buffer('runs', capacity * 8);
-            this.#draw = buffer('draw', capacity * 8);
+            // per particle its front's neighbours before and after it
+            this.#links = buffer('links', capacity * 8);
+            // per particle the cells its support overlaps this frame: its first, its level and spans
+            this.#reaches = buffer('reaches', capacity * 12);
+            // per particle whether its crowds draw it
+            this.#shown = buffer('shown', capacity * 4);
             // per bucket its entries, then the hash: table size and inclusive offsets
             this.#buckets = buffer('buckets', 16 + this.#table_limit * 4);
             this.#offsets = buffer('offsets', sums(this.#table_limit));
             this.#slots = buffer('slots', capacity * WATER_PARTICLE_CORNERS * 4);
             this.#bucket_amplitude = buffer('bucket amplitude', this.#table_limit * 4);
-            // the summed steepness, the largest front and front complement entered, and the entries; then the most a point
-            // under it reads, and its entries by key
-            this.#bucket_weight = buffer('bucket weight', this.#table_limit * WATER_PARTICLE_CROWD_WORDS * 4);
+            // its runs by steepness class and in all; then the most a point under it reads at finer levels, the classes its
+            // points keep and draw, and a slot of the frame's table of cut fronts
+            this.#bucket_crowd = buffer('bucket crowd', this.#table_limit * WATER_PARTICLE_CROWD_WORDS * 4);
             this.#bucket_nest = buffer('bucket nest', this.#table_limit * WATER_PARTICLE_NEST_WORDS * 4);
-            this.#visible = buffer('visible', capacity * 4);
             const entries = capacity * WATER_PARTICLE_CORNERS * WATER_PARTICLE_ENTRY_STRUCT.size;
             this.#staging = buffer('staging', entries);
             this.#entries = buffer('entries', entries);
@@ -157,16 +154,15 @@ export class GPUWaterParticles {
     }
 
     dispose() {
-        for (const buffer of [...this.#particles, this.#children, this.#child_sums, this.#images, this.#fronts, this.#front_sums, this.#runs,
-            this.#draw, this.#buckets, this.#offsets, this.#slots, this.#bucket_amplitude, this.#bucket_weight, this.#bucket_nest, this.#visible,
-            this.#staging, this.#entries, this.#body_bounds, ...(this.#commands ?? [])]) {
+        for (const buffer of [...this.#particles, this.#children, this.#child_sums, this.#images, this.#links, this.#reaches, this.#shown, this.#buckets,
+            this.#offsets, this.#slots, this.#bucket_amplitude, this.#bucket_crowd, this.#bucket_nest, this.#staging, this.#entries, this.#body_bounds,
+            ...(this.#commands ?? [])]) {
             buffer?.destroy();
         }
         this.#particles = [];
         this.#children = this.#child_sums = this.#images = this.#buckets = this.#offsets = this.#slots = this.#bucket_amplitude = null;
         this.#staging = this.#entries = null;
-        this.#fronts = this.#front_sums = this.#runs = this.#draw = null;
-        this.#bucket_weight = this.#bucket_nest = this.#visible = null;
+        this.#links = this.#reaches = this.#shown = this.#bucket_crowd = this.#bucket_nest = null;
         this.#body_bounds = null;
         this.#commands = null;
         this.#device = null;
@@ -205,8 +201,6 @@ export class GPUWaterParticles {
         let child_sums = graph_import_buffer(graph, this.#child_sums, 'Water / particle child sums');
         let buckets = graph_import_buffer(graph, this.#buckets, 'Water / particle buckets');
         let offsets = graph_import_buffer(graph, this.#offsets, 'Water / particle offsets');
-        let fronts = graph_import_buffer(graph, this.#fronts, 'Water / particle fronts');
-        let front_sums = graph_import_buffer(graph, this.#front_sums, 'Water / particle front sums');
         const node = (name, execute, reads, writes) => {
             const data = {};
             const pass = graph.add(name, data, (d, resources, context) => execute(resources, context, d));
@@ -243,49 +237,46 @@ export class GPUWaterParticles {
             }, { child_sums }, {});
         }
 
-        // Each front's run of particles, so that a whole one is drawn as the seven it was emitted as.
-        fronts = node('Water / particles fronts', (resources, { encoder }) => {
+        // The frame's hash: each particle's neighbours round its front, so that a run of them is drawn as one; how crowded
+        // each cell is and so which runs it keeps, the steepest, dooming the rest and cutting, whole, the fronts the gather
+        // cannot read;
+        // then each drawn run entered into every cell its first particle's support overlaps, offsets, entries in order.
+        buckets = node('Water / particles bin', (resources, { encoder }) => {
             if (!stepping) {
                 // the table size the last stepping frame chose for these particles
                 shader_water_particles_finalize.dispatch({ encoder, bindings: { limits: { capacity, table_limit }, next, offsets: this.#buckets,
                     table_command: command_table } });
             }
             build_indirect_compute_dispatch_command(64, encoder, next, 0, command_next, 0, true);
-            encoder.copyBufferToBuffer(next, 0, this.#fronts, 0, 4);
-            shader_water_particles_fronts.dispatchIndirect({ encoder, command: command_next, bindings: { next, fronts: this.#fronts } });
-        }, {}, { fronts }).fronts;
-        front_sums = graph_prefix_scan_csdldf({ graph, input: fronts, output: front_sums, element_max_count: capacity });
-
-        // The frame's hash: how each particle is drawn, how crowded each cell is and so how much of each run its crowd
-        // leaves drawn, then each packet drawn into the cells its support overlaps, offsets, entries in order.
-        buckets = node('Water / particles bin', (resources, { encoder }) => {
-            const draw = this.#draw, runs = this.#runs;
-            shader_water_particles_runs.dispatchIndirect({ encoder, command: command_next, bindings: { next, fronts: this.#front_sums, runs } });
-            shader_water_particles_groups.dispatchIndirect({ encoder, command: command_next, bindings: { next, fronts: this.#front_sums, runs, draw } });
+            const links = this.#links;
+            const reaches = this.#reaches;
+            shader_water_particles_links.dispatchIndirect({ encoder, command: command_next, bindings: { next, links, reaches } });
             shader_water_particles_clear.dispatchIndirect({ encoder, command: command_table, bindings: {
-                buckets: this.#buckets, bucket_amplitude: this.#bucket_amplitude, bucket_weight: this.#bucket_weight,
-                bucket_nest: this.#bucket_nest } });
-            shader_water_particles_weigh.dispatchIndirect({ encoder, command: command_next, bindings: {
-                next, activity, offsets: this.#buckets, draw, bucket_weight: this.#bucket_weight, body_bounds: this.#body_bounds } });
-            shader_water_particles_nest.dispatchIndirect({ encoder, command: command_next, bindings: {
-                next, activity, offsets: this.#buckets, draw, body_bounds: this.#body_bounds, bucket_weight: this.#bucket_weight,
+                buckets: this.#buckets, bucket_amplitude: this.#bucket_amplitude, bucket_crowd: this.#bucket_crowd,
                 bucket_nest: this.#bucket_nest } });
-            shader_water_particles_share.dispatchIndirect({ encoder, command: command_next, bindings: {
-                next, activity, offsets: this.#buckets, bucket_weight: this.#bucket_weight, bucket_nest: this.#bucket_nest,
-                body_bounds: this.#body_bounds, draw, runs } });
+            const crowd = { next, activity, offsets: this.#buckets, links, reaches, body_bounds: this.#body_bounds,
+                bucket_crowd: this.#bucket_crowd };
+            shader_water_particles_weigh.dispatchIndirect({ encoder, command: command_next, bindings: crowd });
+            shader_water_particles_nest.dispatchIndirect({ encoder, command: command_next, bindings: { ...crowd, bucket_nest: this.#bucket_nest } });
+            shader_water_particles_cut.dispatchIndirect({ encoder, command: command_next, bindings: { ...crowd, bucket_nest: this.#bucket_nest } });
+            const shown = this.#shown;
+            shader_water_particles_mark.dispatchIndirect({ encoder, command: command_next, bindings: {
+                next, activity, offsets: this.#buckets, reaches, bucket_nest: this.#bucket_nest } });
+            shader_water_particles_keep.dispatchIndirect({ encoder, command: command_next, bindings: {
+                next, activity, offsets: this.#buckets, reaches, bucket_nest: this.#bucket_nest, shown } });
             shader_water_particles_bin.dispatchIndirect({ encoder, command: command_next, bindings: {
                 next, activity, buckets: this.#buckets, slots: this.#slots, bucket_amplitude: this.#bucket_amplitude,
-                body_bounds: this.#body_bounds, draw, runs, visible: this.#visible } });
-        }, { front_sums }, { buckets }).buckets;
+                body_bounds: this.#body_bounds, links, reaches, shown } });
+        }, {}, { buckets }).buckets;
         offsets = graph_prefix_scan_csdldf({ graph, input: buckets, output: offsets, element_max_count: table_limit });
         node('Water / particles order and bound', (resources, { encoder }) => {
-            const bindings = { next, offsets: this.#offsets, slots: this.#slots, draw: this.#draw };
+            const bindings = { next, offsets: this.#offsets, slots: this.#slots, reaches: this.#reaches };
             shader_water_particles_scatter.dispatchIndirect({ encoder, command: command_next, bindings: { ...bindings,
-                visible: this.#visible, staging: this.#staging } });
+                links: this.#links, shown: this.#shown, staging: this.#staging } });
             shader_water_particles_rank.dispatchIndirect({ encoder, command: command_next, bindings: { ...bindings,
                 staging: this.#staging, entries: this.#entries } });
-            shader_water_particles_bounds.dispatchIndirect({ encoder, command: command_next, bindings: { next, activity,
-                offsets: this.#offsets, bucket_amplitude: this.#bucket_amplitude, draw: this.#draw, body_bounds: this.#body_bounds } });
+            shader_water_particles_bounds.dispatchIndirect({ encoder, command: command_next, bindings: { ...bindings, activity,
+                bucket_amplitude: this.#bucket_amplitude, body_bounds: this.#body_bounds } });
         }, { offsets }, {});
     }
 }

package/src/shade/renderer/water/surface/particles/WATER_PARTICLE_STRUCT.d.ts

@@ -8,9 +8,9 @@
  */
 export const WATER_PARTICLE_STRUCT: WebGPUStruct;
 /**
- * A particle as one hash cell holds it for the surface sampler: everything its kernel needs at the frame's
- * time, and the cell it was entered for, since one particle is entered in every cell its support overlaps and
- * two cells may share a bucket.
+ * A run of a front's particles as one hash cell holds it for the surface sampler: everything its kernel needs at the
+ * frame's time, from the run's first particle, and the cell it was entered for, since a front is entered in every cell
+ * its support overlaps and two cells may share a bucket.
  */
 export const WATER_PARTICLE_ENTRY_STRUCT: WebGPUStruct;
 import { WebGPUStruct } from "../../../shader/type/WebGPUStruct.js";

package/src/shade/renderer/water/surface/particles/WATER_PARTICLE_STRUCT.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"WATER_PARTICLE_STRUCT.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/water/surface/particles/WATER_PARTICLE_STRUCT.js"],"names":[],"mappings":"AAGA;;;;;;;GAOG;AACH,iDAoBoB;AAEpB;;;;GAIG;AACH,uDAkByB;6BAvDI,sCAAsC"}
+{"version":3,"file":"WATER_PARTICLE_STRUCT.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/water/surface/particles/WATER_PARTICLE_STRUCT.js"],"names":[],"mappings":"AAGA;;;;;;;GAOG;AACH,iDAyBoB;AAEpB;;;;GAIG;AACH,uDAuByB;6BAjEI,sCAAsC"}

package/src/shade/renderer/water/surface/particles/WATER_PARTICLE_STRUCT.js

@@ -29,12 +29,17 @@ export const WATER_PARTICLE_STRUCT = WebGPUStruct.from({
      * image was emitted then, and it dies once the last of it has left too. 0 from emission.
      */
     reflected: u32,
+    /**
+     * 0, or once a crowd it cannot be drawn in has doomed it, the steepness |a|/r below which it dies: it fades from
+     * then on, as a packet below the drawing threshold does.
+     */
+    fading: f32,
 }, 'WaterParticle');
 
 /**
- * A particle as one hash cell holds it for the surface sampler: everything its kernel needs at the frame's
- * time, and the cell it was entered for, since one particle is entered in every cell its support overlaps and
- * two cells may share a bucket.
+ * A run of a front's particles as one hash cell holds it for the surface sampler: everything its kernel needs at the
+ * frame's time, from the run's first particle, and the cell it was entered for, since a front is entered in every cell
+ * its support overlaps and two cells may share a bucket.
  */
 export const WATER_PARTICLE_ENTRY_STRUCT = WebGPUStruct.from({
     position: vec2f,
@@ -48,10 +53,15 @@ export const WATER_PARTICLE_ENTRY_STRUCT = WebGPUStruct.from({
     phase: f32,
     /** water_waves row and level, as water_particle_key packs them */
     key: u32,
-    /** Index of the particle, which orders a bucket. */
+    /** Index of the run's first particle, which orders a bucket. */
     source: u32,
     /** How far the particle stands from its front's centre, metres. */
     distance: f32,
     /** Half the length of its envelope across its front, metres. */
     half_length: f32,
+    /**
+     * The run of the front's particles it draws, from this one on, each β further round: their count, and which ends
+     * are open, tapering by the end particle's own window (chunk_water_particle's water_particle_run_profile).
+     */
+    run: u32,
 }, 'WaterParticleEntry');

package/src/shade/renderer/water/surface/particles/chunk_water_particle.d.ts

@@ -19,6 +19,14 @@ export const WATER_PARTICLE_LEVEL0_CELL: number;
  * gathers at that speed and the peak falls as t^(−1/3), which no κ draws: up to 16% below r = 12 mm, 27% at 3 cm.
  */
 export const WATER_PARTICLE_STRETCH: number[];
+/** Bits of a hash entry's run word that hold its count of particles; the two above them mark its open ends. */
+export const WATER_PARTICLE_RUN_MEMBERS: 1073741823;
+/** A run whose first particle has no neighbour of its front before it: it tapers there by that particle's window. */
+export const WATER_PARTICLE_RUN_OPEN_START: 1073741824;
+/** A run whose last particle has no neighbour of its front after it. */
+export const WATER_PARTICLE_RUN_OPEN_END: 2147483648;
+/** A particle drawn alone: a run of one, open at both ends, which is its own window. */
+export const WATER_PARTICLE_LONE: number;
 /**
  * The physics of one wave particle as pure functions (WATER_SURFACE_SIMULATION_PLAN_2026_10_06.md §5).
  *
@@ -34,7 +42,8 @@ export const WATER_PARTICLE_STRETCH: number[];
  * The particles of a front are β apart in angle around its centre, and a packet's crests are arcs around that
  * centre; a cosine window of half-angle β is a partition of unity over them at every radius, so the front's
  * height is the packet's amplitude whatever the spacing, splitting a front changes none of it, and one front
- * adds at most two particles at any point.
+ * adds at most two particles at any point. So a run of neighbours alike in all but angle is drawn as one: height one
+ * over its particles and its own window past either end that has no neighbour, the same surface its windows sum to.
  *
  * @type {CodeChunk}
  */

package/src/shade/renderer/water/surface/particles/chunk_water_particle.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_water_particle.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/water/surface/particles/chunk_water_particle.js"],"names":[],"mappings":"AAKA;;;GAGG;AACH,uCAAwC;AAKxC,yHAAyH;AACzH,gDAAkD;AAElD;;;;;;;;;;;;GAYG;AACH,8CAIE;AAKF;;;;;;;;;;;;;;;;;;GAkBG;AACH,mCAFU,SAAS,CAmN6G;0BA3QtG,uCAAuC"}
+{"version":3,"file":"chunk_water_particle.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/water/surface/particles/chunk_water_particle.js"],"names":[],"mappings":"AAKA;;;GAGG;AACH,uCAAwC;AAKxC,yHAAyH;AACzH,gDAAkD;AAElD;;;;;;;;;;;;GAYG;AACH,8CAIE;AAKF,+GAA+G;AAC/G,oDAAqD;AAErD,qHAAqH;AACrH,uDAAwD;AAExD,wEAAwE;AACxE,qDAAsD;AAEtD,wFAAwF;AACxF,yCAA2G;AAE3G;;;;;;;;;;;;;;;;;;;GAmBG;AACH,mCAFU,SAAS,CAgP6G;0BArTtG,uCAAuC"}

package/src/shade/renderer/water/surface/particles/chunk_water_particle.js

@@ -37,6 +37,18 @@ export const WATER_PARTICLE_STRETCH = [
 /** log₂(k/k_m) of the stretch table's first entry; entries are a quarter apart. */
 const WATER_PARTICLE_STRETCH_FIRST = -7;
 
+/** Bits of a hash entry's run word that hold its count of particles; the two above them mark its open ends. */
+export const WATER_PARTICLE_RUN_MEMBERS = 0x3fffffff;
+
+/** A run whose first particle has no neighbour of its front before it: it tapers there by that particle's window. */
+export const WATER_PARTICLE_RUN_OPEN_START = 0x40000000;
+
+/** A run whose last particle has no neighbour of its front after it. */
+export const WATER_PARTICLE_RUN_OPEN_END = 0x80000000;
+
+/** A particle drawn alone: a run of one, open at both ends, which is its own window. */
+export const WATER_PARTICLE_LONE = (1 | WATER_PARTICLE_RUN_OPEN_START | WATER_PARTICLE_RUN_OPEN_END) >>> 0;
+
 /**
  * The physics of one wave particle as pure functions (WATER_SURFACE_SIMULATION_PLAN_2026_10_06.md §5).
  *
@@ -52,7 +64,8 @@ const WATER_PARTICLE_STRETCH_FIRST = -7;
  * The particles of a front are β apart in angle around its centre, and a packet's crests are arcs around that
  * centre; a cosine window of half-angle β is a partition of unity over them at every radius, so the front's
  * height is the packet's amplitude whatever the spacing, splitting a front changes none of it, and one front
- * adds at most two particles at any point.
+ * adds at most two particles at any point. So a run of neighbours alike in all but angle is drawn as one: height one
+ * over its particles and its own window past either end that has no neighbour, the same surface its windows sum to.
  *
  * @type {CodeChunk}
  */
@@ -62,6 +75,10 @@ const WATER_PARTICLE_LEVEL_BITS: u32 = ${WATER_PARTICLE_LEVEL_BITS}u;
 const WATER_PARTICLE_LEVEL0_CELL: f32 = ${WATER_PARTICLE_LEVEL0_CELL};
 const WATER_PARTICLE_STRETCH = array<f32, ${WATER_PARTICLE_STRETCH.length}>(${WATER_PARTICLE_STRETCH.join(', ')});
 const WATER_PARTICLE_STRETCH_FIRST: f32 = ${WATER_PARTICLE_STRETCH_FIRST}.0;
+const WATER_PARTICLE_RUN_MEMBERS: u32 = ${WATER_PARTICLE_RUN_MEMBERS}u;
+const WATER_PARTICLE_RUN_OPEN_START: u32 = ${WATER_PARTICLE_RUN_OPEN_START}u;
+const WATER_PARTICLE_RUN_OPEN_END: u32 = ${WATER_PARTICLE_RUN_OPEN_END}u;
+const WATER_PARTICLE_LONE: u32 = ${WATER_PARTICLE_LONE}u;
 // kinematic viscosity of water, m²/s
 const WATER_VISCOSITY: f32 = 1e-6;
 const WATER_PI: f32 = 3.14159265358979;
@@ -153,38 +170,57 @@ fn water_particle_support_limit() -> f32 {
     return 0.5 * water_particle_cell_size(WATER_PARTICLE_LEVELS - 1u);
 }
 
-// Whether two particles are of one front: one splash's, neither reflected or faded apart, alike in all but angle.
-fn water_particle_same_front(a: ${WATER_PARTICLE_STRUCT.wgsl_ref}, b: ${WATER_PARTICLE_STRUCT.wgsl_ref}) -> bool {
+// An angle as a turn from 0 round to 2π.
+fn water_particle_turn(angle: f32) -> f32 {
+    return angle - WATER_TAU * floor(angle / WATER_TAU);
+}
+
+// Where round its centre a front's particles are not neighbours: an angle of the front's own, from its centre, so that
+// fronts' ends lie anywhere rather than all to one side of them.
+fn water_particle_break(particle: ${WATER_PARTICLE_STRUCT.wgsl_ref}) -> f32 {
+    let bits = pcg3d(vec3<u32>(bitcast<u32>(particle.origin.x), bitcast<u32>(particle.origin.y), particle.body)).x;
+    return f32(bits >> 8u) * (WATER_TAU / 16777216.0);
+}
+
+// Whether two particles are of one front as it is drawn: one splash's, neither faded apart from the other, alike in all
+// but angle. A doom does not part them until the fade it starts does: what is drawn is all that links them.
+fn water_particle_alike(a: ${WATER_PARTICLE_STRUCT.wgsl_ref}, b: ${WATER_PARTICLE_STRUCT.wgsl_ref}) -> bool {
     return a.body == b.body && all(a.origin == b.origin) && a.age == b.age && a.amplitude == b.amplitude
         && a.radius == b.radius && a.dispersion == b.dispersion;
 }
 
-// How a particle is drawn, given its front's run of particles in the array and its place in it: 1 as itself; 0 not at
-// all, or a group of 3^g as one packet with 3^g times its window, when its front is whole. Whole is every particle
-// the front split into still there, in order and alike: as many as fill its circle. The step puts a particle's three
-// in its place, the middle at its own angle, so a group of 3^g is 3^g in a row and its middle stands at the angle
-// the group was emitted at; with curved crests the groups draw what the particles do. The largest group whose packet
-// the hash holds: the seven a front was emitted as, until their windows outgrow the coarsest cell.
-fn water_particle_group(particle: ${WATER_PARTICLE_STRUCT.wgsl_ref}, members: u32, offset: u32) -> u32 {
-    if (members != u32(round(WATER_TAU / particle.dispersion))) { return 1u; }
-    var group = 1u;
-    for (var g = 0u; g < 20u && members % (3u * group) == 0u; g++) { group *= 3u; }
-    let distance = water_particle_distance(particle);
-    let half_length = water_particle_half_length_at(particle.radius, distance);
-    for (var g = 0u; g < 20u && group > 1u; g++) {
-        let dispersion = particle.dispersion * f32(group);
-        let width = max(dispersion * distance, 1e-3 * particle.radius);
-        if (water_particle_support(half_length, width, dispersion) <= water_particle_support_limit()) { break; }
-        group /= 3u;
-    }
-    return select(0u, group, offset % group == group / 2u);
+// Whether b is a's neighbour round their front, β further on. Angles are compared as turns from the front's break, so
+// its particles either side of it are never neighbours and a run of them never closes on itself; that pair's windows sum
+// to one there as any unlinked pair's do.
+fn water_particle_linked(a: ${WATER_PARTICLE_STRUCT.wgsl_ref}, b: ${WATER_PARTICLE_STRUCT.wgsl_ref}) -> bool {
+    if (!water_particle_alike(a, b)) { return false; }
+    let cut = water_particle_break(a);
+    return abs(water_particle_turn(b.angle - cut) - water_particle_turn(a.angle - cut) - a.dispersion) < 0.01 * a.dispersion;
 }
 
-// The particle as its group draws it: one packet with the group's window.
-fn water_particle_drawn(particle: ${WATER_PARTICLE_STRUCT.wgsl_ref}, group: u32) -> ${WATER_PARTICLE_STRUCT.wgsl_ref} {
-    var drawn = particle;
-    drawn.dispersion *= f32(group);
-    return drawn;
+// A particle's window over x from its axis, |x| < β, and its derivative.
+fn water_particle_taper(x: f32, dispersion: f32) -> vec2<f32> {
+    let t = WATER_PI * x / dispersion;
+    return vec2<f32>(0.5 * (1.0 + cos(t)), -0.5 * WATER_PI / dispersion * sin(t));
+}
+
+// The angular profile of a run of a front's particles at ψ round the front's centre from its first particle's axis, and
+// its derivative: one from its first particle's axis to its last's, where the windows of neighbours β apart sum to one;
+// past an open end the end particle's own window, all there is of the front there; past an end with a neighbour, nothing,
+// since that neighbour's own run draws it there.
+fn water_particle_run_profile(psi: f32, dispersion: f32, run: u32) -> vec2<f32> {
+    let span = f32(max(run & WATER_PARTICLE_RUN_MEMBERS, 1u) - 1u) * dispersion;
+    let onward = water_particle_turn(psi);
+    if (onward <= span) { return vec2<f32>(1.0, 0.0); }
+    var profile = vec2<f32>(0.0);
+    if ((run & WATER_PARTICLE_RUN_OPEN_START) != 0u && psi < 0.0 && psi > -dispersion) {
+        profile += water_particle_taper(psi, dispersion);
+    }
+    let past = onward - span;
+    if ((run & WATER_PARTICLE_RUN_OPEN_END) != 0u && past < dispersion) {
+        profile += water_particle_taper(past, dispersion);
+    }
+    return profile;
 }
 
 // The smallest hash level whose cell is at least the support's diameter, so the support overlaps at most
@@ -220,13 +256,13 @@ struct WaterParticleField {
     displacement_gradient: vec2<f32>,
 }
 
-// The packet at offset d from its particle, which stands distance from its front's centre. ρ the radius from the
-// centre and u = ρ − distance across the front, ψ the angle around the centre from the particle's direction:
-// envelope E(u) over half_length either side, window T(ψ) over the dispersion β either side, carrier phase πu/r − phase.
-// Height a·E·T·cos; horizontal displacement −a·E·T·sin along the radius (Gerstner-like orbits, Yuksel's longitudinal
-// sign); with derivatives, ∇ψ = e_ψ/ρ.
-fn water_particle_field(d: vec2<f32>, angle: f32, amplitude: f32, radius: f32, half_length: f32, dispersion: f32, distance: f32,
-    phase: f32) -> WaterParticleField {
+// The run of a front's packets from the particle at offset d (water_particle_run_profile), which stands distance from
+// its front's centre. ρ the radius from the centre and u = ρ − distance across the front, ψ the angle around the centre
+// from the particle's direction: envelope E(u) over half_length either side, the run's profile T(ψ), carrier phase
+// πu/r − phase. Height a·E·T·cos; horizontal displacement −a·E·T·sin along the radius (Gerstner-like orbits, Yuksel's
+// longitudinal sign); with derivatives, ∇ψ = e_ψ/ρ.
+fn water_particle_run_field(d: vec2<f32>, angle: f32, amplitude: f32, radius: f32, half_length: f32, dispersion: f32, distance: f32,
+    phase: f32, run: u32) -> WaterParticleField {
     var field: WaterParticleField;
     let direction = water_particle_direction(angle);
     let tangent = vec2<f32>(-direction.y, direction.x);
@@ -236,15 +272,15 @@ fn water_particle_field(d: vec2<f32>, angle: f32, amplitude: f32, radius: f32, h
     let u = (dot(d, d) + 2.0 * distance * dot(d, direction)) / max(rho + distance, 1e-30);
     if (abs(u) >= half_length || !(rho > 0.0)) { return field; }
     let psi = atan2(dot(d, tangent), distance + dot(d, direction));
-    if (abs(psi) >= dispersion) { return field; }
+    let profile = water_particle_run_profile(psi, dispersion, run);
+    if (!(profile.x > 0.0)) { return field; }
     let radial = q / rho;
     let around = vec2<f32>(-radial.y, radial.x);
     let eu = WATER_PI * u / half_length;
     let envelope = 0.5 * (1.0 + cos(eu));
     let envelope_du = -0.5 * WATER_PI / half_length * sin(eu);
-    let tv = WATER_PI * psi / dispersion;
-    let window = 0.5 * (1.0 + cos(tv));
-    let window_dpsi = -0.5 * WATER_PI / dispersion * sin(tv);
+    let window = profile.x;
+    let window_dpsi = profile.y;
     let carrier = WATER_PI * u / radius - phase;
     let c = cos(carrier);
     let s = sin(carrier);
@@ -257,12 +293,18 @@ fn water_particle_field(d: vec2<f32>, angle: f32, amplitude: f32, radius: f32, h
     let h_psi = -amplitude * envelope * window_dpsi * s;
     let gradient_h = h_u * radial + (h_psi / rho) * around;
     // the radius turns as the point moves around the centre: ∂e_ρ/∂x_j = e_ψ (e_ψ)_j / ρ
-    let turn = (h / rho) * around;
+    let swing = (h / rho) * around;
     field.height = z;
     field.slope = z_u * radial + (z_psi / rho) * around;
     field.displacement = h * radial;
-    field.jacobian = mat2x2<f32>(radial * gradient_h.x + turn * around.x, radial * gradient_h.y + turn * around.y);
+    field.jacobian = mat2x2<f32>(radial * gradient_h.x + swing * around.x, radial * gradient_h.y + swing * around.y);
     field.displacement_gradient = gradient_h;
     return field;
 }
+
+// One particle's packet: a run of one, its window over the dispersion β either side of its axis.
+fn water_particle_field(d: vec2<f32>, angle: f32, amplitude: f32, radius: f32, half_length: f32, dispersion: f32, distance: f32,
+    phase: f32) -> WaterParticleField {
+    return water_particle_run_field(d, angle, amplitude, radius, half_length, dispersion, distance, phase, WATER_PARTICLE_LONE);
+}
 `, [chunk_water_spectrum, chunk_pcg3d, WATER_PARTICLE_STRUCT.declaration_chunk, WATER_PARTICLE_ENTRY_STRUCT.declaration_chunk]);

package/src/shade/renderer/water/surface/particles/chunk_water_particle_step.d.ts

@@ -1,4 +1,7 @@
-/** Seconds over which a packet that has fallen below the drawing threshold fades to a tenth of it, where it dies. */
+/**
+ * Time constant of a dying packet's fade: one that has fallen below the drawing threshold fades to a tenth of it, where
+ * it dies, and one a crowd doomed to a tenth of its steepness then; about a third of a second either way.
+ */
 export const WATER_PARTICLE_FADE_SECONDS: 0.15;
 /**
  * One frame of one wave particle (WATER_SURFACE_SIMULATION_PLAN_2026_10_06.md §5.1): it ages, spreads over its

package/src/shade/renderer/water/surface/particles/chunk_water_particle_step.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_water_particle_step.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/water/surface/particles/chunk_water_particle_step.js"],"names":[],"mappings":"AAQA,qHAAqH;AACrH,+CAAgD;AAEhD;;;;;;;;;;;;;;GAcG;AACH,wCAFU,SAAS,CAsN8E;0BA9OvE,uCAAuC"}
+{"version":3,"file":"chunk_water_particle_step.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/water/surface/particles/chunk_water_particle_step.js"],"names":[],"mappings":"AAQA;;;GAGG;AACH,+CAAgD;AAEhD;;;;;;;;;;;;;;GAcG;AACH,wCAFU,SAAS,CAuN8E;0BAlPvE,uCAAuC"}

package/src/shade/renderer/water/surface/particles/chunk_water_particle_step.js

@@ -6,7 +6,10 @@ import { RAY_HIT_INFO } from "../../../shader/chunk/geometry/ray/RAY_HIT_INFO.js
 import { WATER_PARTICLE_STRUCT } from "./WATER_PARTICLE_STRUCT.js";
 import { chunk_water_particle } from "./chunk_water_particle.js";
 
-/** Seconds over which a packet that has fallen below the drawing threshold fades to a tenth of it, where it dies. */
+/**
+ * Time constant of a dying packet's fade: one that has fallen below the drawing threshold fades to a tenth of it, where
+ * it dies, and one a crowd doomed to a tenth of its steepness then; about a third of a second either way.
+ */
 export const WATER_PARTICLE_FADE_SECONDS = 0.15;
 
 /**
@@ -141,11 +144,12 @@ fn water_particle_advance(input: ${WATER_PARTICLE_STRUCT.wgsl_ref}, dt: f32, geo
     particle.amplitude *= sqrt(max(distance_before, 1e-30) / max(distance_after, 1e-30)
         * half_length_before / water_particle_half_length(particle)) * exp(-water_particle_damping(particle.radius) * dt);
     // below the threshold a packet fades out rather than vanishing: its amplitude decays on top of the water's own
-    // damping until it is a tenth of the threshold's height, where it dies
+    // damping until it is a tenth of the threshold's height, where it dies; and so does one a crowd doomed, until it is
+    // as steep as its doom says
     let floor = threshold * particle.radius;
-    if (!(abs(particle.amplitude) >= floor)) {
+    if (particle.fading > 0.0 || !(abs(particle.amplitude) >= floor)) {
         particle.amplitude *= exp(-dt / WATER_PARTICLE_FADE_SECONDS);
-        if (!(abs(particle.amplitude) >= 0.1 * floor)) { return WaterParticleStep(particle, particle, 0u); }
+        if (!(abs(particle.amplitude) >= max(0.1 * floor, particle.fading * particle.radius))) { return WaterParticleStep(particle, particle, 0u); }
     }
     // its support: its envelope's half-length either side of its front, its window's angle either side of its axis
     let reach = water_particle_half_length(particle);