@woosh/meep-engine 3.44.0 → 3.46.0

package/src/shade/renderer/shader/type/WebGPUArray.js

@@ -1,5 +1,5 @@
 import { assert } from "../../../../core/assert.js";
-import { combine_hash } from "../../../../core/collection/array/combine_hash.js";
+import { hash_mix2 } from "../../../../core/math/hash/hash_mix2.js";
 import { round_up } from "../../../../core/math/round_up.js";
 import { CodeChunk } from "../compiler/CodeChunk.js";
 import { f32, u32, vec4f, vec4u } from "./WEBGPU_WGSL_PRIMITIVE_TYPES.js";
@@ -61,7 +61,7 @@ export class WebGPUArray extends WebGPUType {
     }
 
     hash() {
-        return combine_hash(
+        return hash_mix2(
             this.type.hash(),
             this.count
         );

package/src/shade/renderer/shader/type/WebGPUStruct.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"WebGPUStruct.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shader/type/WebGPUStruct.js"],"names":[],"mappings":"AA0BA;;;;GAIG;AACH;IAiNI;;;;;;;;;;;;;;OAcG;IACH,8BAHW,MAAM,GACL,YAAY,CAiCvB;IAED;;;;OAIG;IACH,6BAHc,eAAe,KACjB,YAAY,CAiBvB;IA1QD;;;OAGG;IACH,uBAEC;IAVD,kBAEC;IAUD;;;OAGG;IACH,iBAFU,eAAe,EAAE,CAEf;IAmBZ;;;;OAIG;IACH,YAHW,YAAY,GACV,IAAI,CAwBhB;IAED;;;OAGG;IACH,SAFY,YAAY,CAUvB;IAED;;;;;;;;OAQG;IACH,kBAJa,MAAM,CA+BlB;IAED;;;;;;OAMG;IACH,QAFa,IAAI,CAoChB;IAED,4BAYC;IAqGD;;;;OAIG;IACH,gBAHW,MAAM,GACJ,OAAO,CAKnB;IAGD;;;;;OAKG;IACH,gBAJW,MAAM,GACL,eAAe,CAa1B;IA8GL;;;OAGG;IACH,mBAFU,OAAO,CAEc;;CAN9B;2BArb0B,iBAAiB;gCAEZ,sBAAsB"}
+{"version":3,"file":"WebGPUStruct.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shader/type/WebGPUStruct.js"],"names":[],"mappings":"AA2BA;;;;GAIG;AACH;IAmNI;;;;;;;;;;;;;;OAcG;IACH,8BAHW,MAAM,GACL,YAAY,CAiCvB;IAED;;;;OAIG;IACH,6BAHc,eAAe,KACjB,YAAY,CAiBvB;IA5QD;;;OAGG;IACH,uBAEC;IAVD,kBAEC;IAUD;;;OAGG;IACH,iBAFU,eAAe,EAAE,CAEf;IAmBZ;;;;OAIG;IACH,YAHW,YAAY,GACV,IAAI,CAwBhB;IAED;;;OAGG;IACH,SAFY,YAAY,CAUvB;IAED;;;;;;;;OAQG;IACH,kBAJa,MAAM,CA+BlB;IAED;;;;;;OAMG;IACH,QAFa,IAAI,CAoChB;IAED,4BAYC;IAuGD;;;;OAIG;IACH,gBAHW,MAAM,GACJ,OAAO,CAKnB;IAGD;;;;;OAKG;IACH,gBAJW,MAAM,GACL,eAAe,CAa1B;IA8GL;;;OAGG;IACH,mBAFU,OAAO,CAEc;;CAN9B;2BAvb0B,iBAAiB;gCAEZ,sBAAsB"}

package/src/shade/renderer/shader/type/WebGPUStruct.js

@@ -1,6 +1,7 @@
 import { assert } from "../../../../core/assert.js";
 import LineBuilder from "../../../../core/codegen/LineBuilder.js";
-import { combine_hash } from "../../../../core/collection/array/combine_hash.js";
+import { hash_mix2 } from "../../../../core/math/hash/hash_mix2.js";
+import { hash_mix3 } from "../../../../core/math/hash/hash_mix3.js";
 import { isArrayEqual } from "../../../../core/collection/array/isArrayEqual.js";
 import { round_up } from "../../../../core/math/round_up.js";
 import { computeStringHash } from "../../../../core/primitives/strings/computeStringHash.js";
@@ -210,11 +211,13 @@ export class WebGPUStruct extends WebGPUType {
     }
 
     hash() {
-        return combine_hash(
-            computeStringHash(this.name),
-            this.#size,
-            this.#align,
-            this.fields.length,
+        return hash_mix2(
+            hash_mix3(
+                computeStringHash(this.name),
+                this.#size,
+                this.#align
+            ),
+            this.fields.length
         );
     }
 

package/src/shade/renderer/texture/ShadeTexture.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ShadeTexture.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/texture/ShadeTexture.js"],"names":[],"mappings":"AAcA;IA4GI;;;;OAIG;IACH,oBAHW,UAAU,GACR,YAAY,CAiBxB;IA/HD,cAAW;IAOX;;;OAGG;IACH,8BAEC;IAED;;;;;;;;;;;;;OAaG;IACH,aAFU,UAAU,GAAC,MAAM,GAAC,IAAI,CAEb;IAEnB;;;OAGG;IACH,yDAEC;IAED;;;;OAIG;IACH,cAHW,MAAM,GAAC,iBAAiB,GACtB,IAAI,CAIhB;IAED;;;;OAIG;IACH,gBAHW,MAAM,GAAC,iBAAiB,GACtB,IAAI,CAIhB;IAED;;;;OAIG;IACH,gBAHW,MAAM,GAAC,iBAAiB,SACxB,OAAO,QAQjB;IAED;;;;OAIG;IACH,cAHW,MAAM,GAAC,iBAAiB,GACtB,OAAO,CAInB;IAED,cAAsB;IAEtB,kBAAqC;IACrC,kBAAqC;IAErC;;;OAGG;IACH,cAFU,iBAAiB,CAEa;IAExC,cAA+B;IAC/B,cAA+B;IAC/B,cAA+B;IAE/B;;;OAGG;IACH,YAFU,MAAM,CAED;IAEf;;;;OAIG;IACH,wBAFU,iBAAiB,GAAC,MAAM,CAEgB;IAwBlD,eAWC;IAED;;;;OAIG;IACH,cAHW,YAAY,GACV,OAAO,CAYnB;;CACJ;yBArKY,OAAO,wBAAwB,EAAE,UAAU;yBAC3C,OAAO,iBAAiB,EAAE,UAAU;kCANf,wBAAwB;kCACxB,wBAAwB"}
+{"version":3,"file":"ShadeTexture.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/texture/ShadeTexture.js"],"names":[],"mappings":"AAeA;IA4GI;;;;OAIG;IACH,oBAHW,UAAU,GACR,YAAY,CAiBxB;IA/HD,cAAW;IAOX;;;OAGG;IACH,8BAEC;IAED;;;;;;;;;;;;;OAaG;IACH,aAFU,UAAU,GAAC,MAAM,GAAC,IAAI,CAEb;IAEnB;;;OAGG;IACH,yDAEC;IAED;;;;OAIG;IACH,cAHW,MAAM,GAAC,iBAAiB,GACtB,IAAI,CAIhB;IAED;;;;OAIG;IACH,gBAHW,MAAM,GAAC,iBAAiB,GACtB,IAAI,CAIhB;IAED;;;;OAIG;IACH,gBAHW,MAAM,GAAC,iBAAiB,SACxB,OAAO,QAQjB;IAED;;;;OAIG;IACH,cAHW,MAAM,GAAC,iBAAiB,GACtB,OAAO,CAInB;IAED,cAAsB;IAEtB,kBAAqC;IACrC,kBAAqC;IAErC;;;OAGG;IACH,cAFU,iBAAiB,CAEa;IAExC,cAA+B;IAC/B,cAA+B;IAC/B,cAA+B;IAE/B;;;OAGG;IACH,YAFU,MAAM,CAED;IAEf;;;;OAIG;IACH,wBAFU,iBAAiB,GAAC,MAAM,CAEgB;IAwBlD,eAiBC;IAED;;;;OAIG;IACH,cAHW,YAAY,GACV,OAAO,CAYnB;;CACJ;yBA3KY,OAAO,wBAAwB,EAAE,UAAU;yBAC3C,OAAO,iBAAiB,EAAE,UAAU;kCANf,wBAAwB;kCACxB,wBAAwB"}

package/src/shade/renderer/texture/ShadeTexture.js

@@ -1,5 +1,6 @@
 import { assert } from "../../../core/assert.js";
-import { combine_hash } from "../../../core/collection/array/combine_hash.js";
+import { hash_mix2 } from "../../../core/math/hash/hash_mix2.js";
+import { hash_mix3 } from "../../../core/math/hash/hash_mix3.js";
 import { optional_hash } from "../../../core/model/object/optional_hash.js";
 import { ShadeTextureFlags } from "./ShadeTextureFlags.js";
 import { TextureFilterType } from "./TextureFilterType.js";
@@ -143,15 +144,21 @@ export class ShadeTexture {
     }
 
     hash() {
-        return combine_hash(
-            optional_hash(this.#image),
-            this.flags,
-            this.minFilter,
-            this.magFilter,
-            this.mipmapFilter,
-            this.wrapS,
-            this.wrapT,
-            this.wrapR,
+        return hash_mix2(
+            hash_mix3(
+                hash_mix3(
+                    hash_mix3(
+                        optional_hash(this.#image),
+                        this.flags,
+                        this.minFilter
+                    ),
+                    this.magFilter,
+                    this.mipmapFilter
+                ),
+                this.wrapS,
+                this.wrapT
+            ),
+            this.wrapR
         );
     }
 

package/src/shade/renderer/texture/mipmaps/WebGPUMipmapGenerator.js

@@ -1,7 +1,7 @@
 import { assert } from "../../../../core/assert.js";
 import { BinaryBuffer } from "../../../../core/binary/BinaryBuffer.js";
 import { platform_compute_endianness } from "../../../../core/binary/platform_compute_endianness.js";
-import { combine_hash } from "../../../../core/collection/array/combine_hash.js";
+import { hash_mix2 } from "../../../../core/math/hash/hash_mix2.js";
 import { HashMap } from "../../../../core/collection/map/HashMap.js";
 import { Deque } from "../../../../core/collection/queue/Deque.js";
 import { round_up } from "../../../../core/math/round_up.js";
@@ -69,7 +69,7 @@ class MipmapShaderKey {
      * @return {number}
      */
     hash() {
-        return combine_hash(
+        return hash_mix2(
             computeStringHash(this.format),
             this.filter,
         )

package/src/shade/renderer/water/surface/chunk_water_surface_sample.d.ts

@@ -1,8 +1,8 @@
 /**
- * Most particle entries one point reads, over every level. Where a point would read more than
- * WATER_PARTICLE_CELL_SHARE, the bin pass thins its cells to about that many between them, the same packets in every
- * cell they reach, and where whole fronts would still crowd it past this, its cells keep no more than their part of
- * it. So a point reads all of its cells, short of a cell only one front reaches (~40 entries at most).
+ * Most particle entries one point reads, over every level. A front's run of particles in a cell is one entry, so a
+ * point reads about one a front that reaches it; where it would read more than WATER_PARTICLE_CROWD_KEEP, the keep
+ * pass dooms the flattest runs in its cells, which fade out while what is left of the budget still draws them, and
+ * cuts, whole, the fronts the budget cannot hold.
  */
 export const WATER_PARTICLE_GATHER_BUDGET: 64;
 /**

package/src/shade/renderer/water/surface/chunk_water_surface_sample.js

@@ -5,10 +5,10 @@ import { chunk_water_spectrum } from "./spectrum/chunk_water_spectrum.js";
 import { chunk_water_particle } from "./particles/chunk_water_particle.js";
 
 /**
- * Most particle entries one point reads, over every level. Where a point would read more than
- * WATER_PARTICLE_CELL_SHARE, the bin pass thins its cells to about that many between them, the same packets in every
- * cell they reach, and where whole fronts would still crowd it past this, its cells keep no more than their part of
- * it. So a point reads all of its cells, short of a cell only one front reaches (~40 entries at most).
+ * Most particle entries one point reads, over every level. A front's run of particles in a cell is one entry, so a
+ * point reads about one a front that reaches it; where it would read more than WATER_PARTICLE_CROWD_KEEP, the keep
+ * pass dooms the flattest runs in its cells, which fade out while what is left of the budget still draws them, and
+ * cuts, whole, the fronts the budget cannot hold.
  */
 export const WATER_PARTICLE_GATHER_BUDGET = 64;
 
@@ -133,8 +133,8 @@ fn water_surface_sum(wave: u32, p: vec2<f32>, footprint: f32) -> WaterSurfaceSum
             visited++;
             let entry = water_particle_entries[i];
             if (entry.key != key || any(entry.cell != cell)) { continue; }
-            let field = water_particle_field(p - entry.position, entry.angle, entry.amplitude, entry.radius, entry.half_length,
-                entry.dispersion, entry.distance, entry.phase);
+            let field = water_particle_run_field(p - entry.position, entry.angle, entry.amplitude, entry.radius, entry.half_length,
+                entry.dispersion, entry.distance, entry.phase, entry.run);
             // a packet is geometry while its wavelength spans eight samples, fading out by four
             let f = clamp(log2(entry.radius / (2.0 * footprint)), 0.0, 1.0);
             let rough = sqrt(1.0 - f * f);

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

@@ -1 +1 @@
-{"version":3,"file":"GPUWaterParticles.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/water/surface/particles/GPUWaterParticles.js"],"names":[],"mappings":"AAkCA,kHAAkH;AAClH,+CAAgD;AAUhD;;;;GAIG;AACH;IA0BI,uFAAuF;IACvF,yBAAuC;IACvC,kGAAkG;IAClG,yBAAuC;IACvC,uGAAuG;IACvG,6BAA+C;IAC/C,mEAAmE;IACnE,2BAAyD;IACzD,uBAAyC;IAEzC;;;;;;;;;;;OAWG;IACH,qCALW,MAAM,QACN,MAAM,UACK,OAAO,8CAA8C,EAAE,sBAAsB,KAAE,IAAI,GAAC,IAAI,CA6D7G;IAED,gBAgBC;IAED;;;;;;;;;;;;;;;OAeG;IACH;QATyG,KAAK,EAAnG,OAAO,iEAAiE,EAAE,UAAU;QACpE,KAAK,EAArB,MAAM;QACa,KAAK;QACL,QAAQ;QACR,SAAS;QACT,QAAQ;QACX,YAAY,EAA5B,MAAM;QACU,EAAE,EAAlB,MAAM;aAmGhB;;CACJ"}
+{"version":3,"file":"GPUWaterParticles.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/water/surface/particles/GPUWaterParticles.js"],"names":[],"mappings":"AAkCA,kHAAkH;AAClH,+CAAgD;AAUhD;;;;GAIG;AACH;IAwBI,uFAAuF;IACvF,yBAAuC;IACvC,kGAAkG;IAClG,yBAAuC;IACvC,uGAAuG;IACvG,6BAA+C;IAC/C,mEAAmE;IACnE,2BAAyD;IACzD,uBAAyC;IAEzC;;;;;;;;;;;OAWG;IACH,qCALW,MAAM,QACN,MAAM,UACK,OAAO,8CAA8C,EAAE,sBAAsB,KAAE,IAAI,GAAC,IAAI,CA4D7G;IAED,gBAeC;IAED;;;;;;;;;;;;;;;OAeG;IACH;QATyG,KAAK,EAAnG,OAAO,iEAAiE,EAAE,UAAU;QACpE,KAAK,EAArB,MAAM;QACa,KAAK;QACL,QAAQ;QACR,SAAS;QACT,QAAQ;QACX,YAAY,EAA5B,MAAM;QACU,EAAE,EAAlB,MAAM;aA8FhB;;CACJ"}

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

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

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

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

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

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

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

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

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

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

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

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