@woosh/meep-engine 3.45.0 → 3.47.0

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

@@ -10,6 +10,7 @@ import { WGSLStructField } from "../../../shader/type/WGSLStructField.js";
 import { atomic_u32, f32, u32 } from "../../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
 import { COLLECTION_U32_STRUCT_READ } from "../../../gpu_primitive/COLLECTION_U32_STRUCT_READ.js";
 import { STRUCT_DISPATCH_COMPUTE_COMMAND } from "../../../gpu_primitive/indirect/STRUCT_DISPATCH_COMPUTE_COMMAND.js";
+import { WEBGPU_GUARANTEED_MAX_COMPUTE_WORKGROUPS_PER_DIMENSION } from "../../../gpu_primitive/indirect/WEBGPU_GUARANTEED_MAX_COMPUTE_WORKGROUPS_PER_DIMENSION.js";
 import { GEOMETRY_METADATA_STRUCT } from "../../../geometry/GEOMETRY_METADATA_STRUCT.js";
 import { MESHLET_METADATA_STRUCT } from "../../../geometry/meshlet/encoding/MESHLET_METADATA_STRUCT.js";
 import { BVH2_NODE_STRUCT } from "../../../shader/chunk/bvh/BVH2_NODE_STRUCT.js";
@@ -52,52 +53,56 @@ export const WATER_PARTICLE_CORNERS = 4;
 export const WATER_PARTICLE_RANK_LIMIT = 64;
 
 /**
- * Packets a crowded point keeps. A point reads a cell of every level its body has, and a cell is crowded where its most
- * crowded point reads more than this: a point of it at its level and the coarser ones, or one under it where finer
- * levels hold packets too. Then each run of a front in it is drawn by its packets' least share of their cells: this
- * many times the packet's steepness over the summed steepness that point reads, whatever the levels it is read at. So
- * about this many stay at a point, the steepest whole wherever they sit, and a front stays whole or goes. What is
- * elsewhere on the body does not count, so a splash far off, or a front moving to a coarser level, changes nothing here.
- *
- * A front's lot is its own for life and the same in every cell it reaches, so the fronts of the lowest lots are kept in
- * every crowd they are in, whatever their size: the count at a point varies by fronts' worth around this, and a front
- * the outline broke is drawn particle by particle, ~20 entries in one cell. Where a point would read more than the
- * gather budget, its cells keep no more of it than their steepness's part, the lowest keys first
- * ({@link WATER_PARTICLE_CROWD_BINS}), so no point reads past the budget. A whole front is drawn as the seven it was
- * emitted as (water_particle_group), so three fresh splashes cross whole, whatever their steepness and levels; a fourth
- * over them thins one.
- *
- * A cell only one front reaches is not crowded, however many of its packets it holds: one front puts at most ~40 in
- * a cell, within the gather budget.
+ * How many places along the array either side a particle looks for its front's neighbours. A front keeps its
+ * particles in a row and in order — a ring is emitted whole, a split puts its three in its place, the dead leave no
+ * gap — and a mirror image sits right after the packet it left, so a neighbour is a place or two away, a few where
+ * images split beside their packets. A pair further apart, as a ring's last and first are, is drawn as two runs whose
+ * windows meet, the same surface.
  */
-export const WATER_PARTICLE_CELL_SHARE = 24;
+export const WATER_PARTICLE_LINK_REACH = 8;
 
 /**
- * Octaves a crowded cell counts its entries in, by the key its lottery keeps them by (a front's lot over its
- * steepness; the lowest kept first), below the most it can keep: bin j holds keys from 2^-(j+1) of that reach to
- * 2^-j of it, the last everything below. A cell whose point could read past the gather budget drops its octaves from
- * the top until the rest fit its part of the budget, so it may keep up to an octave's worth fewer than would fit.
+ * Most particles one entry draws. A run ends where its neighbours' supports leave its cell. A cell is under four
+ * support radii s across, so the particles reaching it stand within a square of under 6s, and an arc of a circle inside a
+ * square of side L is at most about πL long; the step keeps a front's neighbours at least a third of their envelope's
+ * half-length h apart (they split at h), so s is at most ~3.2 of their spacing, and a cell holds at most ~62 of one
+ * front. A front closer set than the step leaves is drawn with a hole past this many.
  */
-export const WATER_PARTICLE_CROWD_BINS = 4;
+export const WATER_PARTICLE_RUN_LIMIT = 96;
 
 /**
- * Words a bucket's crowd takes, as the weigh pass sums it: its summed steepness, its largest front and complement of a
- * front entered, and its entries.
+ * Steepness classes a cell counts its runs in: half octaves of |a|/r below 0.1, the steepest a splash makes, the last
+ * everything flatter. A run's class is its front's, the same in every cell it reaches. The cut pass reads a cell's
+ * classes and total as vectors, written out for ten (WaterParticleCrowd).
  */
-export const WATER_PARTICLE_CROWD_WORDS = 4;
+export const WATER_PARTICLE_CROWD_BINS = 10;
+
+/** Words a bucket's crowd takes, as the weigh pass counts it: its runs by steepness class, then all of them. */
+export const WATER_PARTICLE_CROWD_WORDS = WATER_PARTICLE_CROWD_BINS + 1;
 
 /**
- * Words the nest pass adds to a bucket's crowd, in a buffer of their own so that it reads weigh's sums as plain loads:
- * the most entries and the most summed steepness a point under it reads where finer levels hold packets, and its
- * entries by key, {@link WATER_PARTICLE_CROWD_BINS} octaves.
+ * Words the nest, cut and mark passes keep per bucket: the most runs a point under it reads at finer levels and its own
+ * and the coarser ones; how many steepness classes its points keep, the steepest first, within
+ * {@link WATER_PARTICLE_CROWD_KEEP}, and within the gather budget; and a slot of the frame's table of cut fronts.
  */
-export const WATER_PARTICLE_NEST_WORDS = 2 + WATER_PARTICLE_CROWD_BINS;
+export const WATER_PARTICLE_NEST_WORDS = 4;
 
-/** Width of the ramp a thinned packet fades over, a fraction of its share. */
-export const WATER_PARTICLE_THINNING_RAMP = 0.25;
+/** Slots of the cut fronts' table a front's tag is looked for in, from its own: at most an eighth of them hold one. */
+export const WATER_PARTICLE_FRONT_PROBES = 8;
+
+/**
+ * Runs a crowded point keeps: the steepest, class by class, as many as fit. A run a crowd cannot keep at any of its
+ * cells dooms its particles (WATER_PARTICLE_STRUCT's `fading`): they fade and die as packets below the drawing threshold
+ * do, so the weakest go first and nothing doomed comes back. The surface sampler's gather budget above this holds the
+ * doomed while they fade; a run past the budget itself, as where fresh fronts arrive faster than doomed ones fade, is
+ * cut: it is not drawn and dies at its next step, and so does all of its front, which a cut would otherwise leave in
+ * pieces no cell counted. The steepest class is always kept: a fresh splash is drawn, though points where more of those
+ * cross than the budget holds then lose some.
+ */
+export const WATER_PARTICLE_CROWD_KEEP = 48;
 
-/** Fixed-point scale of a packet's steepness in its cells' sums. */
-const WATER_PARTICLE_WEIGHT_SCALE = 1 << 20;
+/** A doomed particle's `fading` that kills it at its next step: no steepness reaches it. */
+const WATER_PARTICLE_CUT = 1e30;
 
 const STRIDE = WATER_PARTICLE_BODY_BOUNDS_STRIDE;
 const WORDS = WATER_PARTICLE_CROWD_WORDS;
@@ -303,7 +308,7 @@ fn main(@builtin(workgroup_id) group: vec3u, @builtin(local_invocation_index) la
         let ridge = select(0.0, height, base + count <= capacity);
         for (var k = 0u; k < count; k++) {
             if (base + k >= capacity) { break; }
-            next.elements[base + k] = ${WATER_PARTICLE_STRUCT.wgsl_ref}(impulse.xy * scale, f32(k) * dispersion, age, ridge, radius, dispersion, row, 0u);
+            next.elements[base + k] = ${WATER_PARTICLE_STRUCT.wgsl_ref}(impulse.xy * scale, f32(k) * dispersion, age, ridge, radius, dispersion, row, 0u, 0.0);
         }
         held += f32(count) * abs(ridge);
     }
@@ -324,10 +329,16 @@ finalize_resources.createGroup()
     .addStorageBuffer('offsets', COLLECTION_U32_STRUCT_READ, true)
     .addStorageBuffer('table_command', STRUCT_DISPATCH_COMPUTE_COMMAND, true);
 
+/**
+ * Words the frame's clear writes per bucket of the table: its count, its largest |a|, its crowd and its nest, four to a
+ * thread (the table is a power of two of at least {@link WATER_PARTICLE_TABLE_MIN} buckets, so each array is whole vec4s).
+ */
+export const WATER_PARTICLE_CLEAR_WORDS = 2 + WATER_PARTICLE_CROWD_WORDS + WATER_PARTICLE_NEST_WORDS;
+
 /**
  * The live count, clamped to capacity (emitters append past it), and the frame's hash table size: twice the
  * entries the particles can take, a power of two, at least ${WATER_PARTICLE_TABLE_MIN}; and the command that clears
- * that much of the table, a thread a bucket.
+ * that much of the table, a thread every four words, folded.
  */
 export const shader_water_particles_finalize = ComputeShader.from({ label: 'Water / particles finalize', resources: finalize_resources,
     body: CodeChunk.from(/* language=WGSL */ `
@@ -338,8 +349,9 @@ fn main() {
     let wanted = max(2u * ${WATER_PARTICLE_CORNERS}u * live, ${WATER_PARTICLE_TABLE_MIN}u);
     let table = min(1u << (32u - countLeadingZeros(wanted - 1u)), limits.table_limit);
     offsets.count = table;
-    table_command.workgroupCountX = (table + 63u) / 64u;
-    table_command.workgroupCountY = 1u;
+    let groups = (table / 4u * ${WATER_PARTICLE_CLEAR_WORDS}u + 63u) / 64u;
+    table_command.workgroupCountX = min(groups, ${WEBGPU_GUARANTEED_MAX_COMPUTE_WORKGROUPS_PER_DIMENSION}u);
+    table_command.workgroupCountY = (groups + ${WEBGPU_GUARANTEED_MAX_COMPUTE_WORKGROUPS_PER_DIMENSION - 1}u) / ${WEBGPU_GUARANTEED_MAX_COMPUTE_WORKGROUPS_PER_DIMENSION}u;
     table_command.workgroupCountZ = 1u;
 }
 `, [WATER_PARTICLE_STRUCT.declaration_chunk]) });
@@ -347,77 +359,83 @@ fn main() {
 const clear_resources = new ShaderResourceSetDescriptor();
 clear_resources.createGroup()
     .addStorageBuffer('buckets', WATER_PARTICLE_BUCKETS_STRUCT, true)
-    .addStorageBuffer('bucket_amplitude', WebGPUArray.u32, true)
-    .addStorageBuffer('bucket_weight', WebGPUArray.u32, true)
-    .addStorageBuffer('bucket_nest', WebGPUArray.u32, true);
+    .addStorageBuffer('bucket_amplitude', WebGPUArray.vec4u, true)
+    .addStorageBuffer('bucket_crowd', WebGPUArray.vec4u, true)
+    .addStorageBuffer('bucket_nest', WebGPUArray.vec4u, true);
 
 /**
- * Zero the frame's table, as far as finalize sized it: each bucket's count, largest |a| and crowd. A frame pays for the
- * table its particles take, not for the pool's capacity; the buckets past it are never read.
+ * Clear the frame's table, as far as finalize sized it: each bucket's count, largest |a| and crowd, its points let keep
+ * and draw every steepness class until the cut pass says otherwise, and its slot of the cut fronts' table. A thread
+ * every four words, the words of each array in a row, so neighbouring threads write neighbouring words; a bucket's nest
+ * is its four. A frame pays for the table its particles take, not for the pool's capacity; the buckets past it are
+ * never read.
  */
 export const shader_water_particles_clear = ComputeShader.from({ label: 'Water / particles clear', resources: clear_resources,
     body: CodeChunk.from(/* language=WGSL */ `
 @compute @workgroup_size(64)
 fn main(@builtin(workgroup_id) group: vec3u, @builtin(local_invocation_index) lane: u32) {
-    let b = folded_workgroup_index(group) * 64u + lane;
-    if (b >= buckets.count) { return; }
-    atomicStore(&buckets.elements[b], 0u);
-    bucket_amplitude[b] = 0u;
-    for (var word = 0u; word < ${WORDS}u; word++) { bucket_weight[${WORDS}u * b + word] = 0u; }
-    for (var word = 0u; word < ${NEST}u; word++) { bucket_nest[${NEST}u * b + word] = 0u; }
+    let table = buckets.count;
+    let quarter = table / 4u;
+    var at = folded_workgroup_index(group) * 64u + lane;
+    if (at < quarter) {
+        for (var word = 4u * at; word < 4u * at + 4u; word++) { atomicStore(&buckets.elements[word], 0u); }
+        return;
+    }
+    at -= quarter;
+    if (at < quarter) { bucket_amplitude[at] = vec4<u32>(0u); return; }
+    at -= quarter;
+    if (at < ${WORDS}u * quarter) { bucket_crowd[at] = vec4<u32>(0u); return; }
+    at -= ${WORDS}u * quarter;
+    if (at < table) { bucket_nest[at] = vec4<u32>(0u, ${BINS}u, ${BINS}u, 0u); }
 }
 `, [chunk_folded_workgroup_index]) });
 
 /**
- * A live particle's place in the hash this frame: its kernel at this time, its level and the cells its
- * support overlaps (one or two a side, the level's cell being at least the support's diameter).
+ * A live particle's place in the hash this frame: the level and the cells its support overlaps (one or two a side, the
+ * level's cell being at least the support's diameter), and the entry it makes.
  */
 const chunk_water_particle_cells = CodeChunk.from(/* language=WGSL */ `
-struct WaterParticleCells {
-    entry: ${WATER_PARTICLE_ENTRY_STRUCT.wgsl_ref},
+struct WaterParticleReach {
     level: u32,
     first: vec2<i32>,
     span: vec2<u32>,
 }
 
-fn water_particle_cells(particle: ${WATER_PARTICLE_STRUCT.wgsl_ref}, source: u32) -> WaterParticleCells {
-    var cells: WaterParticleCells;
+// The cells a particle's support overlaps at its level.
+fn water_particle_reach(particle: ${WATER_PARTICLE_STRUCT.wgsl_ref}) -> WaterParticleReach {
+    var reach: WaterParticleReach;
     let position = water_particle_position(particle);
-    let width = water_particle_width(particle);
     let distance = water_particle_distance(particle);
-    let half_length = water_particle_half_length_at(particle.radius, distance);
-    let support = water_particle_support(half_length, width, particle.dispersion);
-    cells.level = water_particle_level(support);
-    let size = water_particle_cell_size(cells.level);
-    cells.first = vec2<i32>(floor((position - vec2<f32>(support)) / size));
+    let support = water_particle_support(water_particle_half_length_at(particle.radius, distance), water_particle_width(particle),
+        particle.dispersion);
+    reach.level = water_particle_level(support);
+    let size = water_particle_cell_size(reach.level);
+    reach.first = vec2<i32>(floor((position - vec2<f32>(support)) / size));
     let last = vec2<i32>(floor((position + vec2<f32>(support)) / size));
-    cells.span = vec2<u32>(clamp(last - cells.first, vec2<i32>(0), vec2<i32>(1))) + vec2<u32>(1u);
-    cells.entry = ${WATER_PARTICLE_ENTRY_STRUCT.wgsl_ref}(position, cells.first, particle.angle, particle.amplitude, particle.radius,
-        particle.dispersion, water_particle_phase(particle), water_particle_key(particle.body, cells.level), source, distance, half_length);
-    return cells;
-}
-
-fn water_particle_corner_cell(cells: WaterParticleCells, corner: u32) -> vec2<i32> {
-    return cells.first + vec2<i32>(i32(corner & 1u), i32(corner >> 1u));
+    reach.span = vec2<u32>(clamp(last - reach.first, vec2<i32>(0), vec2<i32>(1))) + vec2<u32>(1u);
+    return reach;
 }
 
-fn water_particle_has_corner(cells: WaterParticleCells, corner: u32) -> bool {
-    return all(vec2<u32>(corner & 1u, corner >> 1u) < cells.span);
+// The entry a particle makes as a lone packet, for the first cell it reaches.
+fn water_particle_entry(particle: ${WATER_PARTICLE_STRUCT.wgsl_ref}, source: u32, reach: WaterParticleReach) -> ${WATER_PARTICLE_ENTRY_STRUCT.wgsl_ref} {
+    let distance = water_particle_distance(particle);
+    return ${WATER_PARTICLE_ENTRY_STRUCT.wgsl_ref}(water_particle_position(particle), reach.first, particle.angle, particle.amplitude,
+        particle.radius, particle.dispersion, water_particle_phase(particle), water_particle_key(particle.body, reach.level), source,
+        distance, water_particle_half_length_at(particle.radius, distance), WATER_PARTICLE_LONE);
 }
 
-// A packet's claim on its cells: its steepness, fixed point.
-fn water_particle_weight(particle: ${WATER_PARTICLE_STRUCT.wgsl_ref}) -> u32 {
-    return u32(min(abs(particle.amplitude) / max(particle.radius, 1e-6), 1.0) * ${WATER_PARTICLE_WEIGHT_SCALE}.0);
+fn water_particle_corner_cell(reach: WaterParticleReach, corner: u32) -> vec2<i32> {
+    return reach.first + vec2<i32>(i32(corner & 1u), i32(corner >> 1u));
 }
 
-// The front a packet belongs to: from its centre, the same for every packet of the front.
-fn water_particle_front(particle: ${WATER_PARTICLE_STRUCT.wgsl_ref}) -> u32 {
-    return pcg3d(vec3<u32>(bitcast<u32>(particle.origin.x), bitcast<u32>(particle.origin.y), particle.body)).x;
+fn water_particle_has_corner(reach: WaterParticleReach, corner: u32) -> bool {
+    return all(vec2<u32>(corner & 1u, corner >> 1u) < reach.span);
 }
 
-// A number in [0, 1) that stays with a front while it travels, the same for all its packets.
-fn water_particle_lot(particle: ${WATER_PARTICLE_STRUCT.wgsl_ref}) -> f32 {
-    return f32(water_particle_front(particle) >> 8u) * (1.0 / 16777216.0);
+// Whether a particle's support overlaps a cell of its level.
+fn water_particle_reaches(reach: WaterParticleReach, cell: vec2<i32>) -> bool {
+    let offset = cell - reach.first;
+    return all(offset >= vec2<i32>(0)) && all(vec2<u32>(offset) < reach.span);
 }
 
 // The bucket of the cell holding a cell's points at a level as coarse as its own or coarser, as the sampler finds it.
@@ -425,120 +443,111 @@ fn water_particle_bucket_over(body: u32, level: u32, cell: vec2<i32>, over: u32,
     return water_particle_bucket(body, over, cell >> vec2<u32>(over - level), table_size);
 }
 
-// The key a crowd keeps a packet by: its front's lot over its steepness. A packet is drawn while its lot is under its
-// share, which is its steepness times its cell's, so a crowd keeps the packets of its lowest keys, the steepest first.
-fn water_particle_precedence(particle: ${WATER_PARTICLE_STRUCT.wgsl_ref}) -> f32 {
-    return water_particle_lot(particle) / f32(water_particle_weight(particle));
-}
-
-// The largest key a crowded cell's lottery can keep, from the summed steepness a point of it reads at its level and
-// the coarser ones: its most crowded point reads at least that, and the ramp draws a lot up to its share above it.
-fn water_particle_crowd_reach(steepness: u32) -> f32 {
-    return ${1 + WATER_PARTICLE_THINNING_RAMP} * ${WATER_PARTICLE_CELL_SHARE}.0 / f32(steepness);
+// What makes a front's particles alike (water_particle_alike) but their angle, hashed: a tag, never 0, and where in the
+// cut fronts' table it is looked for.
+fn water_particle_front_hash(particle: ${WATER_PARTICLE_STRUCT.wgsl_ref}) -> vec2<u32> {
+    let a = pcg3d(vec3<u32>(bitcast<u32>(particle.origin.x), bitcast<u32>(particle.origin.y), particle.body));
+    let b = pcg3d(vec3<u32>(bitcast<u32>(particle.age) ^ a.x, bitcast<u32>(particle.amplitude) ^ a.y, bitcast<u32>(particle.radius) ^ a.z));
+    let c = pcg3d(vec3<u32>(bitcast<u32>(particle.dispersion) ^ b.x, b.y, b.z));
+    return vec2<u32>(c.x | 1u, c.y);
 }
 
-// The octave of a cell's reach a key falls in, from the exponent of their ratio: [2^-(j+1), 2^-j) is bin j, the last
-// takes everything below, and one past the reach is not counted (${BINS}u).
-fn water_particle_crowd_bin(precedence: f32, reach: f32) -> u32 {
-    let ratio = precedence / reach;
-    if (!(ratio < 1.0)) { return ${BINS}u; }
-    return min(126u - ((bitcast<u32>(ratio) >> 23u) & 0xffu), ${BINS - 1}u);
-}
-
-// How much of a packet its crowd leaves drawn, from its share of the most crowded of its cells: all of it from a share
-// of one, and below that, all of it while its lot is under its share, fading to none a ramp of that share above, and
-// none from a share of none. So a cell keeps about its share whatever its crowd.
-fn water_particle_visibility(share: f32, lot: f32) -> f32 {
-    if (!(share > 0.0)) { return 0.0; }
-    return clamp((share - lot) / (${WATER_PARTICLE_THINNING_RAMP} * share) + 1.0, 0.0, 1.0);
+// A run's steepness class (${BINS} half octaves of |a|/r below 0.1, the steepest first): its front's, alike at every
+// particle of the run and in every cell it reaches.
+fn water_particle_crowd_class(particle: ${WATER_PARTICLE_STRUCT.wgsl_ref}) -> u32 {
+    let steepness = abs(particle.amplitude) / max(particle.radius, 1e-30);
+    if (!(steepness > 0.0)) { return ${BINS - 1}u; }
+    return u32(clamp(floor(2.0 * log2(0.1 / steepness)), 0.0, ${BINS - 1}.0));
 }
 `, [chunk_water_particle]);
 
-const fronts_resources = new ShaderResourceSetDescriptor();
-fronts_resources.createGroup()
-    .addStorageBuffer('next', WATER_PARTICLE_ARRAY_STRUCT)
-    .addStorageBuffer('fronts', COLLECTION_U32_STRUCT_READ, true);
-
 /**
- * Where each front's run of particles begins: 1 at a particle not of the front before it, else 0. A front keeps its
- * particles in a row and in order — a ring is emitted whole, a split puts its three in its place, the dead leave no
- * gap — so the inclusive scan of these numbers each run from 1. A mirror image follows its packet in the row: it
- * breaks its front's run there, as a death does, and is a front of its own.
+ * A particle's cells as the links pass wrote them for the frame: three words, its first cell and its level with its
+ * spans. Bindings: `reaches`.
  */
-export const shader_water_particles_fronts = ComputeShader.from({ label: 'Water / particles fronts', resources: fronts_resources,
-    body: CodeChunk.from(/* language=WGSL */ `
-@compute @workgroup_size(64)
-fn main(@builtin(workgroup_id) group: vec3u, @builtin(local_invocation_index) lane: u32) {
-    let i = folded_workgroup_index(group) * 64u + lane;
-    if (i >= next.count) { return; }
-    fronts.elements[i] = select(1u, 0u, i > 0u && water_particle_same_front(next.elements[i - 1u], next.elements[i]));
+const chunk_water_particle_reach_read = CodeChunk.from(/* language=WGSL */ `
+fn water_particle_reach_at(i: u32) -> WaterParticleReach {
+    let packed = reaches[3u * i + 2u];
+    return WaterParticleReach(packed & 0xffu, vec2<i32>(bitcast<i32>(reaches[3u * i]), bitcast<i32>(reaches[3u * i + 1u])),
+        vec2<u32>(((packed >> 8u) & 1u) + 1u, ((packed >> 9u) & 1u) + 1u));
 }
-`, [chunk_water_particle, chunk_folded_workgroup_index]) });
 
-const runs_resources = new ShaderResourceSetDescriptor();
-runs_resources.createGroup()
-    .addStorageBuffer('next', WATER_PARTICLE_ARRAY_STRUCT)
-    .addStorageBuffer('fronts', COLLECTION_U32_STRUCT_READ)
-    .addStorageBuffer('runs', WebGPUArray.u32, true);
+// No cells: what a missing neighbour reaches.
+fn water_particle_reach_none() -> WaterParticleReach {
+    return WaterParticleReach(0u, vec2<i32>(0), vec2<u32>(0u));
+}
+`, [chunk_water_particle_cells]);
 
 /**
- * Two words a run: its first particle, and the share its crowd leaves it, none yet (the share pass lowers it).
+ * Whether a particle begins a run of its front in a cell its support overlaps: it has no neighbour before it round the
+ * front, or that neighbour's support does not overlap the cell. Each run is drawn in the cell by its first particle,
+ * once. Bindings: `links`, `reaches`.
  */
-export const shader_water_particles_runs = ComputeShader.from({ label: 'Water / particles runs', resources: runs_resources,
-    body: CodeChunk.from(/* language=WGSL */ `
-@compute @workgroup_size(64)
-fn main(@builtin(workgroup_id) group: vec3u, @builtin(local_invocation_index) lane: u32) {
-    let i = folded_workgroup_index(group) * 64u + lane;
-    if (i >= next.count) { return; }
-    let run = fronts.elements[i];
-    if (i == 0u || fronts.elements[i - 1u] != run) {
-        runs[2u * (run - 1u)] = i;
-        runs[2u * (run - 1u) + 1u] = bitcast<u32>(1e30);
-    }
+const chunk_water_particle_run_start = CodeChunk.from(/* language=WGSL */ `
+// The cells the support of a particle's neighbour before it overlaps; none without one.
+fn water_particle_before(i: u32) -> WaterParticleReach {
+    let before = links[2u * i];
+    if (before == ~0u) { return water_particle_reach_none(); }
+    return water_particle_reach_at(before);
 }
-`, [WATER_PARTICLE_STRUCT.declaration_chunk, chunk_folded_workgroup_index]) });
 
-const groups_resources = new ShaderResourceSetDescriptor();
-groups_resources.createGroup()
+fn water_particle_starts_run(before: WaterParticleReach, cell: vec2<i32>) -> bool {
+    return !water_particle_reaches(before, cell);
+}
+`, [chunk_water_particle_reach_read]);
+
+const links_resources = new ShaderResourceSetDescriptor();
+links_resources.createGroup()
     .addStorageBuffer('next', WATER_PARTICLE_ARRAY_STRUCT)
-    .addStorageBuffer('fronts', COLLECTION_U32_STRUCT_READ)
-    .addStorageBuffer('runs', WebGPUArray.u32)
-    .addStorageBuffer('draw', WebGPUArray.u32, true);
+    .addStorageBuffer('links', WebGPUArray.u32, true)
+    .addStorageBuffer('reaches', WebGPUArray.u32, true);
 
 /**
- * Two words a particle: its run, and how the frame draws it ({@link chunk_water_particle}'s water_particle_group): 1 as
- * itself, 0 not at all, 3^g for the middle of a whole front's group of 3^g, drawn as one packet.
+ * Two words a particle: its front's neighbours β before and after it round the front (water_particle_linked), or none,
+ * from the particles {@link WATER_PARTICLE_LINK_REACH} places either side of it. A pair is linked from both ends or
+ * neither, so each draws the other's side of their meeting or neither does, and their windows sum to one. And three
+ * more: the cells its support overlaps, which every pass after reads rather than works out again.
  */
-export const shader_water_particles_groups = ComputeShader.from({ label: 'Water / particles groups', resources: groups_resources,
+export const shader_water_particles_links = ComputeShader.from({ label: 'Water / particles links', resources: links_resources,
     body: CodeChunk.from(/* language=WGSL */ `
 @compute @workgroup_size(64)
 fn main(@builtin(workgroup_id) group: vec3u, @builtin(local_invocation_index) lane: u32) {
     let i = folded_workgroup_index(group) * 64u + lane;
     let count = next.count;
     if (i >= count) { return; }
-    let run = fronts.elements[i] - 1u;
-    let start = runs[2u * run];
-    var end = count;
-    if (run + 1u < fronts.elements[count - 1u]) { end = runs[2u * (run + 1u)]; }
-    draw[2u * i] = run;
-    draw[2u * i + 1u] = water_particle_group(next.elements[i], end - start, i - start);
+    let particle = next.elements[i];
+    var before = ~0u;
+    var after = ~0u;
+    let last = min(i + ${WATER_PARTICLE_LINK_REACH}u, count - 1u);
+    for (var j = max(i, ${WATER_PARTICLE_LINK_REACH}u) - ${WATER_PARTICLE_LINK_REACH}u; j <= last; j++) {
+        if (j == i) { continue; }
+        let other = next.elements[j];
+        if (water_particle_linked(other, particle)) { before = j; }
+        if (water_particle_linked(particle, other)) { after = j; }
+    }
+    links[2u * i] = before;
+    links[2u * i + 1u] = after;
+    let reach = water_particle_reach(particle);
+    reaches[3u * i] = bitcast<u32>(reach.first.x);
+    reaches[3u * i + 1u] = bitcast<u32>(reach.first.y);
+    reaches[3u * i + 2u] = reach.level | ((reach.span.x - 1u) << 8u) | ((reach.span.y - 1u) << 9u);
 }
-`, [chunk_water_particle, chunk_folded_workgroup_index]) });
+`, [chunk_water_particle_cells, chunk_folded_workgroup_index]) });
 
 const weigh_resources = new ShaderResourceSetDescriptor();
 weigh_resources.createGroup()
     .addStorageBuffer('next', WATER_PARTICLE_ARRAY_STRUCT)
     .addStorageBuffer('activity', WebGPUArray.u32)
     .addStorageBuffer('offsets', COLLECTION_U32_STRUCT_READ)
-    .addStorageBuffer('draw', WebGPUArray.u32)
-    .addStorageBuffer('bucket_weight', WebGPUArray.from(atomic_u32), true)
+    .addStorageBuffer('links', WebGPUArray.u32)
+    .addStorageBuffer('reaches', WebGPUArray.u32)
+    .addStorageBuffer('bucket_crowd', WebGPUArray.from(atomic_u32), true)
     .addStorageBuffer('body_bounds', WebGPUArray.from(atomic_u32), true);
 
 /**
- * Each packet drawn of a body simulated this frame adds its steepness to every cell its support overlaps: how crowded
- * a cell is, for the share pass to thin it by. Per bucket ({@link WATER_PARTICLE_CROWD_WORDS}) the sum, the largest
- * front and complement of a front entered, which are each other's complements only where one front alone was, and the
- * entries. And its level to its body's: a point reads a cell of every level its body has.
+ * Each run of a body simulated this frame counted into every cell it is drawn in, by its steepness class
+ * ({@link WATER_PARTICLE_CROWD_WORDS}): how crowded the cell is, for the cut pass to keep its steepest by. And its level
+ * to its body's: a point reads a cell of every level its body has.
  */
 export const shader_water_particles_weigh = ComputeShader.from({ label: 'Water / particles weigh', resources: weigh_resources,
     body: CodeChunk.from(/* language=WGSL */ `
@@ -546,40 +555,38 @@ export const shader_water_particles_weigh = ComputeShader.from({ label: 'Water /
 fn main(@builtin(workgroup_id) group: vec3u, @builtin(local_invocation_index) lane: u32) {
     let i = folded_workgroup_index(group) * 64u + lane;
     if (i >= next.count) { return; }
-    let drawn = draw[2u * i + 1u];
-    if (drawn == 0u) { return; }
-    let particle = water_particle_drawn(next.elements[i], drawn);
+    let particle = next.elements[i];
     if ((activity[particle.body] & ${WaterActivity.Active}u) == 0u) { return; }
-    let cells = water_particle_cells(particle, i);
-    let weight = water_particle_weight(particle);
-    let front = water_particle_front(particle);
+    let cells = water_particle_reach_at(i);
+    let grade = water_particle_crowd_class(particle);
+    let before = water_particle_before(i);
     atomicOr(&body_bounds[particle.body * ${STRIDE}u], 1u << cells.level);
     for (var corner = 0u; corner < ${WATER_PARTICLE_CORNERS}u; corner++) {
         if (!water_particle_has_corner(cells, corner)) { continue; }
-        let at = ${WATER_PARTICLE_CROWD_WORDS}u * water_particle_bucket(particle.body, cells.level, water_particle_corner_cell(cells, corner), offsets.count);
-        atomicAdd(&bucket_weight[at], weight);
-        atomicMax(&bucket_weight[at + 1u], front);
-        atomicMax(&bucket_weight[at + 2u], ~front);
-        atomicAdd(&bucket_weight[at + 3u], 1u);
+        let cell = water_particle_corner_cell(cells, corner);
+        if (!water_particle_starts_run(before, cell)) { continue; }
+        let at = ${WORDS}u * water_particle_bucket(particle.body, cells.level, cell, offsets.count);
+        atomicAdd(&bucket_crowd[at + grade], 1u);
+        atomicAdd(&bucket_crowd[at + ${BINS}u], 1u);
     }
 }
-`, [chunk_water_particle_cells, chunk_folded_workgroup_index]) });
+`, [chunk_water_particle_run_start, chunk_folded_workgroup_index]) });
 
 const nest_resources = new ShaderResourceSetDescriptor();
 nest_resources.createGroup()
     .addStorageBuffer('next', WATER_PARTICLE_ARRAY_STRUCT)
     .addStorageBuffer('activity', WebGPUArray.u32)
     .addStorageBuffer('offsets', COLLECTION_U32_STRUCT_READ)
-    .addStorageBuffer('draw', WebGPUArray.u32)
+    .addStorageBuffer('links', WebGPUArray.u32)
+    .addStorageBuffer('reaches', WebGPUArray.u32)
     .addStorageBuffer('body_bounds', WebGPUArray.u32)
-    .addStorageBuffer('bucket_weight', WebGPUArray.u32)
+    .addStorageBuffer('bucket_crowd', WebGPUArray.u32)
     .addStorageBuffer('bucket_nest', WebGPUArray.from(atomic_u32), true);
 
 /**
- * Each packet drawn of a body simulated this frame, its cells weighed: what a point of each of its cells reads at its
- * level and the coarser ones, entries and summed steepness, raised onto the cell over it at every coarser level its
- * body has, so a cell knows its most crowded point where finer levels hold packets under it; and its entry counted
- * among its cell's by its key (water_particle_crowd_bin), for the share pass to cap a crowd by.
+ * Each run of a body simulated this frame, its cells weighed: the runs a point of the cell it is drawn in reads at that
+ * level and the coarser ones, raised onto the cell over it at every coarser level its body has, so a cell knows the most
+ * its points read where finer levels hold runs under it.
  */
 export const shader_water_particles_nest = ComputeShader.from({ label: 'Water / particles nest', resources: nest_resources,
     body: CodeChunk.from(/* language=WGSL */ `
@@ -587,115 +594,238 @@ export const shader_water_particles_nest = ComputeShader.from({ label: 'Water /
 fn main(@builtin(workgroup_id) group: vec3u, @builtin(local_invocation_index) lane: u32) {
     let i = folded_workgroup_index(group) * 64u + lane;
     if (i >= next.count) { return; }
-    let drawn = draw[2u * i + 1u];
-    if (drawn == 0u) { return; }
-    let particle = water_particle_drawn(next.elements[i], drawn);
+    let particle = next.elements[i];
     if ((activity[particle.body] & ${WaterActivity.Active}u) == 0u) { return; }
-    let cells = water_particle_cells(particle, i);
-    let precedence = water_particle_precedence(particle);
+    let cells = water_particle_reach_at(i);
     // its body's levels coarser than its own
     let coarser = body_bounds[particle.body * ${STRIDE}u] & ~((2u << cells.level) - 1u);
+    let before = water_particle_before(i);
     for (var corner = 0u; corner < ${WATER_PARTICLE_CORNERS}u; corner++) {
         if (!water_particle_has_corner(cells, corner)) { continue; }
         let cell = water_particle_corner_cell(cells, corner);
-        let bucket = water_particle_bucket(particle.body, cells.level, cell, offsets.count);
+        if (!water_particle_starts_run(before, cell)) { continue; }
         // what a point of the cell reads at its level and the coarser ones
-        var entries = bucket_weight[${WORDS}u * bucket + 3u];
-        var steepness = bucket_weight[${WORDS}u * bucket];
+        var runs = bucket_crowd[${WORDS}u * water_particle_bucket(particle.body, cells.level, cell, offsets.count) + ${BINS}u];
         var above = coarser;
         for (var n = 0u; n < WATER_PARTICLE_LEVELS && above != 0u; n++) {
-            let over = ${WORDS}u * water_particle_bucket_over(particle.body, cells.level, cell, firstTrailingBit(above), offsets.count);
+            let over = water_particle_bucket_over(particle.body, cells.level, cell, firstTrailingBit(above), offsets.count);
             above &= above - 1u;
-            entries += bucket_weight[over + 3u];
-            steepness += bucket_weight[over];
+            runs += bucket_crowd[${WORDS}u * over + ${BINS}u];
         }
         // onto every cell over it
         above = coarser;
         for (var n = 0u; n < WATER_PARTICLE_LEVELS && above != 0u; n++) {
-            let over = ${NEST}u * water_particle_bucket_over(particle.body, cells.level, cell, firstTrailingBit(above), offsets.count);
+            let over = water_particle_bucket_over(particle.body, cells.level, cell, firstTrailingBit(above), offsets.count);
             above &= above - 1u;
-            atomicMax(&bucket_nest[over], entries);
-            atomicMax(&bucket_nest[over + 1u], steepness);
+            atomicMax(&bucket_nest[${NEST}u * over], runs);
         }
-        let octave = water_particle_crowd_bin(precedence, water_particle_crowd_reach(steepness));
-        if (octave < ${BINS}u) { atomicAdd(&bucket_nest[${NEST}u * bucket + 2u + octave], 1u); }
     }
 }
-`, [chunk_water_particle_cells, chunk_folded_workgroup_index]) });
+`, [chunk_water_particle_run_start, chunk_folded_workgroup_index]) });
 
-const share_resources = new ShaderResourceSetDescriptor();
-share_resources.createGroup()
+const cut_resources = new ShaderResourceSetDescriptor();
+cut_resources.createGroup()
     .addStorageBuffer('next', WATER_PARTICLE_ARRAY_STRUCT)
     .addStorageBuffer('activity', WebGPUArray.u32)
     .addStorageBuffer('offsets', COLLECTION_U32_STRUCT_READ)
-    .addStorageBuffer('bucket_weight', WebGPUArray.u32)
-    .addStorageBuffer('bucket_nest', WebGPUArray.u32)
+    .addStorageBuffer('links', WebGPUArray.u32)
+    .addStorageBuffer('reaches', WebGPUArray.u32)
     .addStorageBuffer('body_bounds', WebGPUArray.u32)
-    .addStorageBuffer('draw', WebGPUArray.u32)
-    .addStorageBuffer('runs', WebGPUArray.from(atomic_u32), true);
+    .addStorageBuffer('bucket_crowd', WebGPUArray.u32)
+    .addStorageBuffer('bucket_nest', WebGPUArray.from(atomic_u32), true);
 
 /**
- * Each packet drawn its share of the most crowded of its cells, lowered onto its run: a run is thinned whole, by the most
- * crowded cell any of its packets is in, so a front is never holed. A cell is crowded where its most crowded point (one
- * of it at its level and the coarser ones, or one under it the nest pass raised) reads more than
- * {@link WATER_PARTICLE_CELL_SHARE} entries, and a packet's share there is that many times its steepness over the summed
- * steepness that point reads. Where that point would read more than the gather budget, the cell keeps no more of it
- * than its own steepness's part: its keys' octaves dropped from the top until the rest fit
- * ({@link WATER_PARTICLE_CROWD_BINS}). A cell only one front reaches does not count.
+ * How many steepness classes each cell's points keep, the steepest first: as many as keep its most crowded point within
+ * {@link WATER_PARTICLE_CROWD_KEEP} runs, over its own cell and the coarser ones over it, class by class, and what finer
+ * levels add under it (the nest pass's most, less what its own and coarser cells hold), counted as the steepest, since a
+ * run sits finer the younger it is; and as many as keep it within the gather budget. Never fewer than one. Each run
+ * lowers its cell's bucket to what it finds.
  */
-export const shader_water_particles_share = ComputeShader.from({ label: 'Water / particles share', resources: share_resources,
+export const shader_water_particles_cut = ComputeShader.from({ label: 'Water / particles cut', resources: cut_resources,
     body: CodeChunk.from(/* language=WGSL */ `
+// A cell's runs by steepness class, and in all: ${BINS} classes and the total, written out as vectors, so that a cell's
+// words are read at once and a class is never a vector's component by a variable index (local memory).
+struct WaterParticleCrowd {
+    low: vec4<u32>,
+    mid: vec4<u32>,
+    high: vec3<u32>,
+}
+
+fn water_particle_crowd_at(bucket: u32) -> WaterParticleCrowd {
+    let at = ${WORDS}u * bucket;
+    return WaterParticleCrowd(vec4<u32>(bucket_crowd[at], bucket_crowd[at + 1u], bucket_crowd[at + 2u], bucket_crowd[at + 3u]),
+        vec4<u32>(bucket_crowd[at + 4u], bucket_crowd[at + 5u], bucket_crowd[at + 6u], bucket_crowd[at + 7u]),
+        vec3<u32>(bucket_crowd[at + 8u], bucket_crowd[at + 9u], bucket_crowd[at + 10u]));
+}
+
+fn water_particle_crowd_add(a: WaterParticleCrowd, b: WaterParticleCrowd) -> WaterParticleCrowd {
+    return WaterParticleCrowd(a.low + b.low, a.mid + b.mid, a.high + b.high);
+}
+
+// The classes kept and drawn, the steepest first, once a point's reads take in a class: they only grow, so a class past
+// the keep or the budget ends its count.
+fn water_particle_crowd_step(reads: u32, grade: u32, classes: vec2<u32>) -> vec2<u32> {
+    return vec2<u32>(select(classes.x, grade + 1u, reads <= ${WATER_PARTICLE_CROWD_KEEP}u),
+        select(classes.y, grade + 1u, reads <= ${WATER_PARTICLE_GATHER_BUDGET}u));
+}
+
+fn water_particle_crowd_classes(finer: u32, crowd: WaterParticleCrowd) -> vec2<u32> {
+    var reads = finer;
+    var classes = vec2<u32>(1u);
+    reads += crowd.low.x; classes = water_particle_crowd_step(reads, 0u, classes);
+    reads += crowd.low.y; classes = water_particle_crowd_step(reads, 1u, classes);
+    reads += crowd.low.z; classes = water_particle_crowd_step(reads, 2u, classes);
+    reads += crowd.low.w; classes = water_particle_crowd_step(reads, 3u, classes);
+    reads += crowd.mid.x; classes = water_particle_crowd_step(reads, 4u, classes);
+    reads += crowd.mid.y; classes = water_particle_crowd_step(reads, 5u, classes);
+    reads += crowd.mid.z; classes = water_particle_crowd_step(reads, 6u, classes);
+    reads += crowd.mid.w; classes = water_particle_crowd_step(reads, 7u, classes);
+    reads += crowd.high.x; classes = water_particle_crowd_step(reads, 8u, classes);
+    reads += crowd.high.y; classes = water_particle_crowd_step(reads, 9u, classes);
+    return classes;
+}
+
 @compute @workgroup_size(64)
 fn main(@builtin(workgroup_id) group: vec3u, @builtin(local_invocation_index) lane: u32) {
     let i = folded_workgroup_index(group) * 64u + lane;
     if (i >= next.count) { return; }
-    let drawn = draw[2u * i + 1u];
-    if (drawn == 0u) { return; }
-    let particle = water_particle_drawn(next.elements[i], drawn);
+    let particle = next.elements[i];
     if ((activity[particle.body] & ${WaterActivity.Active}u) == 0u) { return; }
-    let cells = water_particle_cells(particle, i);
-    let weight = f32(water_particle_weight(particle));
-    let coarser = body_bounds[particle.body * ${STRIDE}u] & ~((2u << cells.level) - 1u);
-    var share = 1e30;
+    let cells = water_particle_reach_at(i);
+    let levels = body_bounds[particle.body * ${STRIDE}u];
+    let coarser = levels & ~((2u << cells.level) - 1u);
+    let before = water_particle_before(i);
     for (var corner = 0u; corner < ${WATER_PARTICLE_CORNERS}u; corner++) {
         if (!water_particle_has_corner(cells, corner)) { continue; }
         let cell = water_particle_corner_cell(cells, corner);
+        if (!water_particle_starts_run(before, cell)) { continue; }
         let bucket = water_particle_bucket(particle.body, cells.level, cell, offsets.count);
-        let at = ${WORDS}u * bucket;
-        let nested = ${NEST}u * bucket;
-        if (bucket_weight[at + 1u] == ~bucket_weight[at + 2u]) { continue; }
-        // what a point of the cell reads at its level and the coarser ones
-        var entries = bucket_weight[at + 3u];
-        var steepness = bucket_weight[at];
+        // what its points read at its level and the coarser ones, by class and in all
+        var crowd = water_particle_crowd_at(bucket);
         var above = coarser;
         for (var n = 0u; n < WATER_PARTICLE_LEVELS && above != 0u; n++) {
-            let over = ${WORDS}u * water_particle_bucket_over(particle.body, cells.level, cell, firstTrailingBit(above), offsets.count);
+            let over = water_particle_bucket_over(particle.body, cells.level, cell, firstTrailingBit(above), offsets.count);
             above &= above - 1u;
-            entries += bucket_weight[over + 3u];
-            steepness += bucket_weight[over];
-        }
-        // and what its most crowded point reads
-        let crowd = max(entries, bucket_nest[nested]);
-        let total = max(steepness, bucket_nest[nested + 1u]);
-        if (crowd <= ${WATER_PARTICLE_CELL_SHARE}u || total == 0u) { continue; }
-        share = min(share, ${WATER_PARTICLE_CELL_SHARE}.0 * weight / f32(total));
-        if (crowd <= ${WATER_PARTICLE_GATHER_BUDGET}u) { continue; }
-        // no more kept than its part of the budget: the octaves of its keys dropped from the top until the rest fit
-        let quota = ${WATER_PARTICLE_GATHER_BUDGET}.0 * f32(bucket_weight[at]) / f32(total);
-        var below = 0u;
-        for (var octave = 0u; octave < ${BINS}u; octave++) { below += bucket_nest[nested + 2u + octave]; }
-        var reach = water_particle_crowd_reach(steepness);
-        for (var octave = 0u; octave < ${BINS}u && f32(below) > quota; octave++) {
-            below -= bucket_nest[nested + 2u + octave];
-            reach = select(0.0, 0.5 * reach, octave + 1u < ${BINS}u);
+            crowd = water_particle_crowd_add(crowd, water_particle_crowd_at(over));
         }
-        // drawn while its lot is under the ramp above its share: while its key is under the reach left
-        share = min(share, reach * weight / ${1 + WATER_PARTICLE_THINNING_RAMP});
+        // and, under the most crowded, what the finer ones add
+        let runs = crowd.high.z;
+        let most = max(atomicLoad(&bucket_nest[${NEST}u * bucket]), runs);
+        // within the crowd's keep, every class is kept and drawn: as the clear left it
+        if (most <= ${WATER_PARTICLE_CROWD_KEEP}u) { continue; }
+        let classes = water_particle_crowd_classes(most - runs, crowd);
+        atomicMin(&bucket_nest[${NEST}u * bucket + 1u], classes.x);
+        atomicMin(&bucket_nest[${NEST}u * bucket + 2u], classes.y);
     }
-    // non-negative floats order as their bits do
-    atomicMin(&runs[2u * draw[2u * i] + 1u], bitcast<u32>(share));
 }
-`, [chunk_water_particle_cells, chunk_folded_workgroup_index]) });
+`, [chunk_water_particle_run_start, chunk_folded_workgroup_index]) });
+
+const mark_resources = new ShaderResourceSetDescriptor();
+mark_resources.createGroup()
+    .addStorageBuffer('next', WATER_PARTICLE_ARRAY_STRUCT)
+    .addStorageBuffer('activity', WebGPUArray.u32)
+    .addStorageBuffer('offsets', COLLECTION_U32_STRUCT_READ)
+    .addStorageBuffer('reaches', WebGPUArray.u32)
+    .addStorageBuffer('bucket_nest', WebGPUArray.from(atomic_u32), true);
+
+/**
+ * Each particle of a body simulated this frame whose steepness class some cell it reaches cannot draw within the gather
+ * budget, or that an earlier frame cut, puts its front's tag in the frame's table of cut fronts: the first free slot of
+ * {@link WATER_PARTICLE_FRONT_PROBES} from its front's own, or the one already holding it. Its front's particles are
+ * alike and β apart, so every one of them then finds the tag, and the front is cut whole.
+ */
+export const shader_water_particles_mark = ComputeShader.from({ label: 'Water / particles mark', resources: mark_resources,
+    body: CodeChunk.from(/* language=WGSL */ `
+@compute @workgroup_size(64)
+fn main(@builtin(workgroup_id) group: vec3u, @builtin(local_invocation_index) lane: u32) {
+    let i = folded_workgroup_index(group) * 64u + lane;
+    if (i >= next.count) { return; }
+    let particle = next.elements[i];
+    if ((activity[particle.body] & ${WaterActivity.Active}u) == 0u) { return; }
+    let cells = water_particle_reach_at(i);
+    let grade = water_particle_crowd_class(particle);
+    var cut = particle.fading >= ${WATER_PARTICLE_CUT};
+    for (var corner = 0u; corner < ${WATER_PARTICLE_CORNERS}u; corner++) {
+        if (!water_particle_has_corner(cells, corner)) { continue; }
+        let at = ${NEST}u * water_particle_bucket(particle.body, cells.level, water_particle_corner_cell(cells, corner), offsets.count);
+        cut = cut || grade >= atomicLoad(&bucket_nest[at + 2u]);
+    }
+    if (!cut) { return; }
+    let hash = water_particle_front_hash(particle);
+    var probe = 0u;
+    // a weak exchange may fail with the slot still free: that slot again, twice the probes at most
+    for (var attempt = 0u; attempt < ${2 * WATER_PARTICLE_FRONT_PROBES}u && probe < ${WATER_PARTICLE_FRONT_PROBES}u; attempt++) {
+        let at = ${NEST}u * ((hash.y + probe) & (offsets.count - 1u)) + 3u;
+        let exchange = atomicCompareExchangeWeak(&bucket_nest[at], 0u, hash.x);
+        if (exchange.exchanged || exchange.old_value == hash.x) { break; }
+        if (exchange.old_value != 0u) { probe++; }
+    }
+}
+`, [chunk_water_particle_reach_read, chunk_folded_workgroup_index]) });
+
+const keep_resources = new ShaderResourceSetDescriptor();
+keep_resources.createGroup()
+    .addStorageBuffer('next', WATER_PARTICLE_ARRAY_STRUCT, true)
+    .addStorageBuffer('activity', WebGPUArray.u32)
+    .addStorageBuffer('offsets', COLLECTION_U32_STRUCT_READ)
+    .addStorageBuffer('reaches', WebGPUArray.u32)
+    .addStorageBuffer('bucket_nest', WebGPUArray.u32)
+    .addStorageBuffer('shown', WebGPUArray.u32, true);
+
+/**
+ * What each crowd leaves of a body simulated this frame, particle by particle: a particle whose steepness class some
+ * cell it reaches does not keep is doomed, to fade from its next step and die (chunk_water_particle_step), and is drawn
+ * as it is until then; one whose front is in the frame's table of cut fronts (the mark pass) is not drawn, here or
+ * anywhere, and dies at its next step. So a crowd loses its flattest runs, and never by a lot or an order the particles
+ * arrive in. A frame that does not step decides the same again: nothing it reads has changed. One word a particle:
+ * whether it is drawn.
+ */
+export const shader_water_particles_keep = ComputeShader.from({ label: 'Water / particles keep', resources: keep_resources,
+    body: CodeChunk.from(/* language=WGSL */ `
+@compute @workgroup_size(64)
+fn main(@builtin(workgroup_id) group: vec3u, @builtin(local_invocation_index) lane: u32) {
+    let i = folded_workgroup_index(group) * 64u + lane;
+    if (i >= next.count) { return; }
+    let particle = next.elements[i];
+    if ((activity[particle.body] & ${WaterActivity.Active}u) == 0u) { shown[i] = 1u; return; }
+    let cells = water_particle_reach_at(i);
+    let grade = water_particle_crowd_class(particle);
+    var doomed = false;
+    var cut = particle.fading >= ${WATER_PARTICLE_CUT};
+    for (var corner = 0u; corner < ${WATER_PARTICLE_CORNERS}u; corner++) {
+        if (!water_particle_has_corner(cells, corner)) { continue; }
+        let at = ${NEST}u * water_particle_bucket(particle.body, cells.level, water_particle_corner_cell(cells, corner), offsets.count);
+        doomed = doomed || grade >= bucket_nest[at + 1u];
+        cut = cut || grade >= bucket_nest[at + 2u];
+    }
+    // its front cut where another of its particles is
+    let hash = water_particle_front_hash(particle);
+    for (var probe = 0u; probe < ${WATER_PARTICLE_FRONT_PROBES}u && !cut; probe++) {
+        let tag = bucket_nest[${NEST}u * ((hash.y + probe) & (offsets.count - 1u)) + 3u];
+        if (tag == 0u) { break; }
+        cut = tag == hash.x;
+    }
+    shown[i] = select(1u, 0u, cut);
+    if (cut) {
+        next.elements[i].fading = ${WATER_PARTICLE_CUT};
+    } else if (doomed && particle.fading == 0.0) {
+        // a tenth of its steepness now, where a fading packet dies
+        next.elements[i].fading = 0.1 * abs(particle.amplitude) / max(particle.radius, 1e-30);
+    }
+}
+`, [chunk_water_particle_reach_read, chunk_folded_workgroup_index]) });
+
+/**
+ * The cells the support of a drawn particle's drawn neighbour before it overlaps, or none: a drawn particle begins a
+ * run of its front in a cell its support overlaps where these do not. Bindings: `links`, `reaches`, `shown`.
+ */
+const chunk_water_particle_drawn_run_start = CodeChunk.from(/* language=WGSL */ `
+fn water_particle_drawn_before(i: u32) -> WaterParticleReach {
+    let before = links[2u * i];
+    if (before == ~0u || shown[before] == 0u) { return water_particle_reach_none(); }
+    return water_particle_reach_at(before);
+}
+`, [chunk_water_particle_reach_read]);
 
 const bin_resources = new ShaderResourceSetDescriptor();
 bin_resources.createGroup()
@@ -705,19 +835,15 @@ bin_resources.createGroup()
     .addStorageBuffer('slots', WebGPUArray.u32, true)
     .addStorageBuffer('bucket_amplitude', WebGPUArray.from(atomic_u32), true)
     .addStorageBuffer('body_bounds', WebGPUArray.from(atomic_u32), true)
-    .addStorageBuffer('draw', WebGPUArray.u32)
-    .addStorageBuffer('runs', WebGPUArray.u32)
-    .addStorageBuffer('visible', WebGPUArray.from(f32), true);
+    .addStorageBuffer('links', WebGPUArray.u32)
+    .addStorageBuffer('reaches', WebGPUArray.u32)
+    .addStorageBuffer('shown', WebGPUArray.u32);
 
 /**
- * Enter each packet drawn of a body simulated this frame in every hash cell its support overlaps: count it into the
- * cell's bucket, keep its slot there, raise the bucket's largest |a| to its own, and mark its level on its body. One
- * atomic each: no compare-exchange loop a crowded bucket would serialize. A paused body's particles take no slot:
- * nothing draws them this frame.
- *
- * Where cells are crowded (the share pass), a run is drawn by the share its most crowded cell leaves it and its
- * front's lot: one decision for all its packets and all their cells, so neither a front nor the surface across cells
- * is holed, and it does not change with the order particles arrive in. One left out takes no slot.
+ * Enter each drawn run of a body simulated this frame in every cell it is drawn in, by its first particle: count it into
+ * the cell's bucket, keep its slot there, raise the bucket's largest |a| to its own, and mark its level on its body. One
+ * atomic each: no compare-exchange loop a crowded bucket would serialize. A paused body's particles take no slot, nor
+ * does one its crowd does not draw: nothing draws them this frame.
  */
 export const shader_water_particles_bin = ComputeShader.from({ label: 'Water / particles bin', resources: bin_resources,
     body: CodeChunk.from(/* language=WGSL */ `
@@ -729,73 +855,93 @@ fn water_particle_unslotted(i: u32) {
 fn main(@builtin(workgroup_id) group: vec3u, @builtin(local_invocation_index) lane: u32) {
     let i = folded_workgroup_index(group) * 64u + lane;
     if (i >= next.count) { return; }
-    let drawn = draw[2u * i + 1u];
-    let particle = water_particle_drawn(next.elements[i], max(drawn, 1u));
-    if (drawn == 0u || (activity[particle.body] & ${WaterActivity.Active}u) == 0u) { water_particle_unslotted(i); return; }
-    let cells = water_particle_cells(particle, i);
-    let visibility = water_particle_visibility(bitcast<f32>(runs[2u * draw[2u * i] + 1u]), water_particle_lot(particle));
-    visible[i] = visibility;
-    if (!(visibility > 0.0)) { water_particle_unslotted(i); return; }
+    let particle = next.elements[i];
+    if ((activity[particle.body] & ${WaterActivity.Active}u) == 0u || shown[i] == 0u) { water_particle_unslotted(i); return; }
+    let cells = water_particle_reach_at(i);
+    let before = water_particle_drawn_before(i);
     atomicOr(&body_bounds[particle.body * ${STRIDE}u], 1u << cells.level);
     for (var corner = 0u; corner < ${WATER_PARTICLE_CORNERS}u; corner++) {
         var slot = ~0u;
         if (water_particle_has_corner(cells, corner)) {
-            let bucket = water_particle_bucket(particle.body, cells.level, water_particle_corner_cell(cells, corner), buckets.count);
-            slot = atomicAdd(&buckets.elements[bucket], 1u);
-            // non-negative floats order as their bits do
-            atomicMax(&bucket_amplitude[bucket], bitcast<u32>(abs(particle.amplitude) * visibility));
+            let cell = water_particle_corner_cell(cells, corner);
+            if (!water_particle_reaches(before, cell)) {
+                let bucket = water_particle_bucket(particle.body, cells.level, cell, buckets.count);
+                slot = atomicAdd(&buckets.elements[bucket], 1u);
+                // non-negative floats order as their bits do
+                atomicMax(&bucket_amplitude[bucket], bitcast<u32>(abs(particle.amplitude)));
+            }
         }
         slots[i * ${WATER_PARTICLE_CORNERS}u + corner] = slot;
     }
 }
-`, [chunk_water_particle_cells, chunk_folded_workgroup_index]) });
+`, [chunk_water_particle_drawn_run_start, chunk_folded_workgroup_index]) });
 
 const scatter_resources = new ShaderResourceSetDescriptor();
 scatter_resources.createGroup()
     .addStorageBuffer('next', WATER_PARTICLE_ARRAY_STRUCT)
     .addStorageBuffer('offsets', COLLECTION_U32_STRUCT_READ)
     .addStorageBuffer('slots', WebGPUArray.u32)
-    .addStorageBuffer('visible', WebGPUArray.from(f32))
-    .addStorageBuffer('draw', WebGPUArray.u32)
+    .addStorageBuffer('links', WebGPUArray.u32)
+    .addStorageBuffer('reaches', WebGPUArray.u32)
+    .addStorageBuffer('shown', WebGPUArray.u32)
     .addStorageBuffer('staging', WebGPUArray.from(WATER_PARTICLE_ENTRY_STRUCT), true);
 
-/** Each entry to its bucket's range, in arrival order, at the height its crowd leaves it; the rank pass orders it. */
+/**
+ * Each run's entry to its bucket's range, in arrival order; the rank pass orders it. A run is its first particle and its
+ * front's drawn neighbours after it, one by one, while their supports overlap the cell, at most
+ * {@link WATER_PARTICLE_RUN_LIMIT}; an end is open where the front has no drawn neighbour beyond it.
+ */
 export const shader_water_particles_scatter = ComputeShader.from({ label: 'Water / particles scatter', resources: scatter_resources,
     body: CodeChunk.from(/* language=WGSL */ `
 @compute @workgroup_size(64)
 fn main(@builtin(workgroup_id) group: vec3u, @builtin(local_invocation_index) lane: u32) {
     let i = folded_workgroup_index(group) * 64u + lane;
     if (i >= next.count) { return; }
-    let drawn = draw[2u * i + 1u];
-    if (drawn == 0u) { return; }
-    let particle = water_particle_drawn(next.elements[i], drawn);
-    let cells = water_particle_cells(particle, i);
-    for (var corner = 0u; corner < ${WATER_PARTICLE_CORNERS}u; corner++) {
+    var first = 0u;
+    for (; first < ${WATER_PARTICLE_CORNERS}u && slots[i * ${WATER_PARTICLE_CORNERS}u + first] == ~0u; first++) {}
+    if (first == ${WATER_PARTICLE_CORNERS}u) { return; }
+    let particle = next.elements[i];
+    let cells = water_particle_reach_at(i);
+    let lone = water_particle_entry(particle, i, cells);
+    let before = links[2u * i];
+    let open_start = select(0u, WATER_PARTICLE_RUN_OPEN_START, before == ~0u || shown[before] == 0u);
+    for (var corner = first; corner < ${WATER_PARTICLE_CORNERS}u; corner++) {
         let slot = slots[i * ${WATER_PARTICLE_CORNERS}u + corner];
         if (slot == ~0u) { continue; }
         let cell = water_particle_corner_cell(cells, corner);
         let bucket = water_particle_bucket(particle.body, cells.level, cell, offsets.count);
         var start = 0u;
         if (bucket > 0u) { start = offsets.elements[bucket - 1u]; }
-        var entry = cells.entry;
+        // the run, as far as its drawn neighbours reach the cell
+        var members = 1u;
+        var open_end = 0u;
+        var at = i;
+        for (; members < ${WATER_PARTICLE_RUN_LIMIT}u; members++) {
+            let after = links[2u * at + 1u];
+            if (after == ~0u) { open_end = WATER_PARTICLE_RUN_OPEN_END; break; }
+            if (shown[after] == 0u) { open_end = WATER_PARTICLE_RUN_OPEN_END; break; }
+            if (!water_particle_reaches(water_particle_reach_at(after), cell)) { break; }
+            at = after;
+        }
+        var entry = lone;
         entry.cell = cell;
-        entry.amplitude *= visible[i];
+        entry.run = members | open_start | open_end;
         staging[start + slot] = entry;
     }
 }
-`, [chunk_water_particle_cells, chunk_folded_workgroup_index]) });
+`, [chunk_water_particle_reach_read, chunk_folded_workgroup_index]) });
 
 const rank_resources = new ShaderResourceSetDescriptor();
 rank_resources.createGroup()
     .addStorageBuffer('next', WATER_PARTICLE_ARRAY_STRUCT)
     .addStorageBuffer('offsets', COLLECTION_U32_STRUCT_READ)
     .addStorageBuffer('slots', WebGPUArray.u32)
-    .addStorageBuffer('draw', WebGPUArray.u32)
+    .addStorageBuffer('reaches', WebGPUArray.u32)
     .addStorageBuffer('staging', WebGPUArray.from(WATER_PARTICLE_ENTRY_STRUCT))
     .addStorageBuffer('entries', WebGPUArray.from(WATER_PARTICLE_ENTRY_STRUCT), true);
 
 /**
- * Order every bucket by particle index then cell, so a gather that runs out of budget drops the same
+ * Order every bucket by its runs' first particles then cells, so a gather that runs out of budget drops the same
  * entries every frame (the particle array keeps its order from frame to frame). A bucket of more than
  * ${WATER_PARTICLE_RANK_LIMIT} keeps its arrival order: a fixed budget of comparisons per entry.
  */
@@ -811,14 +957,12 @@ fn water_entry_before(a: ${WATER_PARTICLE_ENTRY_STRUCT.wgsl_ref}, b: ${WATER_PAR
 fn main(@builtin(workgroup_id) group: vec3u, @builtin(local_invocation_index) lane: u32) {
     let i = folded_workgroup_index(group) * 64u + lane;
     if (i >= next.count) { return; }
-    let drawn = draw[2u * i + 1u];
-    if (drawn == 0u) { return; }
-    let particle = water_particle_drawn(next.elements[i], drawn);
-    let cells = water_particle_cells(particle, i);
+    let cells = water_particle_reach_at(i);
+    let body = next.elements[i].body;
     for (var corner = 0u; corner < ${WATER_PARTICLE_CORNERS}u; corner++) {
         let slot = slots[i * ${WATER_PARTICLE_CORNERS}u + corner];
         if (slot == ~0u) { continue; }
-        let bucket = water_particle_bucket(particle.body, cells.level, water_particle_corner_cell(cells, corner), offsets.count);
+        let bucket = water_particle_bucket(body, cells.level, water_particle_corner_cell(cells, corner), offsets.count);
         var start = 0u;
         if (bucket > 0u) { start = offsets.elements[bucket - 1u]; }
         let end = offsets.elements[bucket];
@@ -831,7 +975,7 @@ fn main(@builtin(workgroup_id) group: vec3u, @builtin(local_invocation_index) la
         entries[start + rank] = entry;
     }
 }
-`, [chunk_water_particle_cells, chunk_folded_workgroup_index]) });
+`, [chunk_water_particle_reach_read, chunk_folded_workgroup_index]) });
 
 const bounds_resources = new ShaderResourceSetDescriptor();
 bounds_resources.createGroup()
@@ -839,14 +983,14 @@ bounds_resources.createGroup()
     .addStorageBuffer('activity', WebGPUArray.u32)
     .addStorageBuffer('offsets', COLLECTION_U32_STRUCT_READ)
     .addStorageBuffer('bucket_amplitude', WebGPUArray.u32)
-    .addStorageBuffer('draw', WebGPUArray.u32)
+    .addStorageBuffer('slots', WebGPUArray.u32)
+    .addStorageBuffer('reaches', WebGPUArray.u32)
     .addStorageBuffer('body_bounds', WebGPUArray.from(atomic_u32), true);
 
 /**
- * Each body's bound per level: the largest of count × max |a| over the buckets its particles are in, which is
- * at least the bucket's Σ|a|. Every particle that reaches a point is in that point's cell's bucket, and neither
- * its height nor its horizontal displacement exceeds |a|, so the bound holds everywhere; a hash collision only
- * adds to it.
+ * Each body's bound per level: the largest of count × max |a| over the buckets its runs are in, which is at least the
+ * bucket's Σ|a|. Every run that reaches a point is in that point's cell's bucket, and neither its height nor its
+ * horizontal displacement exceeds |a|, so the bound holds everywhere; a hash collision only adds to it.
  */
 export const shader_water_particles_bounds = ComputeShader.from({ label: 'Water / particles bounds', resources: bounds_resources,
     body: CodeChunk.from(/* language=WGSL */ `
@@ -854,15 +998,13 @@ export const shader_water_particles_bounds = ComputeShader.from({ label: 'Water
 fn main(@builtin(workgroup_id) group: vec3u, @builtin(local_invocation_index) lane: u32) {
     let i = folded_workgroup_index(group) * 64u + lane;
     if (i >= next.count) { return; }
-    let drawn = draw[2u * i + 1u];
-    if (drawn == 0u) { return; }
-    let particle = water_particle_drawn(next.elements[i], drawn);
+    let particle = next.elements[i];
     // a paused body keeps the bounds its particles last had
     if ((activity[particle.body] & ${WaterActivity.Active}u) == 0u) { return; }
-    let cells = water_particle_cells(particle, i);
+    let cells = water_particle_reach_at(i);
     var largest = 0.0;
     for (var corner = 0u; corner < ${WATER_PARTICLE_CORNERS}u; corner++) {
-        if (!water_particle_has_corner(cells, corner)) { continue; }
+        if (slots[i * ${WATER_PARTICLE_CORNERS}u + corner] == ~0u) { continue; }
         let bucket = water_particle_bucket(particle.body, cells.level, water_particle_corner_cell(cells, corner), offsets.count);
         var start = 0u;
         if (bucket > 0u) { start = offsets.elements[bucket - 1u]; }
@@ -871,4 +1013,4 @@ fn main(@builtin(workgroup_id) group: vec3u, @builtin(local_invocation_index) la
     // non-negative floats order as their bits do
     atomicMax(&body_bounds[particle.body * ${STRIDE}u + 1u + cells.level], bitcast<u32>(largest));
 }
-`, [chunk_water_particle_cells, chunk_folded_workgroup_index]) });
+`, [chunk_water_particle_reach_read, chunk_folded_workgroup_index]) });