@woosh/meep-engine 3.47.0 → 3.50.0

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

@@ -1,7 +1,7 @@
 import { GPUShaderStage } from "../../descriptor/GPUShaderStage.js";
 import { DepthStencilState } from "../../descriptor/pipeline/render/DepthStencilState.js";
 import { RenderPipelineDescriptor } from "../../descriptor/pipeline/render/RenderPipelineDescriptor.js";
-import { CAMERA_UNIFORM_STRUCT } from "../camera/CAMERA_UNIFORM_STRUCT.js";
+import { CAMERA_RESOURCE } from "../camera/CAMERA_RESOURCE.js";
 import { SHADING_LIGHT_RESOURCE_GROUP } from "../deferred/SHADING_LIGHT_RESOURCE_GROUP.js";
 import { BRICK4_DATA_STRUCT } from "../global_illumination/brick4/gpu/BRICK4_DATA_STRUCT.js";
 import { chunk_F_dielectric } from "../shader/chunk/brdf/fresnel/chunk_F_dielectric.js";
@@ -13,20 +13,29 @@ import { chunk_ffx_sssr_load_depth } from "../shader/chunk/screen_space/chunk_ff
 import { chunk_ffx_sssr_validate_hit } from "../shader/chunk/screen_space/chunk_ffx_sssr_validate_hit.js";
 import { chunk_project_direction } from "../shader/chunk/screen_space/chunk_project_direction.js";
 import { chunk_screen_space_newton_ray } from "../shader/chunk/screen_space/chunk_screen_space_newton_ray.js";
-import { chunk_texture_sample_bilinear_uv } from "../shader/chunk/texture/sample/chunk_texture_sample_bilinear_uv.js";
 import { CodeChunk } from "../shader/compiler/CodeChunk.js";
+import {
+    SCREEN_DEPTH_RESOURCE,
+    SCREEN_HZB_RESOURCE,
+    SCREEN_NORMAL_RESOURCE
+} from "../shader/chunk/screen_space/SCREEN_SPACE_RESOURCES.js";
+import { ShaderResourceDescriptor } from "../shader/resource/ShaderResourceDescriptor.js";
 import { ShaderResourceSetDescriptor } from "../shader/resource/ShaderResourceSetDescriptor.js";
 import { ShaderDescriptor } from "../shader/ShaderDescriptor.js";
 import { f32, u32 } from "../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
 import { WebGPUArray } from "../shader/type/WebGPUArray.js";
 import { WebGPUStruct } from "../shader/type/WebGPUStruct.js";
 import { VIEW_UNIFORM_STRUCT } from "../view/VIEW_UNIFORM_STRUCT.js";
-import { chunk_water_gi_brick4, chunk_water_gi_ibl } from "./chunk_water_gi.js";
+import { chunk_water_gi } from "./chunk_water_gi.js";
 import { WATER_BODIES_TABLE, WATER_WAVES_TABLE } from "./medium/chunk_water_bodies.js";
-import { MESHLET_METADATA_STRUCT } from "../geometry/meshlet/encoding/MESHLET_METADATA_STRUCT.js";
-import { COLLECTION_U32_STRUCT_READ } from "../gpu_primitive/COLLECTION_U32_STRUCT_READ.js";
+import { GEOMETRY_ATTRIBUTE_DATA_RESOURCE } from "../geometry/GEOMETRY_ATTRIBUTE_DATA_RESOURCE.js";
+import { MESHLET_METADATA_RESOURCE } from "../geometry/meshlet/MESHLET_METADATA_RESOURCE.js";
+import { SCENE_DATABASE_RESOURCE } from "../scene/SCENE_DATABASE_RESOURCE.js";
 import { chunk_water_surface_sample } from "./surface/chunk_water_surface_sample.js";
-import { WATER_PARTICLE_ENTRY_STRUCT } from "./surface/particles/WATER_PARTICLE_STRUCT.js";
+import {
+    WATER_BAND_DERIVATIVES_RESOURCE, WATER_BAND_DISPLACEMENT_RESOURCE, WATER_BAND_SAMPLER_RESOURCE,
+    WATER_PARTICLE_ENTRIES_RESOURCE, WATER_PARTICLE_OFFSETS_RESOURCE
+} from "./surface/WATER_SURFACE_RESOURCES.js";
 import { WATER_LOD_BODY_STRUCT, WATER_LOD_VIEW_STRUCT, WaterLodMode } from "./surface/lod/WATER_LOD.js";
 import { chunk_water_lod_candidate, chunk_water_lod_layout, WATER_LOD_BOUNDARY_FIRST_VERTEX, WATER_LOD_CANDIDATE_STRUCT,
     WATER_LOD_CELL_LOCAL_BITS, WATER_LOD_LIMITS_STRUCT, WATER_LOD_PATCH_FIRST_VERTEX, WATER_LOD_PATCH_SIDE, WATER_LOD_POLYGON_WORDS,
@@ -38,8 +47,8 @@ import { NODE3D_GLOBAL_FLAG_MIRRORED } from "../scene/NODE3D_STRUCT.js";
 import { chunk_water_inscatter } from "./optics/chunk_water_inscatter.js";
 import { chunk_water_receiver_downwelling } from "./optics/chunk_water_receiver_downwelling.js";
 import { chunk_water_optics } from "./optics/chunk_water_optics.js";
-import { chunk_water_receiver_radiance, chunk_water_receiver_texel, chunk_water_refraction_confidence,
-    chunk_water_transport, WATER_LEVEL_TOLERANCE_DECLARATION } from './chunk_water_transport.js';
+import { chunk_water_receiver_radiance, chunk_water_receiver_texel, chunk_water_transport,
+    WATER_LEVEL_TOLERANCE_DECLARATION } from './chunk_water_transport.js';
 
 export const WATER_TRACE_STRUCT = WebGPUStruct.from({
     max_distance: f32, distance_tolerance: f32, max_updates: u32, fallback_steps: u32,
@@ -48,45 +57,51 @@ export const WATER_TRACE_STRUCT = WebGPUStruct.from({
     inscatter_segments: u32,
 }, "WaterTrace").pack();
 
+const TRACE_RESOURCE = ShaderResourceDescriptor.uniform("trace", WATER_TRACE_STRUCT);
+// the view's lattice (WATER_SURFACE_DISTANCE_LOD_PROPOSAL_2026_10_06.md §4.3)
+const LOD_RESOURCE = ShaderResourceDescriptor.uniform('lod', WATER_LOD_VIEW_STRUCT);
+const LOD_LIMITS_RESOURCE = ShaderResourceDescriptor.uniform('lod_limits', WATER_LOD_LIMITS_STRUCT);
+const LOD_BODIES_RESOURCE = ShaderResourceDescriptor.storageBuffer('water_lod_bodies', WebGPUArray.from(WATER_LOD_BODY_STRUCT));
+const LOD_CANDIDATES_RESOURCE = ShaderResourceDescriptor.storageBuffer('water_lod_candidates', WebGPUArray.from(WATER_LOD_CANDIDATE_STRUCT));
+const LOD_CELLS_RESOURCE = ShaderResourceDescriptor.storageBuffer('water_lod_cells', WebGPUArray.u32);
+
 function water_resources(finalize = false) {
     const resources = new ShaderResourceSetDescriptor();
     const group = resources.createGroup()
-        .addUniform("camera", CAMERA_UNIFORM_STRUCT)
-        .addUniform("trace", WATER_TRACE_STRUCT)
-        .addTexture("tDepth")
-        .addTexture("tNormal", "uint")
-        .addTexture("tHZB")
+        .add(CAMERA_RESOURCE)
+        .add(TRACE_RESOURCE)
+        .add(SCREEN_DEPTH_RESOURCE)
+        .add(SCREEN_NORMAL_RESOURCE)
+        .add(SCREEN_HZB_RESOURCE)
         .addTexture("tScene")
-        .addStorageBuffer('scene_database', WebGPUArray.u32)
-        // the view's lattice (WATER_SURFACE_DISTANCE_LOD_PROPOSAL_2026_10_06.md §4.3)
-        .addUniform('lod', WATER_LOD_VIEW_STRUCT)
-        .addUniform('lod_limits', WATER_LOD_LIMITS_STRUCT)
-        .addStorageBuffer('water_lod_bodies', WebGPUArray.from(WATER_LOD_BODY_STRUCT))
-        .addStorageBuffer('water_lod_candidates', WebGPUArray.from(WATER_LOD_CANDIDATE_STRUCT))
-        .addStorageBuffer('water_lod_cells', WebGPUArray.u32)
-        .addStorageBuffer('meshlet_metadata', WebGPUArray.from(MESHLET_METADATA_STRUCT))
-        .addStorageBuffer('meshlet_data', WebGPUArray.from(f32))
+        .add(SCENE_DATABASE_RESOURCE)
+        .add(LOD_RESOURCE)
+        .add(LOD_LIMITS_RESOURCE)
+        .add(LOD_BODIES_RESOURCE)
+        .add(LOD_CANDIDATES_RESOURCE)
+        .add(LOD_CELLS_RESOURCE)
+        .add(MESHLET_METADATA_RESOURCE)
+        .add(GEOMETRY_ATTRIBUTE_DATA_RESOURCE)
         // the surface interface: the spectral bands and the frame's binned wave particles
-        .addTexture('water_band_displacement', 'float', '2d-array')
-        .addTexture('water_band_derivatives', 'float', '2d-array')
-        .addSampler('water_band_sampler')
-        .addStorageBuffer('water_particle_offsets', COLLECTION_U32_STRUCT_READ)
-        .addStorageBuffer('water_particle_entries', WebGPUArray.from(WATER_PARTICLE_ENTRY_STRUCT));
+        .add(WATER_BAND_DISPLACEMENT_RESOURCE)
+        .add(WATER_BAND_DERIVATIVES_RESOURCE)
+        .add(WATER_BAND_SAMPLER_RESOURCE)
+        .add(WATER_PARTICLE_OFFSETS_RESOURCE)
+        .add(WATER_PARTICLE_ENTRIES_RESOURCE);
     if (finalize) {
-        group.addTexture('receiver').addTexture('trace_metadata').addTexture('visibility_distance');
+        group.addTexture('receiver').addTexture('trace_metadata');
     }
     return resources;
 }
 const resources = water_resources();
 
-/** Optics under IBL (and LPV, which has no transparent variant): the lights and the environment. */
-export const WATER_FINALIZE_RESOURCES_IBL = water_resources(true);
-WATER_FINALIZE_RESOURCES_IBL.addGroup(SHADING_LIGHT_RESOURCE_GROUP);
-
-/** Optics under Brick4: the lights, and the light map with the view its sampling jitters by. */
-export const WATER_FINALIZE_RESOURCES_BRICK4 = water_resources(true);
-WATER_FINALIZE_RESOURCES_BRICK4.addGroup(SHADING_LIGHT_RESOURCE_GROUP);
-WATER_FINALIZE_RESOURCES_BRICK4.createGroup()
+/**
+ * The optics: the lights, the environment, and the light map with the view its sampling jitters by.
+ * Every indirect lighting mode's resources, whichever the pipeline's variant reads (`chunk_water_gi`).
+ */
+export const WATER_FINALIZE_RESOURCES = water_resources(true);
+WATER_FINALIZE_RESOURCES.addGroup(SHADING_LIGHT_RESOURCE_GROUP);
+WATER_FINALIZE_RESOURCES.createGroup()
     .addStorageBuffer("brick4", BRICK4_DATA_STRUCT, false)
     .addUniform("view", VIEW_UNIFORM_STRUCT);
 
@@ -313,6 +328,13 @@ fn water_interface(world: vec3<f32>, surface_normal: vec3<f32>, ior: f32, above:
     chunk_scene_database_access, chunk_mat3_inverse, chunk_water_lod_candidate, chunk_water_lod_layout,
     WATER_LOD_CANDIDATE_STRUCT.declaration_chunk, chunk_water_surface_sample]);
 
+for (const resource of [
+    CAMERA_RESOURCE, TRACE_RESOURCE, SCENE_DATABASE_RESOURCE, LOD_RESOURCE, LOD_LIMITS_RESOURCE, LOD_BODIES_RESOURCE,
+    LOD_CANDIDATES_RESOURCE, LOD_CELLS_RESOURCE, MESHLET_METADATA_RESOURCE,
+]) {
+    surface_body.requireResource(resource);
+}
+
 export const chunk_water_screen_ray = CodeChunk.from(/* language=WGSL */ `
 fn water_hzb_mip_size(depth_size: vec2f, hzb_size: vec2f, mip: i32) -> vec2f {
     if (mip <= 0) { return depth_size; }
@@ -366,6 +388,13 @@ fn water_exact_receiver(ray: Ray, input: ScreenSpaceRayHit) -> ScreenSpaceRayHit
             camera.projection_matrix,camera.projection_matrix_inverse,camera.view_matrix,trace.distance_tolerance);
         hit.status = checked.status;
         hit.residual = checked.residual;
+        // The plane can carry a hit on the last texel before the sky across that edge. The texel the
+        // traversal stopped on is still a receiver: accept it where it passes on its own.
+        if (checked.status == 2u) {
+            let unsnapped = screen_space_ray_validate(ray, input.uv, tDepth, tNormal, camera.projection_matrix,
+                camera.projection_matrix_inverse, camera.view_matrix, trace.distance_tolerance);
+            if (unsnapped.status == 0u) { hit = unsnapped; }
+        }
     } else { hit.status = 4u; }
     return hit;
 }
@@ -394,6 +423,10 @@ fn water_hzb_hit(ray: Ray, budget: u32) -> ScreenSpaceRayHit {
 `, [chunk_screen_space_newton_ray, chunk_ffx_sssr_advance_ray, chunk_ffx_sssr_load_depth, chunk_project_direction,
     chunk_ray_at]);
 
+for (const resource of [CAMERA_RESOURCE, TRACE_RESOURCE, SCREEN_DEPTH_RESOURCE, SCREEN_HZB_RESOURCE, SCREEN_NORMAL_RESOURCE]) {
+    chunk_water_screen_ray.requireResource(resource);
+}
+
 const body = CodeChunk.from(/* language=WGSL */ `
 struct WaterReceiver {
     @location(0) receiver: vec4<f32>,
@@ -529,11 +562,11 @@ fn fs_main(in: WaterVertexOut, @builtin(front_facing) above: bool) -> WaterOptic
         }
     }
     let original = textureLoad(tScene, coord, 0);
+    // A validated receiver is taken where the trace found it, at its whole displacement, however near an
+    // object or the sky it lies. Any lookup between it and the pixel's own would be a point the ray never
+    // reached, and bends the image around every object. A pixel without one shows its own background.
     let valid = receiver_data.w < 16.0 && above && trace.mode != 2u;
-    var confidence = select(0.0, water_refraction_confidence(receiver_data.xy, uv, dimensions,
-        texture_sample_bilinear_uv(visibility_distance, uv, 0u).r), valid);
-    // Mayer's fade selects one UV, rather than crossfading two images of the same edge.
-    let lookup = water_refraction_lookup(uv, receiver_data.xy, confidence);
+    let lookup = select(uv, receiver_data.xy, valid);
     // The surface height here stands for the one above the displaced receiver: they differ by the
     // wave height across a few metres, against a tolerance the gather already allows.
     let gathered = water_receiver_radiance(tScene, tDepth, tNormal, lookup,
@@ -542,12 +575,12 @@ fn fs_main(in: WaterVertexOut, @builtin(front_facing) above: bool) -> WaterOptic
     var color = original.rgb;
     // the receiver seen through the surface: refracted, or the pixel's own when there is none
     var receiver_coord = coord;
-    if (confidence > 0.0 && gathered.a > 0.0) {
+    if (valid && gathered.a > 0.0) {
         path = min(water_receiver_path(tDepth, tNormal, lookup, camera.projection_matrix_inverse,
             camera.view_matrix, origin), limit);
         color = gathered.rgb;
         receiver_coord = vec2i(lookup * dimensions);
-    } 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
@@ -574,22 +607,20 @@ fn fs_main(in: WaterVertexOut, @builtin(front_facing) above: bool) -> WaterOptic
     }
     let event = water_event(transmitted, fresnel * reflection + scattered);
     let optical = water_transport(event, original.rgb, color, metadata.z);
-    return WaterOptics(vec4f(optical.transmission, metadata.z), vec4f(optical.radiance, confidence),
+    return WaterOptics(vec4f(optical.transmission, metadata.z), vec4f(optical.radiance, 0.0),
         vec4f(optical.background, original.a));
 }
-`, [surface_body, chunk_water_screen_ray, chunk_F_dielectric,
-    chunk_ffx_sssr_validate_hit, chunk_texture_sample_bilinear_uv,
+`, [surface_body, chunk_water_screen_ray, chunk_F_dielectric, chunk_ffx_sssr_validate_hit,
     chunk_direction_view_to_world, chunk_ray_at, chunk_water_optics, chunk_water_inscatter,
     chunk_water_receiver_downwelling, chunk_water_receiver_texel,
-    chunk_water_transport, chunk_water_receiver_radiance, chunk_water_refraction_confidence]);
+    chunk_water_transport, chunk_water_receiver_radiance,
+    // water_gi_specular here, and water_gi_irradiance for the in-scatter and the downwelling light
+    chunk_water_gi]);
 
 export const water_shader = ShaderDescriptor.from({ label: "Water / receivers", resources, body });
-/** The optics pass under IBL, and under LPV, which has no transparent variant. */
-export const water_finalize_shader_ibl = ShaderDescriptor.from({ label: 'Water / coherent optics IBL',
-    resources: WATER_FINALIZE_RESOURCES_IBL, body: CodeChunk.from('', [finalize_body, chunk_water_gi_ibl]) });
-/** The optics pass under Brick4. */
-export const water_finalize_shader_brick4 = ShaderDescriptor.from({ label: 'Water / coherent optics Brick4',
-    resources: WATER_FINALIZE_RESOURCES_BRICK4, body: CodeChunk.from('', [finalize_body, chunk_water_gi_brick4]) });
+/** The optics pass; its variants differ in the indirect lighting they fall back to, and bind alike. */
+export const water_finalize_shader = ShaderDescriptor.from({ label: 'Water / coherent optics',
+    resources: WATER_FINALIZE_RESOURCES, body: finalize_body });
 export const WATER_RESOURCES = resources;
 
 /** Nearest-interface selection writes only water-owned depth and optics, never opaque G-buffer. */
@@ -597,7 +628,7 @@ function water_pipeline(shader, targets, finalize) {
     const code = shader.source;
     const layout = shader.resources.generatePipelineLayout(GPUShaderStage.VERTEX | GPUShaderStage.FRAGMENT);
     // The lattice spends eight storage slots in the vertex stage, the guaranteed budget. Lighting spends four in the
-    // fragment stage. Keep their visibility precise so the Brick4 variant fits it there.
+    // fragment stage, Brick4's buffer among them. Keep their visibility precise so the optics fit it there.
     const vertex_only = new Set(['lod', 'lod_limits', 'water_lod_bodies', 'water_lod_candidates', 'water_lod_cells',
         'meshlet_metadata', 'meshlet_data', 'water_band_displacement', 'water_particle_offsets', 'water_particle_entries']);
     // the fragment stage shades the bands the mesh could not carry
@@ -617,5 +648,7 @@ function water_pipeline(shader, targets, finalize) {
     });
 }
 export function create_water_pipeline() { return water_pipeline(water_shader, ['rgba32float', 'rgba32float'], false); }
-export function create_water_finalize_pipeline_ibl() { return water_pipeline(water_finalize_shader_ibl, ['rgba32float', 'rgba16float', 'rgba16float'], true); }
-export function create_water_finalize_pipeline_brick4() { return water_pipeline(water_finalize_shader_brick4, ['rgba32float', 'rgba16float', 'rgba16float'], true); }
+/** The optics pipeline, its shader built for `switches` (a ShaderSwitchSet). */
+export function create_water_finalize_pipeline(switches) {
+    return water_pipeline(water_finalize_shader.variant(switches), ['rgba32float', 'rgba16float', 'rgba16float'], true);
+}

package/src/shade/renderer/water/shader_water_avboit.d.ts

@@ -1,10 +1,6 @@
-export { chunk_water_refraction_confidence } from "./chunk_water_transport.js";
 export const shader_water_occupancy: ComputeShader;
 export const shader_water_splat: ComputeShader;
 export const shader_water_draw: ImageShader;
-export const shader_water_confidence_seed: ImageShader;
-export const shader_water_confidence_x: ImageShader;
-export const shader_water_confidence_y: ImageShader;
 export const shader_water_background_copy: ImageShader;
 export const shader_water_debug: ImageShader;
 import { ComputeShader } from "../shader/ComputeShader.js";

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

@@ -1 +1 @@
-{"version":3,"file":"shader_water_avboit.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/water/shader_water_avboit.js"],"names":[],"mappings":";AAqCA,mDAwBG;AAQH,+CAqCG;AAUH,4CA4BG;AAQH,uDAuBG;AAyBH,oDAA2E;AAC3E,oDAA0E;AAM1E,uDAYG;AAOH,6CAyCG;8BAxP2B,4BAA4B;4BAC9B,0BAA0B"}
+{"version":3,"file":"shader_water_avboit.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/water/shader_water_avboit.js"],"names":[],"mappings":"AAkCA,mDAwBG;AAQH,+CAqCG;AAUH,4CA4BG;AAMH,uDAYG;AAOH,6CAsCG;8BA3L2B,4BAA4B;4BAC9B,0BAA0B"}

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

@@ -14,8 +14,6 @@ import { chunk_avboit_view_depth_to_physical } from "../rasterize/native/avboit/
 import { chunk_avboit_view_depth_to_virtual } from "../rasterize/native/avboit/chunk_avboit_view_depth_to_virtual.js";
 import { AVBOIT_OCCUPANCY_SETTINGS_STRUCT } from "../rasterize/native/avboit/shader_avboit_occupancy.js";
 import { chunk_get_view_space_depth } from "../shader/chunk/depth/chunk_get_view_space_depth.js";
-import { chunk_is_background } from "../shader/chunk/depth/chunk_is_background.js";
-import { chunk_is_on_screen_i32 } from "../shader/chunk/texture/chunk_is_on_screen_i32.js";
 import { CodeChunk } from "../shader/compiler/CodeChunk.js";
 import { ComputeShader } from "../shader/ComputeShader.js";
 import { ImageShader } from "../shader/ImageShader.js";
@@ -28,7 +26,6 @@ import { SAMPLER_LINEAR_UPSCALE } from "../texture/SAMPLER_LINEAR_UPSCALE.js";
 import { VIEW_UNIFORM_STRUCT } from "../view/VIEW_UNIFORM_STRUCT.js";
 import { VOLUMETRICS_METADATA_STRUCT } from "../volumetrics/VOLUMETRICS_METADATA_STRUCT.js";
 import { DepthStencilState } from '../../descriptor/pipeline/render/DepthStencilState.js';
-export { chunk_water_refraction_confidence } from './chunk_water_transport.js';
 
 const occupancy_resources = new ShaderResourceSetDescriptor();
 occupancy_resources.createGroup().addUniform("camera", CAMERA_UNIFORM_STRUCT)
@@ -144,63 +141,6 @@ fn main(@builtin(position) coord: vec4f) -> WaterContribution {
     }), targets: AVBOIT_DRAW_TARGETS,
 });
 
-// A depth buffer cannot reveal the receiver hidden behind an emergent object.
-// Fade displacement around those disocclusions instead of exposing a hard control-UV hole.
-// Quarter-resolution conservative seeds and a separable bounded distance transform keep
-// this independent of scene size and avoid a full-resolution neighbourhood search.
-const confidence_seed_resources = new ShaderResourceSetDescriptor();
-confidence_seed_resources.createGroup().addTexture("trace_metadata").addTexture("scene_depth");
-export const shader_water_confidence_seed = ImageShader.from({
-    descriptor: ShaderDescriptor.from({ label: "Water / visibility seeds", resources: confidence_seed_resources,
-        body: CodeChunk.from(/* language=WGSL */ `
-@fragment
-fn main(@builtin(position) coord: vec4f) -> @location(0) vec4f {
-    let tile = vec2u(coord.xy) * 4u;
-    let size = textureDimensions(trace_metadata, 0);
-    var distance = 16.0;
-    for (var y = 0u; y < 4u; y++) {
-        for (var x = 0u; x < 4u; x++) {
-            let pixel = tile + vec2u(x, y);
-            if (all(pixel < size)) {
-                let t = textureLoad(trace_metadata, pixel, 0);
-                // Only actual geometry/sky boundaries seed the spatial fade. Trace budget
-                // or numerical failures must not create moving 64-pixel holes around themselves.
-                if (t.b <= 0.0 || is_background(textureLoad(scene_depth, pixel, 0).r)) { distance = 0.0; }
-            }
-        }
-    }
-    return vec4f(distance, 0.0, 0.0, 1.0);
-}
-`, [chunk_is_background]),
-    }), targets: [{ format: "r16float" }],
-});
-
-function confidence_distance_shader(vertical) {
-    const resources = new ShaderResourceSetDescriptor();
-    resources.createGroup().addTexture("distance_field");
-    return ImageShader.from({ descriptor: ShaderDescriptor.from({
-        label: vertical ? "Water / visibility distance Y" : "Water / visibility distance X", resources,
-        body: CodeChunk.from(/* language=WGSL */ `
-@fragment
-fn main(@builtin(position) coord: vec4f) -> @location(0) vec4f {
-    let pixel = vec2i(coord.xy);
-    let size = vec2i(textureDimensions(distance_field, 0));
-    var distance = 16.0;
-    for (var offset = -16; offset <= 16; offset++) {
-        let sample = pixel + ${vertical ? "vec2i(0, offset)" : "vec2i(offset, 0)"};
-        if (is_on_screen_i32(sample, size)) {
-            let d = textureLoad(distance_field, sample, 0).r;
-            distance = min(distance, ${vertical ? "length(vec2f(d, f32(offset)))" : "d + abs(f32(offset))"});
-        }
-    }
-    return vec4f(distance, 0.0, 0.0, 1.0);
-}
-`, [chunk_is_on_screen_i32]),
-    }), targets: [{ format: "r16float" }] });
-}
-export const shader_water_confidence_x = confidence_distance_shader(false);
-export const shader_water_confidence_y = confidence_distance_shader(true);
-
 // Initialize all three final targets in the same render pass as water shading.
 // This samples opaque HDR and needs no COPY_SRC usage or renderer changes.
 const background_resources = new ShaderResourceSetDescriptor();
@@ -249,9 +189,6 @@ fn main(@builtin(position) coord: vec4f) -> @location(0) vec4f {
         }
         case 5u: { color = textureLoad(radiance, pixel, 0).rgb; }
         case 6u: { color = vec3f(min(textureLoad(trace_metadata, pixel, 0).g, 1.0)); }
-        case 10u: {
-            color = vec3f(textureLoad(radiance, pixel, 0).a);
-        }
         case 8u, 9u: {
             let z = get_view_space_depth(textureLoad(interface_depth, pixel, 0).r, camera);
             // without the draw's footprint (a derivative this switch cannot take): where the water is

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

@@ -14,7 +14,10 @@ export class GPUWaterSurface {
     onInputsConsumed: Signal;
     /** Most wave particles alive at once over every body of a scene. */
     particle_capacity: number;
-    /** Whether any body has wind; without it the band tiles are not animated. */
+    /**
+     * Whether the scene's wind field can hold wind (set by whoever owns the bodies: `WaterSystem` asks the GPU fluid);
+     * without it the band tiles are not animated.
+     */
     windy: boolean;
     /**
      * Whether any splash was ever queued. Until one is, the pool is empty and no particle pass is recorded; set by

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":"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"}
+{"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;;;OAGG;IACH,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;aAyEhB;;CACJ;kCA3MiC,kDAAkD;mBAHjE,0CAA0C;kCAK3B,kCAAkC"}

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

@@ -41,7 +41,10 @@ export class GPUWaterSurface {
     onInputsConsumed = new Signal();
     /** Most wave particles alive at once over every body of a scene. */
     particle_capacity = 65536;
-    /** Whether any body has wind; without it the band tiles are not animated. */
+    /**
+     * Whether the scene's wind field can hold wind (set by whoever owns the bodies: `WaterSystem` asks the GPU fluid);
+     * without it the band tiles are not animated.
+     */
     windy = false;
     /**
      * Whether any splash was ever queued. Until one is, the pool is empty and no particle pass is recorded; set by
@@ -174,11 +177,14 @@ export class GPUWaterSurface {
                 }
             }
             if (groups > 0) {
-                shader_water_cull.dispatch({ encoder, bindings: {
+                const bindings = {
                     cull: encoder.allocateTransientValueBuffer(WATER_CULL_STRUCT, { dt, stepping: stepping ? 1 : 0, binning: binning ? 1 : 0 }),
                     lod: encoder.allocateTransientValueBuffer(WATER_LOD_VIEW_STRUCT, lod), camera: view.camera, scene_database: scene.scene_database_buffer, geometries: scene.geometries.buffer_metadata,
                     band_state, band_requests, particle_bounds, steep, activity, visible_rows: lists.visible, active_rows: lists.active,
-                    emit_rows: lists.emit }, group_count_x: Math.min(groups, 65535), group_count_y: Math.ceil(groups / 65535) });
+                    emit_rows: lists.emit };
+                // the bodies' wind: the scene's published field, read as its producer left it before this pass
+                scene.wind.bind(bindings);
+                shader_water_cull.dispatch({ encoder, bindings, group_count_x: Math.min(groups, 65535), group_count_y: Math.ceil(groups / 65535) });
             }
             finalize(encoder, { fresh: fresh && !seed ? 1 : 0, seed: 0 });
             if (windy) { spectrum(encoder); }

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

@@ -0,0 +1,15 @@
+/** @type {ShaderResourceDescriptor} */
+export const WATER_BAND_DISPLACEMENT_RESOURCE: ShaderResourceDescriptor;
+/** @type {ShaderResourceDescriptor} */
+export const WATER_BAND_DERIVATIVES_RESOURCE: ShaderResourceDescriptor;
+/**
+ * Linear, repeat.
+ * @type {ShaderResourceDescriptor}
+ */
+export const WATER_BAND_SAMPLER_RESOURCE: ShaderResourceDescriptor;
+/** @type {ShaderResourceDescriptor} */
+export const WATER_PARTICLE_OFFSETS_RESOURCE: ShaderResourceDescriptor;
+/** @type {ShaderResourceDescriptor} */
+export const WATER_PARTICLE_ENTRIES_RESOURCE: ShaderResourceDescriptor;
+import { ShaderResourceDescriptor } from "../../shader/resource/ShaderResourceDescriptor.js";
+//# sourceMappingURL=WATER_SURFACE_RESOURCES.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"WATER_SURFACE_RESOURCES.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/water/surface/WATER_SURFACE_RESOURCES.js"],"names":[],"mappings":"AAUA,uCAAuC;AACvC,+CADW,wBAAwB,CAC8F;AAEjI,uCAAuC;AACvC,8CADW,wBAAwB,CAC4F;AAE/H;;;GAGG;AACH,0CAFU,wBAAwB,CAEgE;AAElG,uCAAuC;AACvC,8CADW,wBAAwB,CACyG;AAE5I,uCAAuC;AACvC,8CADW,wBAAwB,CAC4H;yCAzBtH,mDAAmD"}

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

@@ -0,0 +1,27 @@
+import { COLLECTION_U32_STRUCT_READ } from "../../gpu_primitive/COLLECTION_U32_STRUCT_READ.js";
+import { ShaderResourceDescriptor } from "../../shader/resource/ShaderResourceDescriptor.js";
+import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
+import { WATER_PARTICLE_ENTRY_STRUCT } from "./particles/WATER_PARTICLE_STRUCT.js";
+
+/*
+ The surface interface `chunk_water_surface_sample` reads: the spectral bands and the frame's binned
+ wave particles.
+*/
+
+/** @type {ShaderResourceDescriptor} */
+export const WATER_BAND_DISPLACEMENT_RESOURCE = ShaderResourceDescriptor.texture("water_band_displacement", "float", "2d-array");
+
+/** @type {ShaderResourceDescriptor} */
+export const WATER_BAND_DERIVATIVES_RESOURCE = ShaderResourceDescriptor.texture("water_band_derivatives", "float", "2d-array");
+
+/**
+ * Linear, repeat.
+ * @type {ShaderResourceDescriptor}
+ */
+export const WATER_BAND_SAMPLER_RESOURCE = ShaderResourceDescriptor.sampler("water_band_sampler");
+
+/** @type {ShaderResourceDescriptor} */
+export const WATER_PARTICLE_OFFSETS_RESOURCE = ShaderResourceDescriptor.storageBuffer("water_particle_offsets", COLLECTION_U32_STRUCT_READ);
+
+/** @type {ShaderResourceDescriptor} */
+export const WATER_PARTICLE_ENTRIES_RESOURCE = ShaderResourceDescriptor.storageBuffer("water_particle_entries", WebGPUArray.from(WATER_PARTICLE_ENTRY_STRUCT));

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

@@ -2,7 +2,8 @@
 export const WATER_WAVE_IMPULSE_LIMIT: 16;
 /**
  * The surface state of one water body, one row per body (WATER_SURFACE_SIMULATION_PLAN_2026_10_06.md §6.1).
- * The CPU writes what is authored and queued; the GPU writes what it derives each frame.
+ * The CPU writes what is authored and queued; the GPU writes what it derives each frame, the body's wind among it:
+ * the scene's wind field, sampled and low-passed (GPU_FLUID_CASCADES_PROPOSAL_2026_10_16.md §6, the Water row).
  */
 export const WATER_WAVE_RECORD_STRUCT: WebGPUStruct;
 import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";

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

@@ -1 +1 @@
-{"version":3,"file":"WATER_WAVE_RECORD_STRUCT.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/water/surface/WATER_WAVE_RECORD_STRUCT.js"],"names":[],"mappings":"AAKA,mDAAmD;AACnD,0CAA2C;AAE3C;;;GAGG;AACH,oDA8BsB;6BAxCO,mCAAmC"}
+{"version":3,"file":"WATER_WAVE_RECORD_STRUCT.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/water/surface/WATER_WAVE_RECORD_STRUCT.js"],"names":[],"mappings":"AAKA,mDAAmD;AACnD,0CAA2C;AAE3C;;;;GAIG;AACH,oDAsCsB;6BAjDO,mCAAmC"}

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

@@ -1,4 +1,4 @@
-import { f32, u32, vec2f, vec4f } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { f32, u32, vec2f, vec3f, vec4f } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
 import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
 import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
 import { WATER_SPECTRUM_BAND_COUNT } from "./spectrum/WATER_SPECTRUM.js";
@@ -8,16 +8,14 @@ export const WATER_WAVE_IMPULSE_LIMIT = 16;
 
 /**
  * The surface state of one water body, one row per body (WATER_SURFACE_SIMULATION_PLAN_2026_10_06.md §6.1).
- * The CPU writes what is authored and queued; the GPU writes what it derives each frame.
+ * The CPU writes what is authored and queued; the GPU writes what it derives each frame, the body's wind among it:
+ * the scene's wind field, sampled and low-passed (GPU_FLUID_CASCADES_PROPOSAL_2026_10_16.md §6, the Water row).
  */
 export const WATER_WAVE_RECORD_STRUCT = WebGPUStruct.from({
-    /**
-     * Wind direction in the body's metric local xz (cos, sin), wind speed at 10 m in m/s, and the amplitude
-     * reflection coefficient of the mesh's outline.
-     */
-    wind: vec4f,
     /** Open water upwind of the mesh, metres, added to the mesh's own extent along the wind. */
     upwind_fetch: f32,
+    /** Amplitude reflection coefficient of the mesh's outline for wave particles: 0 a beach, 1 a wall. */
+    shore_reflection: f32,
     /** Queued splashes: local xz centre, world radius, velocity kick (m/s). */
     impulses: WebGPUArray.from(vec4f, WATER_WAVE_IMPULSE_LIMIT),
     impulse_count: u32,
@@ -25,8 +23,19 @@ export const WATER_WAVE_RECORD_STRUCT = WebGPUStruct.from({
     geometry: u32,
     /** Non-zero to step the body while no view sees it (`Water.simulateWhenHidden`). */
     simulate_hidden: u32,
-    /** GPU: the wind speed and fetch the weights were derived for; the culling pass re-derives when they change. */
-    derived_for: vec2f,
+    /**
+     * GPU: the body's wind, world m/s: the scene's wind field 10 m above its origin (U10), low-passed over the frames
+     * that step. What its fetch, its weights and its turn follow.
+     */
+    wind: vec3f,
+    /** GPU: non-zero once {@link wind} holds a sample; a new row is 0, and its first sample seeds the low-pass. */
+    wind_seeded: u32,
+    /**
+     * GPU: the wind speed (m/s), fetch (m) and wind direction (metric local xz) the weights were derived for. The
+     * culling pass derives again when the low-passed wind leaves the deadband about them, or the fetch along that
+     * direction changes; a negative speed is a row never derived.
+     */
+    derived_for: vec4f,
     /** GPU: amplitude weight of each spectral band, from the wind and the fetch. */
     weights: WebGPUArray.from(f32, WATER_SPECTRUM_BAND_COUNT),
     /** GPU: slope variance of all of the body's ambient waves. */

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

@@ -13,9 +13,6 @@ export const WATER_PARTICLE_GATHER_BUDGET: 64;
  * A pure function of its arguments and the frame's resources. Callers pass the rest point and a footprint
  * computed from the rest point alone, so two cells sharing a vertex displace it identically.
  *
- * Bindings it reads: `scene_database`, `water_band_displacement`, `water_band_derivatives`,
- * `water_band_sampler` (linear, repeat), `water_particle_offsets`, `water_particle_entries`.
- *
  * @type {CodeChunk}
  */
 export const chunk_water_surface_sample: CodeChunk;

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;;;;;GAKG;AACH,8CAA+C;AAE/C;;;;;;;;;;;;GAYG;AACH,yCAFU,SAAS,CAyMyC;0BAlOlC,oCAAoC"}
+{"version":3,"file":"chunk_water_surface_sample.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/water/surface/chunk_water_surface_sample.js"],"names":[],"mappings":"AAcA;;;;;GAKG;AACH,8CAA+C;AAE/C;;;;;;;;;GASG;AACH,yCAFU,SAAS,CAyMyC;0BAvOlC,oCAAoC"}

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

@@ -3,6 +3,14 @@ import { chunk_pcg3d } from "../../shader/chunk/random/pcg/chunk_pcg3d.js";
 import { WATER_WAVES_TABLE } from "../medium/chunk_water_bodies.js";
 import { chunk_water_spectrum } from "./spectrum/chunk_water_spectrum.js";
 import { chunk_water_particle } from "./particles/chunk_water_particle.js";
+import { SCENE_DATABASE_RESOURCE } from "../../scene/SCENE_DATABASE_RESOURCE.js";
+import {
+    WATER_BAND_DERIVATIVES_RESOURCE,
+    WATER_BAND_DISPLACEMENT_RESOURCE,
+    WATER_BAND_SAMPLER_RESOURCE,
+    WATER_PARTICLE_ENTRIES_RESOURCE,
+    WATER_PARTICLE_OFFSETS_RESOURCE
+} from "./WATER_SURFACE_RESOURCES.js";
 
 /**
  * Most particle entries one point reads, over every level. A front's run of particles in a cell is one entry, so a
@@ -20,9 +28,6 @@ export const WATER_PARTICLE_GATHER_BUDGET = 64;
  * A pure function of its arguments and the frame's resources. Callers pass the rest point and a footprint
  * computed from the rest point alone, so two cells sharing a vertex displace it identically.
  *
- * Bindings it reads: `scene_database`, `water_band_displacement`, `water_band_derivatives`,
- * `water_band_sampler` (linear, repeat), `water_particle_offsets`, `water_particle_entries`.
- *
  * @type {CodeChunk}
  */
 export const chunk_water_surface_sample = CodeChunk.from(/* language=WGSL */ `
@@ -225,3 +230,10 @@ fn water_surface_sample(wave: u32, p: vec2<f32>, footprint: f32, horizontal: f32
     WATER_WAVES_TABLE.chunk_read_field('weights'), WATER_WAVES_TABLE.chunk_read_field('wind_from'),
     WATER_WAVES_TABLE.chunk_read_field('wind_to'), WATER_WAVES_TABLE.chunk_read_field('wind_blend'),
     WATER_WAVES_TABLE.chunk_read_field('particle_levels')]);
+
+chunk_water_surface_sample.requireResource(SCENE_DATABASE_RESOURCE);
+chunk_water_surface_sample.requireResource(WATER_BAND_DERIVATIVES_RESOURCE);
+chunk_water_surface_sample.requireResource(WATER_BAND_DISPLACEMENT_RESOURCE);
+chunk_water_surface_sample.requireResource(WATER_BAND_SAMPLER_RESOURCE);
+chunk_water_surface_sample.requireResource(WATER_PARTICLE_ENTRIES_RESOURCE);
+chunk_water_surface_sample.requireResource(WATER_PARTICLE_OFFSETS_RESOURCE);

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

@@ -187,7 +187,7 @@ fn main(@builtin(workgroup_id) group: vec3u, @builtin(local_invocation_index) in
         let threshold = water_particle_threshold(${waves.marshalling_method_read_field('slope_variance')}(&scene_database, particle.body),
             count, frame.capacity);
         let advanced = water_particle_advance(particle, frame.dt, geometry, scale,
-            ${waves.marshalling_method_read_field('wind')}(&scene_database, particle.body).w, threshold, hint);
+            ${waves.marshalling_method_read_field('shore_reflection')}(&scene_database, particle.body), threshold, hint);
         particle = advanced.particle;
         left = advanced.children;
         if (left == 2u || left == 6u) { images[i] = advanced.image; }
@@ -198,7 +198,7 @@ fn main(@builtin(workgroup_id) group: vec3u, @builtin(local_invocation_index) in
     children.elements[i] = left;
 }
 `, [chunk_water_particle_step, chunk_scene_database_access, waves.chunk_read_field('node'), waves.chunk_read_field('slope_variance'),
-    waves.chunk_read_field('geometry'), waves.chunk_read_field('wind'), chunk_folded_workgroup_index]);
+    waves.chunk_read_field('geometry'), waves.chunk_read_field('shore_reflection'), chunk_folded_workgroup_index]);
 update_body.addExtension(WebGPUExtensionType.Subgroups);
 export const shader_water_particles_update = ComputeShader.from({ label: 'Water / particles update', resources: update_resources,
     body: update_body });

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

@@ -17,9 +17,15 @@ export const WATER_LIST_HEADER_BYTES: 16;
  * The frame's culling pass (WATER_SURFACE_DISTANCE_LOD_PROPOSAL_2026_10_06.md §3.1), one thread a water body, before
  * anything simulates. Against the frustum of the view the frame is recorded for, with a prior bound on the body's
  * displacement, it decides whether the body is visible and whether it is simulated this frame, and lists it for the
- * passes that follow. On the way it does the per-body work that used to be passes of its own over every row: weights
- * when the wind or the fetch changed, the wind's turn for a body that is simulated, optics when they were edited.
- * A visible body ORs the bands it can draw into the frame's band mask.
+ * passes that follow. On the way it does the per-body work that used to be passes of its own over every row: the
+ * body's wind, weights when the wind left its deadband or the fetch changed, the wind's turn for a body that is
+ * simulated, optics when they were edited. A visible body ORs the bands it can draw into the frame's band mask.
+ *
+ * **The wind** (GPU_FLUID_CASCADES_PROPOSAL_2026_10_16.md §6, the Water row) is the scene's wind field,
+ * `wind_field_sample`, 10 m above the body's origin, low-passed per body on the frames
+ * that step and seeded from the first sample (`chunk_water_waves_derive`). Every body's is kept, hidden ones
+ * too, since their weights bound what they can reach. The pass reads the field as the frame's producer left it
+ * before it: a field published later in the same frame is read the frame after, which the low-pass does not see.
  */
 export const shader_water_cull: ComputeShader;
 /** Commands the finalize pass writes, in order, 16 bytes apart. */