@woosh/meep-engine 3.49.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";
@@ -14,18 +14,28 @@ import { chunk_ffx_sssr_validate_hit } from "../shader/chunk/screen_space/chunk_
 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 { 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,
@@ -47,30 +57,37 @@ 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');
     }
@@ -78,14 +95,13 @@ function water_resources(finalize = false) {
 }
 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);
 
@@ -312,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; }
@@ -400,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>,
@@ -586,15 +613,14 @@ fn fs_main(in: WaterVertexOut, @builtin(front_facing) above: bool) -> WaterOptic
 `, [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_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. */
@@ -602,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
@@ -622,11 +648,7 @@ function water_pipeline(shader, targets, finalize) {
     });
 }
 export function create_water_pipeline() { return water_pipeline(water_shader, ['rgba32float', 'rgba32float'], false); }
-/** The optics pipeline under IBL, its shader built for `switches` (a ShaderSwitchSet). */
-export function create_water_finalize_pipeline_ibl(switches) {
-    return water_pipeline(water_finalize_shader_ibl.variant(switches), ['rgba32float', 'rgba16float', 'rgba16float'], true);
-}
-/** The optics pipeline under Brick4, its shader built for `switches` (a ShaderSwitchSet). */
-export function create_water_finalize_pipeline_brick4(switches) {
-    return water_pipeline(water_finalize_shader_brick4.variant(switches), ['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/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. */

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

@@ -1 +1 @@
-{"version":3,"file":"shader_water_cull.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/water/surface/shader_water_cull.js"],"names":[],"mappings":"AAoCA,2EAA2E;AAC3E,2CAA4C;AAE5C,0CAA0C;AAC1C;IACI,uDAAuD;;IAEvD,sEAAsE;;GAEvE;AAEH,qDAAqD;AACrD,6CAOuB;AAEvB,+CAA+C;AAC/C,oDAGE;AAEF,8EAA8E;AAC9E,yCAA0C;AA6C1C;;;;;;;GAOG;AACH,8CAsGiG;AAEjG,mEAAmE;AACnE;;;;;GAKG;AACH,8CAA+C;AAC/C,4CAA6C;AAW7C;;;;GAIG;AACH,uDAuBM;6BA9PuB,mCAAmC;8BAVlC,+BAA+B"}
+{"version":3,"file":"shader_water_cull.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/water/surface/shader_water_cull.js"],"names":[],"mappings":"AAsCA,2EAA2E;AAC3E,2CAA4C;AAE5C,0CAA0C;AAC1C;IACI,uDAAuD;;IAEvD,sEAAsE;;GAEvE;AAEH,qDAAqD;AACrD,6CAOuB;AAEvB,+CAA+C;AAC/C,oDAGE;AAEF,8EAA8E;AAC9E,yCAA0C;AA+C1C;;;;;;;;;;;;;GAaG;AACH,8CAoHiG;AAEjG,mEAAmE;AACnE;;;;;GAKG;AACH,8CAA+C;AAC/C,4CAA6C;AAW7C;;;;GAIG;AACH,uDAuBM;6BAtRuB,mCAAmC;8BAVlC,+BAA+B"}

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

@@ -22,7 +22,7 @@ import { WATER_BODIES_TABLE, WATER_WAVES_TABLE } from "../medium/chunk_water_bod
 import { chunk_water_lod } from "./lod/chunk_water_lod.js";
 import { WATER_LOD_VIEW_STRUCT } from "./lod/WATER_LOD.js";
 import { WATER_PARTICLE_LEVELS } from "./particles/chunk_water_particle.js";
-import { chunk_water_waves_derive } from "./shader_water_waves_derive.js";
+import { chunk_water_waves_derive, WATER_WIND_REFERENCE_HEIGHT } from "./shader_water_waves_derive.js";
 import { WATER_PARTICLE_BODY_BOUNDS_STRIDE } from "./shader_water_waves_combine.js";
 import {
     WATER_BAND_REQUESTS_STRUCT,
@@ -33,6 +33,8 @@ import {
 import { chunk_water_spectrum } from "./spectrum/chunk_water_spectrum.js";
 import { WATER_SPECTRUM_COLUMN_GROUPS_PER_BAND, WATER_SPECTRUM_ROW_GROUPS_PER_BAND } from "./spectrum/shader_water_spectrum.js";
 import { WATER_WAVE_IMPULSE_LIMIT } from "./WATER_WAVE_RECORD_STRUCT.js";
+import { chunk_wind_field_sample } from "../../wind/chunk_wind_field_sample.js";
+import { wind_field_add_resources } from "../../wind/wind_field_add_resources.js";
 
 /** Workgroup size of the culling pass and of the passes over its lists. */
 export const WATER_CULL_WORKGROUP_SIZE = 64;
@@ -85,8 +87,10 @@ fn water_cull_ambient(weights: array<f32, WATER_SPECTRUM_BANDS>, blend: f32) ->
 }
 `);
 
+// the scene's wind field adds a uniform, a texture and a sampler, and no storage buffer: the pass is at the 10 a
+// device is asked for
 const resources = new ShaderResourceSetDescriptor();
-resources.createGroup()
+wind_field_add_resources(resources.createGroup()
     .addUniform('cull', WATER_CULL_STRUCT)
     .addUniform('lod', WATER_LOD_VIEW_STRUCT)
     .addUniform('camera', CAMERA_UNIFORM_STRUCT)
@@ -99,7 +103,7 @@ resources.createGroup()
     .addStorageBuffer('activity', WebGPUArray.u32, true)
     .addStorageBuffer('visible_rows', WATER_LIST_APPEND_STRUCT, true)
     .addStorageBuffer('active_rows', WATER_LIST_APPEND_STRUCT, true)
-    .addStorageBuffer('emit_rows', WATER_LIST_APPEND_STRUCT, true);
+    .addStorageBuffer('emit_rows', WATER_LIST_APPEND_STRUCT, true));
 
 const bodies = WATER_BODIES_TABLE, waves = WATER_WAVES_TABLE;
 const pg = bodies.page_iterator_symbol_prefix(64, true);
@@ -111,9 +115,15 @@ const STRIDE = WATER_PARTICLE_BODY_BOUNDS_STRIDE;
  * 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.from({ label: 'Water / cull', resources,
     body: CodeChunk.from(/* language=WGSL */ `
@@ -141,18 +151,33 @@ fn main(@builtin(workgroup_id) group: vec3u, @builtin(local_invocation_index) la
     let scale = max(vec3<f32>(length(global[0].xyz), length(global[1].xyz), length(global[2].xyz)), vec3<f32>(1e-20));
     let box = geometries[${body('geometry')}].bounding_box;
 
-    // weights, when the wind or the fetch they were derived for changed; none without wind
-    let wind = ${read('wind')};
-    let direction = wind.xy / max(length(wind.xy), 1e-20);
-    let fetch = water_waves_fetch(box, scale, direction, ${read('upwind_fetch')});
+    // the body's wind: the field's at U10, low-passed over the frames that step; the first sample seeds it
+    let dt = select(0.0, cull.dt, cull.stepping != 0u);
+    let sample = wind_field_sample(global[3].xyz + vec3<f32>(0.0, ${WATER_WIND_REFERENCE_HEIGHT}.0, 0.0));
+    let seeded = ${read('wind_seeded')} != 0u;
+    let wind = water_wind_low_pass(${read('wind')}, seeded, sample, dt);
+    if (!seeded || dt > 0.0) { ${waves.marshalling_method_write_field('wind')}(&scene_database, row, wind); }
+    if (!seeded) { ${waves.marshalling_method_write_field('wind_seeded')}(&scene_database, row, 1u); }
+    let local = water_wind_local(wind, global, scale);
+    let speed = length(local);
+    var direction = vec2<f32>(0.0);
+    if (speed > 0.0) { direction = local / speed; }
+
+    // weights, when the wind left the deadband about the one they were derived for, or the fetch along its direction
+    // changed; none without wind
+    let reference = ${read('derived_for')};
+    let leaves = water_wind_speed_leaves(reference.x, speed) || (speed > 0.0 && water_wind_direction_leaves(reference.zw, direction));
+    let derived_speed = select(reference.x, speed, leaves);
+    let derived_direction = select(reference.zw, direction, leaves);
+    let fetch = water_waves_fetch(box, scale, derived_direction, ${read('upwind_fetch')});
     var weights: array<f32, WATER_SPECTRUM_BANDS>;
-    if (any(${read('derived_for')} != vec2<f32>(wind.z, fetch))) {
-        let derived = water_waves_derive(wind.z, fetch);
+    if (leaves || fetch != reference.y) {
+        let derived = water_waves_derive(derived_speed, fetch);
         weights = derived.weights;
         ${waves.marshalling_method_write_field('weights')}(&scene_database, row, weights);
         ${waves.marshalling_method_write_field('slope_variance')}(&scene_database, row, derived.slope_variance);
-        ${waves.marshalling_method_write_field('derived_for')}(&scene_database, row, vec2<f32>(wind.z, fetch));
-    } else if (wind.z > 0.0) {
+        ${waves.marshalling_method_write_field('derived_for')}(&scene_database, row, vec4<f32>(derived_speed, fetch, derived_direction));
+    } else if (derived_speed > 0.0) {
         weights = ${read('weights')};
     }
 
@@ -171,7 +196,7 @@ fn main(@builtin(workgroup_id) group: vec3u, @builtin(local_invocation_index) la
             for (var j = 0u; j < queued; j++) { particles += WATER_RING_BOUND * clamp(impulses[j].z, 1e-3, 16.0); }
         }
         var ambient = vec2<f32>(0.0);
-        if (wind.z > 0.0) { ambient = water_cull_ambient(weights, ${read('wind_blend')}); }
+        if (derived_speed > 0.0) { ambient = water_cull_ambient(weights, ${read('wind_blend')}); }
         vertical = 2.0 * ambient.x + particles;
         horizontal = 2.0 * ambient.y + particles;
     }
@@ -183,7 +208,7 @@ fn main(@builtin(workgroup_id) group: vec3u, @builtin(local_invocation_index) la
     let is_visible = aabb3_intersects_frustum(aabb3_project(array_to_aabb3(grown), global), camera.frustum);
     let is_active = is_visible || ${read('simulate_hidden')} != 0u;
 
-    if (is_visible && wind.z > 0.0) {
+    if (is_visible && derived_speed > 0.0) {
         // the bands this body can draw: waves longer than 8 of the finest cells it can be drawn with
         let rest = aabb3_project(array_to_aabb3(box), global);
         let eye = camera.view_matrix_inverse[3].xyz;
@@ -196,8 +221,7 @@ fn main(@builtin(workgroup_id) group: vec3u, @builtin(local_invocation_index) la
         if (mask != 0u) { atomicOr(&band_requests.needed, mask); }
     }
     if (is_active) {
-        let turn = water_wind_turn(WaterWindTurn(${read('wind_from')}, ${read('wind_to')}, ${read('wind_blend')}),
-            direction, select(0.0, cull.dt, cull.stepping != 0u));
+        let turn = water_wind_turn(WaterWindTurn(${read('wind_from')}, ${read('wind_to')}, ${read('wind_blend')}), direction, dt);
         ${waves.marshalling_method_write_field('wind_from')}(&scene_database, row, turn.previous);
         ${waves.marshalling_method_write_field('wind_to')}(&scene_database, row, turn.current);
         ${waves.marshalling_method_write_field('wind_blend')}(&scene_database, row, turn.blend);
@@ -212,10 +236,10 @@ fn main(@builtin(workgroup_id) group: vec3u, @builtin(local_invocation_index) la
     activity[row] = select(0u, ${WaterActivity.Visible}u, is_visible) | select(0u, ${WaterActivity.Active}u, is_active);
 }
 `, [bodies.chunk_iterate(64, true), bodies.chunk_write, bodies.chunk_read_rw,
-        ...['dirty', 'wave', 'node', 'geometry'].map(field => bodies.chunk_read_field(field, true)), ...['wind', 'upwind_fetch', 'weights', 'derived_for', 'wind_blend',
-        'impulses', 'impulse_count', 'simulate_hidden', 'wind_from', 'wind_to'].map(field => waves.chunk_read_field(field, true)),
-        ...['weights', 'slope_variance', 'derived_for', 'wind_from', 'wind_to', 'wind_blend'].map(field => waves.wgsl_gen_write_field_code(field)),
-        chunk_water_cull_bound, chunk_water_spectrum, chunk_water_waves_derive, chunk_water_lod, chunk_water_medium_derived,
+        ...['dirty', 'wave', 'node', 'geometry'].map(field => bodies.chunk_read_field(field, true)), ...['wind', 'wind_seeded', 'upwind_fetch', 'weights',
+        'derived_for', 'wind_blend', 'impulses', 'impulse_count', 'simulate_hidden', 'wind_from', 'wind_to'].map(field => waves.chunk_read_field(field, true)),
+        ...['wind', 'wind_seeded', 'weights', 'slope_variance', 'derived_for', 'wind_from', 'wind_to', 'wind_blend'].map(field => waves.wgsl_gen_write_field_code(field)),
+        chunk_wind_field_sample, chunk_water_cull_bound, chunk_water_spectrum, chunk_water_waves_derive, chunk_water_lod, chunk_water_medium_derived,
         chunk_water_medium_scattering, chunk_scene_database_access_rw, chunk_folded_workgroup_index, chunk_aabb3_project,
         chunk_array_to_aabb3, chunk_aabb3_intersects_frustum, chunk_mat4_linear_determinant]) });