@woosh/meep-engine 3.42.0 → 3.44.0

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

@@ -1,6 +1,7 @@
 import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
 import { BVH_TRAVERSAL_STACK_SIZE } from "../../../shader/chunk/bvh/BVH_TRAVERSAL_STACK_SIZE.js";
 import { chunk_ray_query_blas_nearest } from "../../../shader/chunk/geometry/ray/chunk_ray_query_blas_nearest.js";
+import { chunk_geometry_read_triangle_positions } from "../../../shader/chunk/geometry/format/chunk_geometry_read_triangle_positions.js";
 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";
@@ -10,7 +11,12 @@ 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
- * widening front, damps, reflects off its body's authored outline, and dies or splits.
+ * widening front, damps, meets its body's authored outline, and dies or splits.
+ *
+ * At the outline the water shows the packet plus the shore's share of its mirror image in the outline (the image
+ * method, as Jeschke & Wojtan 2017 §4.4 keep a "ghost" of a reflected packet): the image is emitted the step the first
+ * of the packet's support leaves the body, and the packet carries on until the last of it has left it too. The body's
+ * outline clips what of either lies beyond it, so the water changes only as the two move.
  *
  * Whether a point is over the body is a down-ray into the body's own BLAS, so the outline is exactly the
  * authored mesh's, holes for islands included. Bindings: `geometries`, `blas_lookup`, `blas_data`,
@@ -22,8 +28,11 @@ export const chunk_water_particle_step = CodeChunk.from(/* language=WGSL */ `
 const WATER_PARTICLE_FADE_SECONDS: f32 = ${WATER_PARTICLE_FADE_SECONDS};
 
 struct WaterParticleStep {
+    // the particle a step on
     particle: ${WATER_PARTICLE_STRUCT.wgsl_ref},
-    // 0 dies, 1 lives on, 3 splits into three
+    // the mirror image it leaves, when it leaves one
+    image: ${WATER_PARTICLE_STRUCT.wgsl_ref},
+    // the particles it leaves, each split into three when they split: 0, 1, 2 (it, then its image), 3 or 6
     children: u32,
 }
 
@@ -37,6 +46,50 @@ fn water_particle_over_body(geometry_index: u32, local: vec2<f32>) -> ${RAY_HIT_
         top - box[1] + margin), geometry_index, &stack, 0u);
 }
 
+// The points of a packet's support the step tests against the outline, on its arc ρ from its front's centre: the k-th
+// of its axis and its window's ends, β either side of it. The support is the annular sector of two radii either side of
+// the front and β either side of the axis, so a straight outline meets first the point of its leading arc whose
+// direction is nearest the outline's normal, an end unless the normal is within β of the axis, and leaves last the end
+// of its trailing arc farthest from it: at any incidence, these three find both, or within the arc's sagitta.
+fn water_particle_support_point(particle: ${WATER_PARTICLE_STRUCT.wgsl_ref}, k: u32, rho: f32) -> vec2<f32> {
+    let turn = select(0.0, select(particle.dispersion, -particle.dispersion, k == 1u), k > 0u);
+    return particle.origin + water_particle_direction(particle.angle + turn) * rho;
+}
+
+// Whether a triangle seen from above holds a point strictly inside it, in the body's local xz.
+fn water_triangle_covers(a: vec2<f32>, b: vec2<f32>, c: vec2<f32>, point: vec2<f32>) -> bool {
+    let side = sign((b.x - a.x) * (c.y - a.y) - (b.y - a.y) * (c.x - a.x));
+    let ab = (b.x - a.x) * (point.y - a.y) - (b.y - a.y) * (point.x - a.x);
+    let bc = (c.x - b.x) * (point.y - b.y) - (c.y - b.y) * (point.x - b.x);
+    let ca = (a.x - c.x) * (point.y - c.y) - (a.y - c.y) * (point.x - c.x);
+    return side * ab > 0.0 && side * bc > 0.0 && side * ca > 0.0;
+}
+
+// The k-th tested point of a particle's leading arc once it has stepped dt on: what water_particle_advance tests.
+fn water_particle_leading_point(particle: ${WATER_PARTICLE_STRUCT.wgsl_ref}, dt: f32, k: u32) -> vec2<f32> {
+    var stepped = particle;
+    stepped.age += dt;
+    return water_particle_support_point(stepped, k, water_particle_distance(stepped) + water_particle_half_length(stepped));
+}
+
+// What is already known of a particle's leading arc a step on, bit k for its k-th tested point: whether that is known,
+// and whether it is over the body; and the triangle under the axis's point when that is. Zero is nothing known. A
+// particle's window's ends are its neighbours' axis points when they are of its front, so the update pass hands each
+// what its neighbours in the subgroup found.
+struct WaterParticleArcHint {
+    known: u32,
+    over: u32,
+    triangle: u32,
+}
+
+// Whether any of an arc's tested points is over the body.
+fn water_particle_arc_over(particle: ${WATER_PARTICLE_STRUCT.wgsl_ref}, geometry_index: u32, scale: vec2<f32>, rho: f32) -> bool {
+    for (var k = 0u; k < 3u; k++) {
+        if (water_particle_over_body(geometry_index, water_particle_support_point(particle, k, rho) / scale).t >= 0.0) { return true; }
+    }
+    return false;
+}
+
 // The line of the edge of a triangle nearest a point inside it, in the metric xz frame: a point on it and a
 // unit normal. Which side the normal points to does not matter: a mirror in a line is the same for either.
 struct WaterOutlineLine {
@@ -62,54 +115,119 @@ fn water_outline_line(geometry_index: u32, triangle: u32, point: vec2<f32>, scal
     return line;
 }
 
+// The particle's mirror image in a line of the outline: its front's centre and its direction mirrored. Not yet reflected.
+fn water_particle_mirrored(particle: ${WATER_PARTICLE_STRUCT.wgsl_ref}, line: WaterOutlineLine) -> ${WATER_PARTICLE_STRUCT.wgsl_ref} {
+    var image = particle;
+    let direction = water_particle_direction(particle.angle);
+    let mirrored = direction - 2.0 * dot(direction, line.normal) * line.normal;
+    image.origin -= 2.0 * dot(particle.origin - line.point, line.normal) * line.normal;
+    image.angle = atan2(mirrored.y, mirrored.x);
+    image.reflected = 0u;
+    return image;
+}
+
 // Advance a particle by dt. scale turns the body's metric frame into its local one; reflection is the
-// outline's amplitude reflection coefficient; threshold is the steepness |a|/r below which it dies.
+// outline's amplitude reflection coefficient; threshold is the steepness |a|/r below which it dies; hint is what is
+// already known of its leading arc.
 fn water_particle_advance(input: ${WATER_PARTICLE_STRUCT.wgsl_ref}, dt: f32, geometry_index: u32, scale: vec2<f32>,
-    reflection: f32, threshold: f32) -> WaterParticleStep {
+    reflection: f32, threshold: f32, hint: WaterParticleArcHint) -> WaterParticleStep {
     var particle = input;
-    let before = water_particle_position(particle);
     let distance_before = water_particle_distance(particle);
+    let half_length_before = water_particle_half_length(particle);
     particle.age += dt;
     let distance_after = water_particle_distance(particle);
-    // energy spread over the widening circumference, and the water's own damping
-    particle.amplitude *= sqrt(max(distance_before, 1e-30) / max(distance_after, 1e-30))
-        * exp(-water_particle_damping(particle.radius) * dt);
-    let after = water_particle_position(particle);
-    if (water_particle_over_body(geometry_index, after / scale).t < 0.0) {
-        let start = water_particle_over_body(geometry_index, before / scale);
-        if (!(reflection > 0.0) || start.t < 0.0) { return WaterParticleStep(particle, 0u); }
-        // where along this frame's step it left the mesh
-        var lo = 0.0;
-        var hi = 1.0;
-        var last = start;
-        for (var halving = 0u; halving < 6u; halving++) {
-            let mid = 0.5 * (lo + hi);
-            let probe = water_particle_over_body(geometry_index, mix(before, after, mid) / scale);
-            if (probe.t >= 0.0) { lo = mid; last = probe; } else { hi = mid; }
-        }
-        // the mirror image of its front in the outline's own line, wherever along the step it was crossed
-        let line = water_outline_line(geometry_index, last.triangle, mix(before, after, lo), scale);
-        let normal = line.normal;
-        let direction = water_particle_direction(particle.angle);
-        let reflected = direction - 2.0 * dot(direction, normal) * normal;
-        particle.origin -= 2.0 * dot(particle.origin - line.point, normal) * normal;
-        particle.angle = atan2(reflected.y, reflected.x);
-        particle.amplitude *= reflection;
-        // a corner can send the mirror image off the mesh too
-        if (water_particle_over_body(geometry_index, water_particle_position(particle) / scale).t < 0.0) {
-            return WaterParticleStep(particle, 0u);
-        }
-    }
+    // energy spread over the widening circumference and the lengthening envelope (Jeschke & Wojtan 2017 eq. 17), and the
+    // water's own damping
+    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
     let floor = threshold * particle.radius;
     if (!(abs(particle.amplitude) >= floor)) {
         particle.amplitude *= exp(-dt / WATER_PARTICLE_FADE_SECONDS);
-        if (!(abs(particle.amplitude) >= 0.1 * floor)) { return WaterParticleStep(particle, 0u); }
+        if (!(abs(particle.amplitude) >= 0.1 * floor)) { 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);
+    // whether any of it may still be over the body
+    var remains = true;
+    var image = particle;
+    var mirrored = false;
+    if (particle.reflected == 0u) {
+        // which of its leading arc's tested points are over the body: what the hint knows, then the axis's by a down-ray,
+        // the ends by the triangle under it, which covers them away from the outline, and the rest by a down-ray each
+        let ahead = distance_after + reach;
+        var known = hint.known;
+        var over = hint.over & known;
+        var triangle = hint.triangle;
+        if ((known & 1u) == 0u) {
+            let hit = water_particle_over_body(geometry_index, water_particle_support_point(particle, 0u, ahead) / scale);
+            known |= 1u;
+            over |= select(0u, 1u, hit.t >= 0.0);
+            triangle = hit.triangle;
+        }
+        if ((over & 1u) != 0u && (known & 6u) != 6u) {
+            var a: vec3<f32>;
+            var b: vec3<f32>;
+            var c: vec3<f32>;
+            geometry_read_triangle_positions(&a, &b, &c, geometries[geometry_index], triangle);
+            for (var k = 1u; k < 3u; k++) {
+                if (((known >> k) & 1u) == 0u && water_triangle_covers(a.xz, b.xz, c.xz, water_particle_support_point(particle, k, ahead) / scale)) {
+                    known |= 1u << k;
+                    over |= 1u << k;
+                }
+            }
+        }
+        for (var k = 1u; k < 3u; k++) {
+            if (((known >> k) & 1u) == 0u
+                && water_particle_over_body(geometry_index, water_particle_support_point(particle, k, ahead) / scale).t >= 0.0) { over |= 1u << k; }
+        }
+        // the first of them to leave the body: one off it whose radius was over it where its trailing arc was when the
+        // step began. With none over it there, the point is not leaving the body but entering it, as a mirror image's
+        // do: every radius of one starts beyond its outline.
+        var crossing = 3u;
+        var back = vec2<f32>(0.0);
+        var last: ${RAY_HIT_INFO.wgsl_ref};
+        for (var k = 0u; k < 3u && crossing == 3u; k++) {
+            if (((over >> k) & 1u) != 0u) { continue; }
+            back = water_particle_support_point(particle, k, distance_before - reach);
+            last = water_particle_over_body(geometry_index, back / scale);
+            if (last.t >= 0.0) { crossing = k; }
+        }
+        if (crossing < 3u) {
+            // it is kept this step: if all of it has left the body too, it dies at the next, unseen beyond the outline
+            particle.reflected = 1u;
+            // where from there that radius leaves the body
+            let leading = water_particle_support_point(particle, crossing, ahead);
+            var lo = 0.0;
+            var hi = 1.0;
+            for (var halving = 0u; halving < 10u; halving++) {
+                let mid = 0.5 * (lo + hi);
+                let probe = water_particle_over_body(geometry_index, mix(back, leading, mid) / scale);
+                if (probe.t >= 0.0) { lo = mid; last = probe; } else { hi = mid; }
+            }
+            // the mirror image of its front in the outline's own line, wherever that was crossed
+            image = water_particle_mirrored(particle, water_outline_line(geometry_index, last.triangle, mix(back, leading, lo), scale));
+            image.amplitude *= reflection;
+            mirrored = abs(image.amplitude) >= 0.1 * floor;
+        } else if (over == 0u) {
+            // with none of them over the body and none leaving it, all of it is beyond the outline: a splash off the
+            // mesh, or a mirror image landing off it at a corner (one entering the body has the point it was mirrored
+            // from over it)
+            remains = false;
+        }
+    } else {
+        remains = water_particle_arc_over(particle, geometry_index, scale, distance_after - reach);
     }
-    // Yuksel's subdivision, at a coarser spacing: the window along the front keeps its height
-    if (water_particle_width(particle) > 2.0 * particle.radius) { return WaterParticleStep(particle, 3u); }
-    return WaterParticleStep(particle, 1u);
+    // Yuksel's subdivision, at a coarser spacing: the three windows of a third of the angle sum to the front's height
+    // as the parents' did, so the surface does not change. A window splits once its arc along the front is longer than
+    // its envelope is across it, so a packet's support stays about round, whatever its stretch. An image is as wide as
+    // its packet and splits with it.
+    let split = select(1u, 3u, water_particle_width(particle) > water_particle_half_length(particle));
+    // a reflected packet lives until the last of it has left the body
+    if (!remains) { return WaterParticleStep(particle, particle, 0u); }
+    if (mirrored) { return WaterParticleStep(particle, image, 2u * split); }
+    return WaterParticleStep(particle, particle, split);
 }
 
 // The death threshold: a packet flatter than the body's own wind waves is not drawn, and the fuller the pool,
@@ -118,4 +236,4 @@ fn water_particle_threshold(slope_variance: f32, live: u32, capacity: u32) -> f3
     let pressure = f32(live) / f32(max(capacity, 1u));
     return max(0.003, 0.1 * sqrt(max(slope_variance, 0.0))) / max(1.0 - pressure, 0.05);
 }
-`, [chunk_water_particle, chunk_ray_query_blas_nearest]);
+`, [chunk_water_particle, chunk_ray_query_blas_nearest, chunk_geometry_read_triangle_positions]);

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

@@ -11,25 +11,54 @@ export const WATER_PARTICLE_CORNERS: 4;
 /** Buckets ordered by particle; a crowded bucket past this keeps its arrival order. */
 export const WATER_PARTICLE_RANK_LIMIT: 64;
 /**
- * Packets a crowded cell keeps: where more crowd a cell, each is drawn by its share of the cell's summed steepness
- * times this, so about this many stay, the steepest whole. Well under the surface sampler's gather budget and the rank
- * limit, so a point reads all of its cell and every bucket keeps the particles' order.
+ * 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.
+ */
+export const WATER_PARTICLE_CELL_SHARE: 24;
+/**
+ * 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.
+ */
+export const WATER_PARTICLE_CROWD_BINS: 4;
+/**
+ * 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.
  */
-export const WATER_PARTICLE_CELL_SHARE: 16;
+export const WATER_PARTICLE_CROWD_WORDS: 4;
+/**
+ * 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.
+ */
+export const WATER_PARTICLE_NEST_WORDS: number;
 /** Width of the ramp a thinned packet fades over, a fraction of its share. */
 export const WATER_PARTICLE_THINNING_RAMP: 0.25;
 /** The step's settings: one immediate per entry point. */
 export const WATER_PARTICLE_STEP_STRUCT: WebGPUStruct;
 /** The pool's limits for the frame's finalize. */
 export const WATER_PARTICLE_LIMITS_STRUCT: WebGPUStruct;
-/**
- * Advance every live particle of a body simulated this frame in place and count what it leaves: 0, 1 or 3. A paused
- * body's particles stand still and leave themselves.
- */
 export const shader_water_particles_update: ComputeShader;
 /**
- * Write what each particle leaves into the next array at its scanned offset, in order: a split particle's
- * three at θ − β/3, θ, θ + β/3 with β/3 each. Past capacity, the tail is dropped.
+ * Write what each particle leaves into the next array at its scanned offset, in order: the particle, then the mirror
+ * image it left; each split one's three at θ − β/3, θ, θ + β/3 with β/3 each. So a front's particles stay in a row
+ * and in order, and an image follows its packet as a front of its own. Past capacity, the tail is dropped.
  */
 export const shader_water_particles_split: ComputeShader;
 /** The next array's count: everything the scan placed, up to capacity. */
@@ -37,30 +66,71 @@ export const shader_water_particles_total: ComputeShader;
 /**
  * Each queued splash of a row on the culling pass's emit list becomes a ring
  * (WATER_SURFACE_SIMULATION_PLAN_2026_10_06.md §5.3): packets of the splash's radius r, two radii out from its centre,
- * a front's width apart, ridge height strength·r/c (a vertical velocity over the time a crest takes to cross the
+ * their windows' arcs no longer than their envelopes, ridge height strength·r/c (a vertical velocity over the time a crest takes to cross the
  * packet), no steeper than 0.1. The row's queue is spent. A paused body's ring stands still with its other particles,
  * which this frame's binning does not visit, so the ring's bound is added to the body's own here.
  */
 export const shader_water_particles_emit: ComputeShader;
 /**
  * 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}.
+ * 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.
  */
 export const shader_water_particles_finalize: ComputeShader;
 /**
- * Each particle of a body simulated this frame adds its steepness to every cell its support overlaps: how crowded a
- * cell is, for the bin pass to thin it by.
+ * 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.
+ */
+export const shader_water_particles_clear: ComputeShader;
+/**
+ * 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.
+ */
+export const shader_water_particles_fronts: ComputeShader;
+/**
+ * Two words a run: its first particle, and the share its crowd leaves it, none yet (the share pass lowers it).
+ */
+export const shader_water_particles_runs: ComputeShader;
+/**
+ * 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.
+ */
+export const shader_water_particles_groups: ComputeShader;
+/**
+ * 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.
  */
 export const shader_water_particles_weigh: ComputeShader;
 /**
- * Enter each particle 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.
+ * 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.
+ */
+export const shader_water_particles_nest: ComputeShader;
+/**
+ * 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.
+ */
+export const shader_water_particles_share: ComputeShader;
+/**
+ * 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 weigh pass), a particle is drawn by how much its most crowded cell leaves it
- * ({@link WATER_PARTICLE_CELL_SHARE}): one decision for all its cells, so the surface stays continuous across them, and
- * from its own lot, so it does not change with the order particles arrive in. One left out takes no slot.
+ * 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.
  */
 export const shader_water_particles_bin: ComputeShader;
 /** Each entry to its bucket's range, in arrival order, at the height its crowd leaves it; the rank pass orders it. */

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

@@ -1 +1 @@
-{"version":3,"file":"shader_water_particles.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/water/surface/particles/shader_water_particles.js"],"names":[],"mappings":"AAuBA,uFAAuF;AACvF,uDAGE;AAEF,+DAA+D;AAC/D,8DAGE;AAEF,oFAAoF;AACpF,yDAGE;AAEF,0DAA0D;AAC1D,4CAA6C;AAE7C,gFAAgF;AAChF,uCAAwC;AAExC,uFAAuF;AACvF,2CAA4C;AAE5C;;;;GAIG;AACH,2CAA4C;AAE5C,8EAA8E;AAC9E,gDAAiD;AAOjD,0DAA0D;AAC1D,sDAAqH;AAErH,kDAAkD;AAClD,wDAA0H;AAe1H;;;GAGG;AACH,0DA0B8G;AAS9G;;;GAGG;AACH,yDAsB+E;AAQ/E,0EAA0E;AAC1E,yDAOiD;AAYjD;;;;;;GAMG;AACH,wDAwC0C;AAQ1C;;;GAGG;AACH,4DASiD;AA+DjD;;;GAGG;AACH,yDAekE;AAalE;;;;;;;;;GASG;AACH,uDAqCkE;AAUlE,sHAAsH;AACtH,2DAqBkE;AAUlE;;;;GAIG;AACH,wDA8BkE;AAUlE;;;;;GAKG;AACH,0DAqBkE;6BAjfrC,sCAAsC;8BAJrC,kCAAkC"}
+{"version":3,"file":"shader_water_particles.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/water/surface/particles/shader_water_particles.js"],"names":[],"mappings":"AA0BA,uFAAuF;AACvF,uDAGE;AAEF,+DAA+D;AAC/D,8DAGE;AAEF,oFAAoF;AACpF,yDAGE;AAEF,0DAA0D;AAC1D,4CAA6C;AAE7C,gFAAgF;AAChF,uCAAwC;AAExC,uFAAuF;AACvF,2CAA4C;AAE5C;;;;;;;;;;;;;;;;;;GAkBG;AACH,2CAA4C;AAE5C;;;;;GAKG;AACH,0CAA2C;AAE3C;;;GAGG;AACH,2CAA4C;AAE5C;;;;GAIG;AACH,+CAAuE;AAEvE,8EAA8E;AAC9E,gDAAiD;AAUjD,0DAA0D;AAC1D,sDAAqH;AAErH,kDAAkD;AAClD,wDAA0H;AAuF1H,0DACyB;AAUzB;;;;GAIG;AACH,yDA4B+E;AAQ/E,0EAA0E;AAC1E,yDAOiD;AAYjD;;;;;;GAMG;AACH,wDAyC0C;AAS1C;;;;GAIG;AACH,4DAaiD;AASjD;;;GAGG;AACH,yDAWsC;AA6FtC;;;;;GAKG;AACH,0DAQ4D;AAQ5D;;GAEG;AACH,wDAY+E;AAS/E;;;GAGG;AACH,0DAc4D;AAW5D;;;;;GAKG;AACH,yDAuBkE;AAYlE;;;;;GAKG;AACH,wDAwCkE;AAalE;;;;;;;;GAQG;AACH,yDAoDkE;AAclE;;;;;;;;;GASG;AACH,uDA6BkE;AAWlE,sHAAsH;AACtH,2DAuBkE;AAWlE;;;;GAIG;AACH,wDAgCkE;AAWlE;;;;;GAKG;AACH,0DAuBkE;6BAp2BrC,sCAAsC;8BAJrC,kCAAkC"}