@woosh/meep-engine 3.42.0 → 3.43.0

package/src/shade/renderer/volumetrics/shader_volumetrics_build_irradiance.js

@@ -0,0 +1,228 @@
+import { CAMERA_UNIFORM_STRUCT } from "../camera/CAMERA_UNIFORM_STRUCT.js";
+import { chunk_light_cluster_counts } from "../light/cluster/chunk_light_cluster_counts.js";
+import { chunk_light_cluster_metadata_by_position } from "../light/cluster/chunk_light_cluster_metadata_by_position.js";
+import { LIGHT_CLUSTER_LOOKUP_STRUCT } from "../light/cluster/shader_cluster_assign_lights.js";
+import { chunk_cluster_depth_from_z_slice } from "../light/cluster/chunk_cluster_depth_from_z_slice.js";
+import { chunk_camera_ray_from_uv } from "../shader/chunk/geometry/ray/chunk_camera_ray_from_uv.js";
+import { RAY_STRUCT } from "../shader/chunk/geometry/ray/RAY_STRUCT.js";
+import { chunk_stbn_sample_vec3 } from "../shader/chunk/noise/chunk_stbn_sample_vec3.js";
+import {
+    chunk_directional_lights_iteration_mask
+} from "../shader/chunk/light/io/chunk_directional_lights_iteration_mask.js";
+import {
+    chunk_get_directional_light_info_by_index
+} from "../shader/chunk/light/io/chunk_get_directional_light_info_by_index.js";
+import {
+    chunk_get_point_light_info_by_index
+} from "../shader/chunk/light/io/chunk_get_point_light_info_by_index.js";
+import { chunk_get_spot_light_info_by_index } from "../shader/chunk/light/io/chunk_get_spot_light_info_by_index.js";
+import {
+    METRO_L1_IRRADIANCE_STRUCT
+} from "../shader/chunk/spherical_harmonics/l1i/chunk_convert_to_irradiance_sh.js";
+import { chunk_texel_coordinate_to_uv } from "../shader/chunk/texture/chunk_texel_coordinate_to_uv.js";
+import { chunk_uv_to_texel_coordinate } from "../shader/chunk/texture/chunk_uv_to_texel_coordinate.js";
+import { CodeChunk } from "../shader/compiler/CodeChunk.js";
+import { ComputeShader } from "../shader/ComputeShader.js";
+import { ShaderResourceSetDescriptor } from "../shader/resource/ShaderResourceSetDescriptor.js";
+import { vec3f } from "../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUArray } from "../shader/type/WebGPUArray.js";
+import { chunk_shadowmap_get_light_visibility } from "../shadow/map/shader/chunk_shadowmap_get_light_visibility.js";
+import { SHADOWMAP_COMPARE_SAMPLER_DESCRIPTOR } from "../shadow/map/SHADOWMAP_COMPARE_SAMPLER_DESCRIPTOR.js";
+import { VIEW_UNIFORM_STRUCT } from "../view/VIEW_UNIFORM_STRUCT.js";
+import { chunk_volumetrics_irradiance_sh } from "./chunk_volumetrics_irradiance_sh.js";
+import { chunk_volumetrics_local_light_shadow } from "./chunk_volumetrics_local_light_shadow.js";
+import { chunk_camera_ray_planar_depth_scale } from "./chunk_camera_ray_planar_depth_scale.js";
+import { chunk_volumetrics_column_jitter } from "./chunk_volumetrics_column_jitter.js";
+import { VOLUMETRICS_METADATA_STRUCT } from "./VOLUMETRICS_METADATA_STRUCT.js";
+
+/**
+ * Workgroup shape of this pass, `[x, y, z]` in froxels, stated to the `@workgroup_size` below and
+ * read back out of it by the dispatch. Flat in z and 64 invocations, for the reasons the fog's
+ * lighting pass gives (`VOLUMETRICS_LIGHTING_WORKGROUP_RESOLUTION`): it walks the same light
+ * clusters, and those are farthest apart along depth.
+ *
+ * @type {number[]}
+ */
+export const VOLUMETRICS_IRRADIANCE_WORKGROUP_RESOLUTION = [8, 8, 1];
+
+const resources = new ShaderResourceSetDescriptor();
+
+// The froxel irradiance volume (chunk_volumetrics_irradiance_sh): luma SH2 in one, chroma in the .rg
+// of the other. rgba16float for both, because rg16float is not a storage format without
+// texture-formats-tier1. It starts from what the froxel GI stage (gi/) wrote to tGIY / tGICoCg.
+resources.createGroup()
+    .addUniform("volumetrics_metadata", VOLUMETRICS_METADATA_STRUCT)
+    .addUniform("camera", CAMERA_UNIFORM_STRUCT)
+    .addUniform("view", VIEW_UNIFORM_STRUCT)
+    .addTexture("tSTBN_vec3", "unfilterable-float", "3d")
+    .addTexture("tGIY", "float", "3d")
+    .addTexture("tGICoCg", "float", "3d")
+    .addStorageTexture("tIrradianceY", "rgba16float", "3d", "write-only")
+    .addStorageTexture("tIrradianceCoCg", "rgba16float", "3d", "write-only");
+
+// Lighting information
+resources.createGroup()
+    .addStorageBuffer("light_data", WebGPUArray.u32)
+    // clusters
+    .addUniform("cluster_parameters", vec3f)
+    .addStorageBuffer("cluster_lookup", LIGHT_CLUSTER_LOOKUP_STRUCT)
+    .addStorageBuffer("cluster_data", WebGPUArray.u32)
+    // shadows
+    .addTexture("shadowmapAtlas", "depth")
+    .addSampler("sCompareLinear", "comparison", SHADOWMAP_COMPARE_SAMPLER_DESCRIPTOR);
+
+const body = CodeChunk.from(
+    //language=WGSL
+    `
+@compute @workgroup_size(${VOLUMETRICS_IRRADIANCE_WORKGROUP_RESOLUTION.join(",")})
+fn main(
+    @builtin(global_invocation_id) voxel : vec3<u32>
+){
+    let resolution = textureDimensions(tIrradianceY);
+
+    if (any(voxel >= resolution)) {
+        return;
+    }
+
+    // The fog lighting pass's sample, taken the same way (shader_volumetrics_build_lighting, where
+    // the irradiance was written until it had a pass of its own): one point per froxel per frame,
+    // jittered across the slab in depth by the column jitter and the blue noise, and in xy by the
+    // blue noise. Never a fixed point. A particle spans many froxels and reads them trilinearly, and
+    // a lattice of samples that never moves shows on it as seams wherever neighbouring texels
+    // disagree — beside a light, along a shadow edge. Moved every frame, the lattice is resolved by
+    // the main TAA, which the particles are drawn ahead of.
+    let near_far = camera.clip_near_far;
+    let curve = volumetrics_metadata.froxel_cluster_parameters;
+
+    let z_jitter = volumetrics_column_jitter(voxel.xy, view.frame_index);
+
+    let z0 = max(near_far.x, cluster_depth_from_z_slice(f32(voxel.z) + z_jitter, curve, f32(resolution.z)));
+    let z1 = min(near_far.y, cluster_depth_from_z_slice(f32(voxel.z + 1u) + z_jitter, curve, f32(resolution.z)));
+
+    // the lighting pass's offset and temporal axis, so the two passes ask about the same point
+    const STBN_DECORRELATION_OFFSET = vec2<u32>(37u, 71u);
+
+    let noise = stbn_sample_vec3(vec3(voxel.xy + STBN_DECORRELATION_OFFSET, view.frame_index + voxel.z));
+
+    // interpolate the cubes, then take the cube root: uniform in world-space volume across the slab
+    let view_depth = pow(mix(z0 * z0 * z0, z1 * z1 * z1, noise.z), 0.333333);
+
+    let tile_uv = saturate(texel_coordinate_to_uv(vec2<f32>(voxel.xy) + (noise.xy - 0.5), resolution.xy));
+    let view_ray = camera_ray_from_uv(tile_uv, camera);
+
+    // view_depth is planar, so step the ray by the planar-to-distance scale
+    let position_ws = view_ray.origin
+        + view_ray.direction * (view_depth * camera_ray_planar_depth_scale(view_ray.direction, camera));
+
+    let view_pixel_coord = uv_to_texel_coordinate(tile_uv, vec2(view.width, view.height));
+
+    var irradiance: ${METRO_L1_IRRADIANCE_STRUCT.wgsl_ref};
+
+    // Each light as the surfaces around the froxel receive it: its colour and its shadow, and no
+    // medium on the way in. The deferred and forward paths light meshes by exactly this, and a lit
+    // particle beside a lit log has to agree with it — the fog is composited over both afterwards.
+
+    var directional_bits = directional_lights_iteration_mask(&light_data);
+    while (directional_bits != 0u) {
+        let directional_index = countTrailingZeros(directional_bits);
+        directional_bits &= ~(1u << directional_index);
+
+        let sun = get_directional_light_info_by_index(&light_data, directional_index);
+
+        let shadow_term = shadowmap_get_directional_light_visibility(
+            &light_data,
+            directional_index,
+            position_ws,
+            // toward-camera, the deferred cascade-blend convention; view_ray runs camera->scene
+            -view_ray.direction,
+            sun.direction
+        );
+
+        irradiance = volumetrics_irradiance_sh_add(irradiance, shadow_term * sun.color, sun.direction);
+    }
+
+    let cluster_metadata = light_cluster_metadata_by_position(
+        view_pixel_coord,
+        view_depth,
+        vec2(view.width, view.height)
+    );
+
+    let cluster_offset = cluster_metadata.offset;
+    let point_count = light_cluster_count_point(cluster_metadata.counts);
+    let spot_count = light_cluster_count_spot(cluster_metadata.counts);
+
+    for (var j = 0u; j < point_count; j++) {
+        let light_index = cluster_data[cluster_offset + j];
+        let direct_light = get_point_light_info_by_index(&light_data, light_index, position_ws);
+
+        if (all(direct_light.color == vec3(0.0))) {
+            continue;
+        }
+
+        let shadow_term = volumetrics_point_light_shadow(&light_data, light_index, position_ws);
+
+        irradiance = volumetrics_irradiance_sh_add(irradiance, shadow_term * direct_light.color, direct_light.direction);
+    }
+
+    for (var k = 0u; k < spot_count; k++) {
+        let light_index = cluster_data[cluster_offset + point_count + k];
+        let direct_light = get_spot_light_info_by_index(&light_data, light_index, position_ws);
+
+        if (all(direct_light.color == vec3(0.0))) {
+            continue;
+        }
+
+        let shadow_term = volumetrics_spot_light_shadow(&light_data, light_index, position_ws);
+
+        irradiance = volumetrics_irradiance_sh_add(irradiance, shadow_term * direct_light.color, direct_light.direction);
+    }
+
+    // What the renderer's indirect lighting gives this froxel, in the same encoding; the lights add
+    // to it. Written by the froxel GI module the mode selects, which is all this pass knows of GI.
+    irradiance.Y += textureLoad(tGIY, voxel, 0);
+    irradiance.CoCg += textureLoad(tGICoCg, voxel, 0).xy;
+
+    // nothing filters this volume, so nothing downstream would stop an Inf or a NaN here
+    let stored = volumetrics_irradiance_sh_storable(irradiance);
+
+    textureStore(tIrradianceY, voxel, stored.Y);
+    textureStore(tIrradianceCoCg, voxel, vec4<f32>(stored.CoCg, 0.0, 0.0));
+}
+    `, [
+        METRO_L1_IRRADIANCE_STRUCT.declaration_chunk,
+        RAY_STRUCT.declaration_chunk,
+        chunk_volumetrics_column_jitter,
+        chunk_cluster_depth_from_z_slice,
+        chunk_stbn_sample_vec3,
+        chunk_texel_coordinate_to_uv,
+        chunk_uv_to_texel_coordinate,
+        chunk_camera_ray_from_uv,
+        chunk_camera_ray_planar_depth_scale,
+
+        chunk_light_cluster_metadata_by_position,
+        chunk_light_cluster_counts,
+        chunk_directional_lights_iteration_mask,
+        chunk_get_directional_light_info_by_index,
+        chunk_get_point_light_info_by_index,
+        chunk_get_spot_light_info_by_index,
+        chunk_shadowmap_get_light_visibility,
+        chunk_volumetrics_local_light_shadow,
+        chunk_volumetrics_irradiance_sh,
+    ]
+);
+
+/**
+ * The froxel irradiance volume (`chunk_volumetrics_irradiance_sh`): what a lit particle standing in a
+ * froxel is lit by. Starts from the froxel GI stage's volume and adds every directional, point and
+ * spot light with its shadow, at a point jittered through the froxel every frame.
+ *
+ * Its own pass, not a by-product of the fog's lighting pass: particle lighting needs no medium, so it
+ * runs whether or not the scene has any fog, and the frame graph culls it when nothing reads it.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_volumetrics_build_irradiance = ComputeShader.from({
+    label: "Volumetrics / build irradiance",
+    resources,
+    body,
+});

package/src/shade/renderer/volumetrics/shader_volumetrics_build_lighting.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_volumetrics_build_lighting.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/volumetrics/shader_volumetrics_build_lighting.js"],"names":[],"mappings":"AAiDA;;;;;;;;;;;;;;;GAeG;AACH,wDAFU,MAAM,EAAE,CAEiD;AAkanE,8DAIE;8BAnd4B,4BAA4B"}
+{"version":3,"file":"shader_volumetrics_build_lighting.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/volumetrics/shader_volumetrics_build_lighting.js"],"names":[],"mappings":"AA6CA;;;;;;;;;;;;;;;GAeG;AACH,wDAFU,MAAM,EAAE,CAEiD;AAiXnE,8DAIE;8BA9Z4B,4BAA4B"}

package/src/shade/renderer/volumetrics/shader_volumetrics_build_lighting.js

@@ -41,10 +41,6 @@ import {
 import { VOLUMETRICS_SUN_SHADOW_CASCADE_COUNT } from "./VOLUMETRICS_SUN_SHADOW_RESOLUTION.js";
 import { chunk_volumetrics_column_jitter } from "./chunk_volumetrics_column_jitter.js";
 import { chunk_volumetrics_local_light_shadow } from "./chunk_volumetrics_local_light_shadow.js";
-import { chunk_volumetrics_irradiance_sh } from "./chunk_volumetrics_irradiance_sh.js";
-import {
-    METRO_L1_IRRADIANCE_STRUCT
-} from "../shader/chunk/spherical_harmonics/l1i/chunk_convert_to_irradiance_sh.js";
 import { VOLUMETRICS_METADATA_STRUCT } from "./VOLUMETRICS_METADATA_STRUCT.js";
 
 /**
@@ -87,14 +83,6 @@ for (let cascade = 0; cascade < VOLUMETRICS_SUN_SHADOW_CASCADE_COUNT; cascade++)
 
 primary_group.addStorageTexture("tLighting", "rgba16float", "3d", "write-only")
 
-// The froxel irradiance volume (chunk_volumetrics_irradiance_sh): luma SH2 in one, chroma in the
-// .rg of the other. rgba16float for both, because rg16float is not a storage format without
-// texture-formats-tier1. It is what the froxel GI stage (gi/) wrote to tGIY / tGICoCg, plus the lights.
-primary_group.addTexture("tGIY", "float", "3d")
-primary_group.addTexture("tGICoCg", "float", "3d")
-primary_group.addStorageTexture("tIrradianceY", "rgba16float", "3d", "write-only")
-primary_group.addStorageTexture("tIrradianceCoCg", "rgba16float", "3d", "write-only")
-
 // Lighting information
 resources.createGroup()
 
@@ -144,11 +132,6 @@ fn main(
     var inScatteringSum = vec3<f32>(0.0);
     var extinctionSum = 0.0;
 
-    // What a transparent surface at the sample receives from the same lights: their shadowed
-    // colour, attenuated by the medium toward each light, before any scattering by it.
-    var irradianceSum: ${METRO_L1_IRRADIANCE_STRUCT.wgsl_ref};
-
-
     // One sample per froxel. The 0.95-blend TAA downstream is a ~39-effective-sample temporal
     // integrator; supersampling here as well spends N times this pass removing variance that filter
     // removes anyway — and spends it at the Monte Carlo rate, because the samples were independent
@@ -313,15 +296,6 @@ fn main(
             );
 
             inScatteringSum += shadow_term * ms * transmittance_atmospheric * sun.color;
-
-            // No atmospheric transmittance: that is the air's, and a surface in the volume is lit
-            // the way the surfaces around it are — the deferred and forward paths light meshes by
-            // sun.color as it stands, and a lit particle beside a lit log has to agree with it.
-            irradianceSum = volumetrics_irradiance_sh_add(
-                irradianceSum,
-                shadow_term * exp(-optical_depth) * sun.color,
-                sun.direction
-            );
         }
 
         // Local lights
@@ -374,12 +348,6 @@ fn main(
             let shadow_term = volumetrics_point_light_shadow(&light_data, light_index, position_ws);
 
             inScatteringSum += shadow_term * ms * direct_light.color;
-
-            irradianceSum = volumetrics_irradiance_sh_add(
-                irradianceSum,
-                shadow_term * exp(-optical_depth) * direct_light.color,
-                direct_light.direction
-            );
         }
 
         for (var k = 0u; k < spot_count; k++) {
@@ -415,12 +383,6 @@ fn main(
             let shadow_term = volumetrics_spot_light_shadow(&light_data, light_index, position_ws);
 
             inScatteringSum += shadow_term * ms * direct_light.color;
-
-            irradianceSum = volumetrics_irradiance_sh_add(
-                irradianceSum,
-                shadow_term * exp(-optical_depth) * direct_light.color,
-                direct_light.direction
-            );
         }
     }
 
@@ -435,20 +397,6 @@ fn main(
     let extinction = extinctionSum / f32(SAMPLE_COUNT);
 
     textureStore(tLighting, voxel_coord, vec4<f32>(inScattering, extinction));
-
-    irradianceSum.Y /= f32(SAMPLE_COUNT);
-    irradianceSum.CoCg /= f32(SAMPLE_COUNT);
-
-    // What the renderer's indirect lighting gives this froxel, in the same encoding; the lights add
-    // to it. Written by the froxel GI module the mode selects, which is all this pass knows of GI.
-    irradianceSum.Y += textureLoad(tGIY, voxel_coord, 0);
-    irradianceSum.CoCg += textureLoad(tGICoCg, voxel_coord, 0).xy;
-
-    // nothing TAA-filters this volume, so nothing downstream would stop an Inf or a NaN here
-    let irradiance = volumetrics_irradiance_sh_storable(irradianceSum);
-
-    textureStore(tIrradianceY, voxel_coord, irradiance.Y);
-    textureStore(tIrradianceCoCg, voxel_coord, vec4<f32>(irradiance.CoCg, 0.0, 0.0));
 }
     `, [
         chunk_cluster_depth_from_z_slice,
@@ -469,7 +417,6 @@ fn main(
         chunk_get_spot_light_info_by_index,
         chunk_shadowmap_get_light_visibility,
         chunk_volumetrics_local_light_shadow,
-        chunk_volumetrics_irradiance_sh,
         chunk_sky_lut_compute_uv,
 
         RAY_STRUCT.declaration_chunk,

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

@@ -1,7 +1,8 @@
 /**
- * Most particle entries one point reads, over every level. The bin pass thins a crowded cell to about
- * WATER_PARTICLE_CELL_SHARE packets, the same ones in every cell they reach, so a point reads all of its cells
- * unless several levels are crowded there at once.
+ * 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).
  */
 export const WATER_PARTICLE_GATHER_BUDGET: 64;
 /**

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

@@ -1 +1 @@
-{"version":3,"file":"chunk_water_surface_sample.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/water/surface/chunk_water_surface_sample.js"],"names":[],"mappings":"AAMA;;;;GAIG;AACH,8CAA+C;AAE/C;;;;;;;;;;;;GAYG;AACH,yCAFU,SAAS,CAgMyC;0BAxNlC,oCAAoC"}
+{"version":3,"file":"chunk_water_surface_sample.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/water/surface/chunk_water_surface_sample.js"],"names":[],"mappings":"AAMA;;;;;GAKG;AACH,8CAA+C;AAE/C;;;;;;;;;;;;GAYG;AACH,yCAFU,SAAS,CAyMyC;0BAlOlC,oCAAoC"}

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

@@ -5,9 +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. The bin pass thins a crowded cell to about
- * WATER_PARTICLE_CELL_SHARE packets, the same ones in every cell they reach, so a point reads all of its cells
- * unless several levels are crowded there at once.
+ * 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).
  */
 export const WATER_PARTICLE_GATHER_BUDGET = 64;
 
@@ -113,14 +114,17 @@ fn water_surface_sum(wave: u32, p: vec2<f32>, footprint: f32) -> WaterSurfaceSum
     }
     let table = water_particle_offsets.count;
     var visited = 0u;
-    var particle_variance = 0.0;
+    // the slope of what the footprint cannot draw of the packets and the same a quarter carrier cycle on, summed as the
+    // surface sums them, so a front's packets roughen it alike however many they are
+    var unresolved = vec2<f32>(0.0);
+    var quadrature = vec2<f32>(0.0);
     // coarsest first: the budget goes to packets the footprint can draw before those it can only roughen
     for (var from_top = 0u; from_top < WATER_PARTICLE_LEVELS && table != 0u; from_top++) {
         let level = WATER_PARTICLE_LEVELS - 1u - from_top;
         if ((levels & (1u << level)) == 0u) { continue; }
         let size = water_particle_cell_size(level);
         let cell = vec2<i32>(floor(p / size));
-        let key = (wave << 4u) | level;
+        let key = water_particle_key(wave, level);
         let bucket = water_particle_bucket(wave, level, cell, table);
         var start = 0u;
         if (bucket > 0u) { start = water_particle_offsets.elements[bucket - 1u]; }
@@ -129,16 +133,22 @@ 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.width, entry.phase);
+            let field = water_particle_field(p - entry.position, entry.angle, entry.amplitude, entry.radius, entry.half_length,
+                entry.dispersion, entry.distance, entry.phase);
             // 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);
-            particle_variance += (1.0 - f * f) * dot(field.slope, field.slope);
+            let rough = sqrt(1.0 - f * f);
+            unresolved += rough * field.slope;
+            quadrature += rough * field.displacement_gradient;
             sum.height += f * field.height;
             sum.slope += f * field.slope;
             sum.displacement += f * field.displacement;
             sum.jacobian += f * field.jacobian;
         }
     }
+    // the slope's mean square over a carrier cycle, as the bands' variance is (Bruneton, Neyret & Holzschuch 2010): at a
+    // point the slope alone swings from nothing to twice it with the carrier
+    let particle_variance = 0.5 * (dot(unresolved, unresolved) + dot(quadrature, quadrature));
     sum.variance = variance + particle_variance;
     sum.particle_variance = particle_variance;
     return sum;

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":"AAuBA,kHAAkH;AAClH,+CAAgD;AAUhD;;;;GAIG;AACH;IAkBI,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,CA4C7G;IAED,gBAWC;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;aA6EhB;;CACJ"}
+{"version":3,"file":"GPUWaterParticles.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/water/surface/particles/GPUWaterParticles.js"],"names":[],"mappings":"AA+BA,kHAAkH;AAClH,+CAAgD;AAUhD;;;;GAIG;AACH;IAuBI,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,CAuD7G;IAED,gBAcC;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;aAgGhB;;CACJ"}

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

@@ -10,15 +10,23 @@ import { WATER_PARTICLE_ENTRY_STRUCT, WATER_PARTICLE_STRUCT } from "./WATER_PART
 import {
     shader_water_particles_bin,
     shader_water_particles_bounds,
+    shader_water_particles_clear,
     shader_water_particles_emit,
     shader_water_particles_finalize,
+    shader_water_particles_fronts,
+    shader_water_particles_groups,
+    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,
     shader_water_particles_weigh,
-    WATER_PARTICLE_CORNERS
+    WATER_PARTICLE_CORNERS,
+    WATER_PARTICLE_CROWD_WORDS,
+    WATER_PARTICLE_NEST_WORDS
 } from "./shader_water_particles.js";
 
 /** The longest step a particle takes in one frame, seconds: a stalled tab does not fling fronts across a lake. */
@@ -45,10 +53,15 @@ export class GPUWaterParticles {
     #parity = 0;
     #particles = [];
     #children = null;
+    #images = null;
+    #fronts = null;
+    #runs = null;
+    #draw = null;
     #buckets = null;
     #slots = null;
     #bucket_amplitude = null;
     #bucket_weight = null;
+    #bucket_nest = null;
     #visible = null;
     #staging = null;
     #entries = null;
@@ -90,15 +103,26 @@ export class GPUWaterParticles {
             const array_size = 16 + capacity * WATER_PARTICLE_STRUCT.size;
             this.#particles = [buffer('a', array_size), buffer('b', array_size)];
             this.#children = buffer('children', 16 + capacity * 4);
+            // per particle the mirror image the step left beside it at the outline
+            this.#images = buffer('images', capacity * WATER_PARTICLE_STRUCT.size);
+            // per particle 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.#runs = buffer('runs', capacity * 8);
+            this.#draw = buffer('draw', capacity * 8);
             this.#buckets = buffer('buckets', 16 + this.#table_limit * 4);
             this.#slots = buffer('slots', capacity * WATER_PARTICLE_CORNERS * 4);
             this.#bucket_amplitude = buffer('bucket amplitude', this.#table_limit * 4);
-            this.#bucket_weight = buffer('bucket weight', 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);
+            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);
-            this.#commands = [0, 1].map(i => device.createBuffer({ label: `Water / particles command ${i}`,
+            // the particles' this frame and next, and the clear of the frame's table
+            this.#commands = [0, 1, 2].map(i => device.createBuffer({ label: `Water / particles command ${i}`,
                 size: INDIRECT_COMPUTE_COMMAND_DESCRIPTOR.size, usage: INDIRECT_COMPUTE_COMMAND_DESCRIPTOR.usage }));
             this.#rows = 0;
             this.#parity = 0;
@@ -121,11 +145,14 @@ export class GPUWaterParticles {
     }
 
     dispose() {
-        for (const buffer of [...this.#particles, this.#children, this.#buckets, this.#slots, this.#bucket_amplitude,
-            this.#bucket_weight, this.#visible, this.#staging, this.#entries, this.#body_bounds, ...(this.#commands ?? [])]) { buffer?.destroy(); }
+        for (const buffer of [...this.#particles, this.#children, this.#images, this.#fronts, this.#runs, this.#draw, this.#buckets, this.#slots,
+            this.#bucket_amplitude, this.#bucket_weight, this.#bucket_nest, this.#visible, this.#staging, this.#entries, this.#body_bounds, ...(this.#commands ?? [])]) {
+            buffer?.destroy();
+        }
         this.#particles = [];
-        this.#children = this.#buckets = this.#slots = this.#bucket_amplitude = this.#staging = this.#entries = null;
-        this.#bucket_weight = this.#visible = null;
+        this.#children = this.#images = this.#buckets = this.#slots = this.#bucket_amplitude = this.#staging = this.#entries = null;
+        this.#fronts = this.#runs = this.#draw = null;
+        this.#bucket_weight = this.#bucket_nest = this.#visible = null;
         this.#body_bounds = null;
         this.#commands = null;
         this.#device = null;
@@ -158,10 +185,11 @@ export class GPUWaterParticles {
         // a frame that does not step bins the particles where they are
         const next = stepping ? this.#particles[1 - this.#parity] : current;
         if (stepping) { this.#parity = 1 - this.#parity; }
-        const [command_current, command_next] = this.#commands;
+        const [command_current, command_next, command_table] = this.#commands;
         const geometries = scene.geometries;
         let children = graph_import_buffer(graph, this.#children, 'Water / particle children');
         let buckets = graph_import_buffer(graph, this.#buckets, 'Water / particle buckets');
+        let fronts = graph_import_buffer(graph, this.#fronts, 'Water / particle fronts');
         const node = (name, execute, reads, writes) => {
             const data = {};
             const pass = graph.add(name, data, (d, resources, context) => execute(resources, context, d));
@@ -177,7 +205,7 @@ export class GPUWaterParticles {
                 encoder.copyBufferToBuffer(current, 0, this.#children, 0, 4);
                 build_indirect_compute_dispatch_command(64, encoder, current, 0, command_current, 0, true);
                 shader_water_particles_update.dispatchIndirect({ encoder, command: command_current, bindings: {
-                    frame: { dt: step, capacity }, particles: current, children: this.#children, activity,
+                    frame: { dt: step, capacity }, particles: current, children: this.#children, images: this.#images, activity,
                     scene_database: scene.scene_database_buffer, geometries: geometries.buffer_metadata,
                     blas_lookup: geometries.blas.buffer_metadata, blas_data: geometries.blas.buffer_data,
                     meshlet_metadata: geometries.meshlets.buffer_metadata, meshlet_data: geometries.meshlets.buffer_data,
@@ -188,41 +216,59 @@ export class GPUWaterParticles {
             // What they leave into the next array, then the frame's splashes after them.
             node('Water / particles split and emit', (resources, { encoder }) => {
                 shader_water_particles_split.dispatchIndirect({ encoder, command: command_current, bindings: {
-                    capacity, particles: current, children: this.#children, next } });
+                    capacity, particles: current, children: this.#children, images: this.#images, next } });
                 shader_water_particles_total.dispatch({ encoder, bindings: { capacity, children: this.#children, next } });
                 shader_water_particles_emit.dispatchIndirect({ encoder, command: commands, command_offset: emit_command,
                     bindings: { capacity, scene_database: scene.scene_database_buffer, emit_rows, steep, activity,
                         particle_bounds: this.#body_bounds, next } });
-                shader_water_particles_finalize.dispatch({ encoder, bindings: { limits: { capacity, table_limit }, next, offsets: this.#buckets } });
+                shader_water_particles_finalize.dispatch({ encoder, bindings: { limits: { capacity, table_limit }, next, offsets: this.#buckets,
+                    table_command: command_table } });
             }, { children }, {});
         }
 
-        // The frame's hash: how crowded each cell is, then each particle into the cells its support overlaps as far as
-        // its crowd leaves it drawn, offsets, entries in order.
-        buckets = node('Water / particles bin', (resources, { encoder }) => {
+        // 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 }) => {
             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 } });
+                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.clearBuffer(this.#buckets, 16, table_limit * 4);
-            encoder.clearBuffer(this.#bucket_amplitude);
-            encoder.clearBuffer(this.#bucket_weight);
+            encoder.copyBufferToBuffer(next, 0, this.#fronts, 0, 4);
+            shader_water_particles_fronts.dispatchIndirect({ encoder, command: command_next, bindings: { next, fronts: this.#fronts } });
+        }, {}, { fronts }).fronts;
+        fronts = graph_prefix_scan_csdldf({ graph, data: fronts, 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.#fronts, runs } });
+            shader_water_particles_groups.dispatchIndirect({ encoder, command: command_next, bindings: { next, fronts: this.#fronts, runs, draw } });
+            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, bucket_weight: this.#bucket_weight } });
+                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,
+                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 } });
             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, bucket_weight: this.#bucket_weight, visible: this.#visible } });
-        }, {}, { buckets }).buckets;
+                body_bounds: this.#body_bounds, draw, runs, visible: this.#visible } });
+        }, { fronts }, { buckets }).buckets;
         buckets = graph_prefix_scan_csdldf({ graph, data: buckets, element_max_count: table_limit });
         node('Water / particles order and bound', (resources, { encoder }) => {
-            const bindings = { next, offsets: this.#buckets, slots: this.#slots };
+            const bindings = { next, offsets: this.#buckets, slots: this.#slots, draw: this.#draw };
             shader_water_particles_scatter.dispatchIndirect({ encoder, command: command_next, bindings: { ...bindings,
                 visible: this.#visible, 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.#buckets, bucket_amplitude: this.#bucket_amplitude, body_bounds: this.#body_bounds } });
+                offsets: this.#buckets, bucket_amplitude: this.#bucket_amplitude, draw: this.#draw, body_bounds: this.#body_bounds } });
         }, { buckets }, {});
     }
 }

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,iDAeoB;AAEpB;;;;GAIG;AACH,uDAeyB;6BA/CI,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,iDAoBoB;AAEpB;;;;GAIG;AACH,uDAkByB;6BAvDI,sCAAsC"}