@woosh/meep-engine 3.42.0 → 3.44.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/chunk_water_transport.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_water_transport.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/water/chunk_water_transport.js"],"names":[],"mappings":"AAUA,0DAEG;AAEH,0DAeG;AAEH,8CAsBG;AAGH,mDAS6F;AAI7F,sDAmCoE;0BAxG1C,iCAAiC"}
+{"version":3,"file":"chunk_water_transport.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/water/chunk_water_transport.js"],"names":[],"mappings":"AAUA,0DAEG;AAEH,0DAeG;AAEH,8CAsBG;AAIH,mDAU6F;AAI7F,sDAmCoE;0BA1G1C,iCAAiC"}

package/src/shade/renderer/water/chunk_water_transport.js

@@ -53,15 +53,17 @@ fn water_transport(event: WaterEvent, original: vec3f, receiver: vec3f,
 }
 `);
 
-// One G-buffer texel in world space: its stored depth, texel-center position and face normal.
+// One G-buffer texel in world space: its stored depth, texel-center position, its triangle's face normal, which
+// is where the surface is, and the normal it was shaded with, which is what lit it.
 export const chunk_water_receiver_texel = CodeChunk.from(/* language=WGSL */ `
-struct WaterReceiverTexel { depth: f32, position: vec3f, normal: vec3f }
+struct WaterReceiverTexel { depth: f32, position: vec3f, face_normal: vec3f, shading_normal: vec3f }
 fn water_receiver_texel(depth: texture_2d<f32>, normals: texture_2d<u32>, coord: vec2i,
     inverse_projection: mat4x4f, inverse_view: mat4x4f) -> WaterReceiverTexel {
     let d = textureLoad(depth, coord, 0).r;
     let center = texel_coordinate_to_uv(vec2f(coord), textureDimensions(depth, 0));
     let position = inverse_view * vec4f(inv_project_position(vec3f(center, d), inverse_projection), 1.0);
-    return WaterReceiverTexel(d, position.xyz, decode_g_buffer_normal(textureLoad(normals, coord, 0).zw));
+    let encoded = textureLoad(normals, coord, 0);
+    return WaterReceiverTexel(d, position.xyz, decode_g_buffer_normal(encoded.zw), decode_g_buffer_normal(encoded.xy));
 }
 `, [chunk_decode_g_buffer_normal, chunk_inv_project_position, chunk_texel_coordinate_to_uv]);
 
@@ -92,8 +94,8 @@ fn water_receiver_radiance(scene: texture_2d<f32>, depth: texture_2d<f32>, norma
             let coord = clamp(base + vec2i(x,y), vec2i(0), size-1);
             let tap = water_receiver_texel(depth, normals, coord, inverse_projection, inverse_view);
             if (is_background(tap.depth) || (below_interface && dot(tap.position - surface, surface_normal) > WATER_LEVEL_TOLERANCE)
-                || dot(center.normal, tap.normal) < 0.95
-                || abs(dot(tap.position - center.position, center.normal)) > 0.02) { continue; }
+                || dot(center.face_normal, tap.face_normal) < 0.95
+                || abs(dot(tap.position - center.position, center.face_normal)) > 0.02) { continue; }
             let w = select(1.0-f.x, f.x, x == 1) * select(1.0-f.y, f.y, y == 1);
             color += w * textureLoad(scene, coord, 0).rgb;
             weight += w;

package/src/shade/renderer/water/medium/GPUWaterBodies.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUWaterBodies.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/water/medium/GPUWaterBodies.js"],"names":[],"mappings":"AAcA,4FAA4F;AAC5F;IACI;;;;;;OAMG;IACH;;;;;;;;QAFa;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAA;KAAC,CA8ClD;CACJ"}
+{"version":3,"file":"GPUWaterBodies.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/water/medium/GPUWaterBodies.js"],"names":[],"mappings":"AAkBA,4FAA4F;AAC5F;IACI;;;;;;OAMG;IACH;;;;;;;;QAFa;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAA;KAAC,CAgDlD;CACJ"}

package/src/shade/renderer/water/medium/GPUWaterBodies.js

@@ -1,6 +1,10 @@
 import { BufferResourceDescriptor } from "../../../device/graph/BufferResourceDescriptor.js";
 import { round_up } from "../../../../core/math/round_up.js";
-import { graph_prefix_scan_csdldf } from "../../gpu_primitive/prefix_sum/v1/graph_prefix_scan_csdldf.js";
+import {
+    graph_prefix_scan_csdldf,
+    prefix_scan_csdldf_output_descriptor
+} from "../../gpu_primitive/prefix_sum/v1/graph_prefix_scan_csdldf.js";
+import { graph_create_buffer } from "../../shader/graph/graph_create_buffer.js";
 import {
     build_indirect_compute_dispatch_command,
     INDIRECT_COMPUTE_COMMAND_DESCRIPTOR
@@ -42,7 +46,9 @@ export class GPUWaterBodies {
         data.command = pass.create('Water lod bodies command', INDIRECT_COMPUTE_COMMAND_DESCRIPTOR);
         data.lod_bodies = pass.create('Water lod bodies', BufferResourceDescriptor.from(capacity * WATER_LOD_BODY_STRUCT.size,
             GPUBufferUsage.STORAGE));
-        const sums = graph_prefix_scan_csdldf({ graph, data: data.counts, element_max_count: capacity });
+        const sums = graph_prefix_scan_csdldf({ graph, input: data.counts,
+            output: graph_create_buffer(graph, 'Water lod body meshlet sums', prefix_scan_csdldf_output_descriptor(capacity)),
+            element_max_count: capacity });
         const command_data = {};
         const command_pass = graph.add('Water / expand command', command_data, (d, resources, { encoder }) => {
             shader_prefix_sum_to_command.dispatch({ encoder, bindings: {

package/src/shade/renderer/water/optics/chunk_water_receiver_downwelling.d.ts

@@ -5,8 +5,9 @@
  * light that receiver was shaded with survives the water above it.
  *
  * The ratio is of the receiver's irradiance under the water to its irradiance dry, from what the
- * water pass can rebuild at the receiver — its position, G-buffer normal and depth below the
- * surface, the shadow map and the GI mode:
+ * water pass can rebuild at the receiver — its position, the normal it was shaded with (the G-buffer's
+ * shading normal, as deferred lighting takes n·l, the shadow lookup and GI on it; never its triangle's,
+ * which turns at every edge) and depth below the surface, the shadow map and the GI mode:
  *
  * - dry: each directional light × its shadow × n·l, plus the GI mode's irradiance on n;
  * - wet: each light refracted at the surface, so steeper, with the Fresnel transmittance, the beam's

package/src/shade/renderer/water/optics/chunk_water_receiver_downwelling.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_water_receiver_downwelling.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/water/optics/chunk_water_receiver_downwelling.js"],"names":[],"mappings":"AAWA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,+CAFU,SAAS,CAyCmE;0BApE5D,oCAAoC"}
+{"version":3,"file":"chunk_water_receiver_downwelling.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/water/optics/chunk_water_receiver_downwelling.js"],"names":[],"mappings":"AAWA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,+CAFU,SAAS,CAyCmE;0BArE5D,oCAAoC"}

package/src/shade/renderer/water/optics/chunk_water_receiver_downwelling.js

@@ -16,8 +16,9 @@ import { chunk_water_optics } from "./chunk_water_optics.js";
  * light that receiver was shaded with survives the water above it.
  *
  * The ratio is of the receiver's irradiance under the water to its irradiance dry, from what the
- * water pass can rebuild at the receiver — its position, G-buffer normal and depth below the
- * surface, the shadow map and the GI mode:
+ * water pass can rebuild at the receiver — its position, the normal it was shaded with (the G-buffer's
+ * shading normal, as deferred lighting takes n·l, the shadow lookup and GI on it; never its triangle's,
+ * which turns at every edge) and depth below the surface, the shadow map and the GI mode:
  *
  * - dry: each directional light × its shadow × n·l, plus the GI mode's irradiance on n;
  * - wet: each light refracted at the surface, so steeper, with the Fresnel transmittance, the beam's

package/src/shade/renderer/water/shader_water.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_water.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/water/shader_water.js"],"names":[],"mappings":"AAwmBA,kEAAuH;AACvH,+EAA+J;AAC/J,kFAAqK;AA/jBrK,8CAKwB;AAiCxB,oGAAoG;AACpG,uEAAkE;AAGlE,gGAAgG;AAChG,0EAAqE;AAqOrE,+CA+EmB;AA6LnB,4CAAmG;AACnG,kFAAkF;AAClF,yDAC8G;AAC9G,oCAAoC;AACpC,4DACoH;AACpH,0DAAyC;yCA5kBA,8DAA8D;6BAmB1E,gCAAgC;4CAJjB,mDAAmD;0BADrE,iCAAiC;iCAE1B,+BAA+B"}
+{"version":3,"file":"shader_water.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/water/shader_water.js"],"names":[],"mappings":"AA0mBA,kEAAuH;AACvH,+EAA+J;AAC/J,kFAAqK;AAjkBrK,8CAKwB;AAiCxB,oGAAoG;AACpG,uEAAkE;AAGlE,gGAAgG;AAChG,0EAAqE;AAqOrE,+CA+EmB;AA+LnB,4CAAmG;AACnG,kFAAkF;AAClF,yDAC8G;AAC9G,oCAAoC;AACpC,4DACoH;AACpH,0DAAyC;yCA9kBA,8DAA8D;6BAmB1E,gCAAgC;4CAJjB,mDAAmD;0BADrE,iCAAiC;iCAE1B,+BAA+B"}

package/src/shade/renderer/water/shader_water.js

@@ -550,12 +550,14 @@ fn fs_main(in: WaterVertexOut, @builtin(front_facing) above: bool) -> WaterOptic
     } else { confidence = 0.0; }
     // The opaque scene was shaded dry: what reaches the receiver is what survives the water above it
     // (WATER_OPTICS_PLAN_2026_10_02.md §4.3). Seen from under the surface, the receiver is above it.
+    // Its light is rebuilt on the normal it was shaded with: its triangle's turns at every edge of a
+    // tessellated floor, and every edge would show through the water.
     let receiver_texel = water_receiver_texel(tDepth, tNormal, receiver_coord, camera.projection_matrix_inverse,
         camera.view_matrix_inverse);
     if (above && !is_background(receiver_texel.depth)) {
         let camera_ws = camera.view_matrix_inverse[3].xyz;
         let up = normalize(in.rest_normal);
-        color *= water_receiver_downwelling(body, receiver_texel.position, receiver_texel.normal, up,
+        color *= water_receiver_downwelling(body, receiver_texel.position, receiver_texel.shading_normal, up,
             max(dot(in.world - receiver_texel.position, up), 0.0), normalize(camera_ws - receiver_texel.position));
     }
     // Light in the water body (WATER_OPTICS_PLAN_2026_10_02.md §4.4): the receiver attenuated along

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

@@ -1 +1 @@
-{"version":3,"file":"GPUWaterSurface.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/water/surface/GPUWaterSurface.js"],"names":[],"mappings":"AAmBA,uHAAuH;AACvH,2CAA4C;AAE5C,4EAA4E;AAC5E,6DAKI;AAEJ;;;;;;GAMG;AACH;IACI,4FAA4F;IAC5F,yBAAgC;IAChC,oEAAoE;IACpE,0BAA0B;IAC1B,6EAA6E;IAC7E,eAAc;IACd;;;OAGG;IACH,kBAAiB;IAejB,mCAA0D;IAC1D,kCAAwD;IACxD,kCAA0D;IAC1D,kCAA0D;IAC1D,kHAAkH;IAClH,uBAAmC;IACnC,qGAAqG;IACrG,0BAAyC;IACzC,gHAAgH;IAChH,8BAA2D;IAC3D,mCAA2C;IAE3C;;;OAGG;IACH,YAFW,MAAM,QAKhB;IAED,gBAWC;IAsBD;;;;;;;;;;;OAWG;IACH;QAVsG,KAAK,EAAhG,OAAO,8DAA8D,EAAE,UAAU;QAC9D,MAAM;QACT,KAAK,EAArB,MAAM;QACU,IAAI,EAApB,MAAM;QACU,IAAI;YACI,MAAM;YACE,UAAU,EAA1C,UAAU,MAAM,CAAC;YACI,MAAM,EAA3B,MAAM;;QACU,MAAM,EAAtB,MAAM;aAsEhB;;CACJ;kCApMiC,kDAAkD;mBAFjE,0CAA0C;kCAI3B,kCAAkC"}
+{"version":3,"file":"GPUWaterSurface.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/water/surface/GPUWaterSurface.js"],"names":[],"mappings":"AAoBA,uHAAuH;AACvH,2CAA4C;AAE5C,4EAA4E;AAC5E,6DAKI;AAEJ;;;;;;GAMG;AACH;IACI,4FAA4F;IAC5F,yBAAgC;IAChC,oEAAoE;IACpE,0BAA0B;IAC1B,6EAA6E;IAC7E,eAAc;IACd;;;OAGG;IACH,kBAAiB;IAejB,mCAA0D;IAC1D,kCAAwD;IACxD,kCAA0D;IAC1D,kCAA0D;IAC1D,kHAAkH;IAClH,uBAAmC;IACnC,qGAAqG;IACrG,0BAAyC;IACzC,gHAAgH;IAChH,8BAA2D;IAC3D,mCAA2C;IAE3C;;;OAGG;IACH,YAFW,MAAM,QAKhB;IAED,gBAWC;IAuBD;;;;;;;;;;;OAWG;IACH;QAVsG,KAAK,EAAhG,OAAO,8DAA8D,EAAE,UAAU;QAC9D,MAAM;QACT,KAAK,EAArB,MAAM;QACU,IAAI,EAApB,MAAM;QACU,IAAI;YACI,MAAM;YACE,UAAU,EAA1C,UAAU,MAAM,CAAC;YACI,MAAM,EAA3B,MAAM;;QACU,MAAM,EAAtB,MAAM;aAsEhB;;CACJ;kCArMiC,kDAAkD;mBAHjE,0CAA0C;kCAK3B,kCAAkC"}

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

@@ -1,5 +1,6 @@
 import Signal from "../../../../core/events/signal/Signal.js";
 import { assert } from "../../../../core/assert.js";
+import { round_up } from "../../../../core/math/round_up.js";
 import { SamplerDescriptor } from "../../../descriptor/texture/SamplerDescriptor.js";
 import { GPUWaterSpectrum } from "./spectrum/GPUWaterSpectrum.js";
 import { GPUWaterParticles } from "./particles/GPUWaterParticles.js";
@@ -104,7 +105,8 @@ export class GPUWaterSurface {
             usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | usage });
         this.#steep = buffer('steep bodies', rows * 4);
         this.#activity = buffer('activity', rows * 4);
-        const list = label => buffer(label, WATER_LIST_HEADER_BYTES + rows * 4);
+        // rows are aligned to 16, so WGSL rounds a list up to whole blocks of 4: one row binds 32 bytes, not 20
+        const list = label => buffer(label, WATER_LIST_HEADER_BYTES + round_up(rows, 4) * 4);
         this.#lists = { visible: list('visible rows'), active: list('active rows'), emit: list('emit rows') };
         this.#commands ??= buffer('surface commands', WATER_SURFACE_COMMAND_COUNT * WATER_SURFACE_COMMAND_STRIDE, GPUBufferUsage.INDIRECT);
         this.#rows = rows;

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/graph_water_tessellation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graph_water_tessellation.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/water/surface/graph_water_tessellation.js"],"names":[],"mappings":"AAiCA;;;;;;;GAOG;AACH,8CAHW;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAC,GACtE;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAC,CAQrH;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH;IAXsG,KAAK,EAAhG,OAAO,8DAA8D,EAAE,UAAU;IACjE,KAAK,EAArB,MAAM;IACU,MAAM,EAAtB,MAAM;IACU,QAAQ,EAAxB,MAAM;IACU,UAAU,EAA1B,MAAM;IACU,gBAAgB,EAAhC,MAAM;IAC2E,GAAG,EAApF;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,YAAY,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAC;IAC+B,MAAM,EAA5G;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAC;IACzE,KAAK;IACtB;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAC,CAsGrF"}
+{"version":3,"file":"graph_water_tessellation.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/water/surface/graph_water_tessellation.js"],"names":[],"mappings":"AAqCA;;;;;;;GAOG;AACH,8CAHW;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAC,GACtE;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAC,CAQrH;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH;IAXsG,KAAK,EAAhG,OAAO,8DAA8D,EAAE,UAAU;IACjE,KAAK,EAArB,MAAM;IACU,MAAM,EAAtB,MAAM;IACU,QAAQ,EAAxB,MAAM;IACU,UAAU,EAA1B,MAAM;IACU,gBAAgB,EAAhC,MAAM;IAC2E,GAAG,EAApF;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,YAAY,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAC;IAC+B,MAAM,EAA5G;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAC;IACzE,KAAK;IACtB;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAC,CAyGrF"}

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

@@ -1,11 +1,15 @@
 import { assert } from "../../../../core/assert.js";
 import { BufferResourceDescriptor } from "../../../device/graph/BufferResourceDescriptor.js";
 import { GEOMETRY_MESHLET_TRIANGLE_LIMIT } from "../../geometry/meshlet/GEOMETRY_MESHLET_TRIANGLE_LIMIT.js";
-import { graph_prefix_scan_csdldf } from "../../gpu_primitive/prefix_sum/v1/graph_prefix_scan_csdldf.js";
+import {
+    graph_prefix_scan_csdldf,
+    prefix_scan_csdldf_output_descriptor
+} from "../../gpu_primitive/prefix_sum/v1/graph_prefix_scan_csdldf.js";
 import {
     build_indirect_compute_dispatch_command,
     INDIRECT_COMPUTE_COMMAND_DESCRIPTOR
 } from "../../gpu_primitive/indirect/IndirectComputeCommandBuildPass.js";
+import { graph_create_buffer } from "../../shader/graph/graph_create_buffer.js";
 import { WATER_LOD_VIEW_STRUCT } from "./lod/WATER_LOD.js";
 import {
     shader_water_lod_candidate_command,
@@ -73,6 +77,9 @@ export function graph_water_tessellation({ graph, scene, camera, meshlets, lod_b
     const geometry_bindings = { scene_database: scene.scene_database_buffer,
         meshlet_metadata: scene.geometries.meshlets.buffer_metadata, meshlet_data: scene.geometries.meshlets.buffer_data };
     const limits_value = { ...limits };
+    // a counts collection's inclusive sums, into a collection of their own
+    const sums_of = (counts, label, elements) => graph_prefix_scan_csdldf({ graph, input: counts,
+        output: graph_create_buffer(graph, label, prefix_scan_csdldf_output_descriptor(elements)), element_max_count: elements });
 
     // per triangle slot of the drawn meshlets: drawn as itself, or its candidates
     const triangles_data = {};
@@ -88,8 +95,8 @@ export function graph_water_tessellation({ graph, scene, camera, meshlets, lod_b
     triangles_data.command = triangles.create('Water lod triangles command', INDIRECT_COMPUTE_COMMAND_DESCRIPTOR);
     triangles_data.counts = triangles.create('Water lod triangle counts', counts_descriptor(slots));
     triangles_data.flats = triangles.create('Water lod flat counts', counts_descriptor(slots));
-    const triangle_sums = graph_prefix_scan_csdldf({ graph, data: triangles_data.counts, element_max_count: slots });
-    const flat_sums = graph_prefix_scan_csdldf({ graph, data: triangles_data.flats, element_max_count: slots });
+    const triangle_sums = sums_of(triangles_data.counts, 'Water lod triangle sums', slots);
+    const flat_sums = sums_of(triangles_data.flats, 'Water lod flat sums', slots);
 
     // the candidates' dispatch; the flat triangles' records and draw
     const command_data = {};
@@ -133,7 +140,7 @@ export function graph_water_tessellation({ graph, scene, camera, meshlets, lod_b
         budget * WATER_LOD_CANDIDATE_ROW_WORDS * 4, GPUBufferUsage.STORAGE));
     // the interior, boundary and patch counts of every candidate, one region after another, scanned once
     candidates_data.counts = candidates.create('Water lod cell counts', counts_descriptor(3 * budget));
-    const list_sums = graph_prefix_scan_csdldf({ graph, data: candidates_data.counts, element_max_count: 3 * budget });
+    const list_sums = sums_of(candidates_data.counts, 'Water lod cell sums', 3 * budget);
 
     // each list's records; the boundary cells' polygons
     const lists = [

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":"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"}