@woosh/meep-engine 3.38.0 → 3.40.0

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

@@ -2,6 +2,15 @@ import { CodeChunk } from '../shader/compiler/CodeChunk.js';
 import { chunk_decode_g_buffer_normal } from '../shader/chunk/geometry/normal/chunk_decode_g_buffer_normal.js';
 import { chunk_inv_project_position } from '../shader/chunk/screen_space/chunk_inv_project_position.js';
 import { chunk_is_background } from '../shader/chunk/depth/chunk_is_background.js';
+import { chunk_screen_space_newton_ray } from '../shader/chunk/screen_space/chunk_screen_space_newton_ray.js';
+import { chunk_texel_coordinate_to_uv } from '../shader/chunk/texture/chunk_texel_coordinate_to_uv.js';
+import { chunk_get_bilinear_filter_uv } from '../shader/chunk/texture/sample/chunk_get_bilinear_filter_uv.js';
+
+// How far above the water level a screen-space receiver may lie and still count as submerged.
+// Receiver selection and the optics' color gather must agree on it.
+export const WATER_LEVEL_TOLERANCE_DECLARATION = CodeChunk.from(/* language=WGSL */ `
+const WATER_LEVEL_TOLERANCE: f32 = 0.02;
+`);
 
 export const chunk_water_refraction_confidence = CodeChunk.from(/* language=WGSL */ `
 fn water_refraction_lookup(original: vec2f, receiver: vec2f, confidence: f32) -> vec2f {
@@ -11,79 +20,80 @@ fn water_refraction_confidence(uv: vec2f, original_uv: vec2f, size: vec2f, dista
     let displacement = length((uv - original_uv) * size);
     let fade_width = clamp(displacement, 8.0, 64.0);
     let visibility = smoothstep(0.0, fade_width, distance_tiles * 4.0);
-    let source_edge = min(min(original_uv.x, original_uv.y), min(1.0-original_uv.x, 1.0-original_uv.y));
-    let receiver_edge = min(min(uv.x, uv.y), min(1.0-uv.x, 1.0-uv.y));
+    // Distance from the frame border of whichever of source and receiver is nearer to it.
+    let edge = min(min(original_uv, 1.0 - original_uv), min(uv, 1.0 - uv));
     // Approaching an off-screen receiver must approach the control lookup continuously,
     // even while the water fragment itself is far enough from the frame border.
     return visibility * smoothstep(0.0, clamp(displacement / min(size.x, size.y), 0.01, 0.1),
-        min(source_edge, receiver_edge));
+        min(edge.x, edge.y));
 }
 `);
 
 export const chunk_water_transport = CodeChunk.from(/* language=WGSL */ `
 struct WaterEvent { transmission: vec3f, radiance: vec3f }
 struct WaterTransport { transmission: vec3f, radiance: vec3f, background: vec3f }
-fn water_event(path: f32, extinction: vec3f, fresnel: f32, reflection: vec3f, body: vec3f) -> WaterEvent {
-    let absorption = exp(-max(extinction, vec3f(0.0)) * max(path, 0.0));
-    let raw = (1.0 - fresnel) * absorption;
-    let t = max(raw, vec3f(1e-6));
-    let scale = (1.0 - t) / max(1.0 - raw, vec3f(1e-20));
-    return WaterEvent(t, scale * (fresnel * reflection + (1.0-fresnel) * (1.0-absorption) * body));
+// The water's own event at one pixel, before coverage: the fraction of the radiance behind it that
+// it transmits, and the radiance it sends towards the camera itself. A transmittance under the floor
+// AVBOIT can encode is raised to it, and the radiance scaled with the lost throughput so the shared
+// normalization still returns it whole.
+fn water_event(transmission: vec3f, radiance: vec3f) -> WaterEvent {
+    let t = max(transmission, vec3f(1e-6));
+    let scale = (1.0 - t) / max(1.0 - transmission, vec3f(1e-20));
+    return WaterEvent(t, select(scale, vec3f(1.0), transmission >= vec3f(1e-6)) * radiance);
 }
 // One selected lookup and its optical event. Only geometric coverage mixes images;
 // fading refraction interpolates the lookup UV before sampling, never two displaced colors.
 fn water_transport(event: WaterEvent, original: vec3f, receiver: vec3f,
     coverage: f32) -> WaterTransport {
     let a = clamp(coverage, 0.0, 1.0);
-    let t = (1.0-a) + a * event.transmission;
+    let t = mix(vec3f(1.0), event.transmission, a);
     let w = a * event.radiance;
-    let background = ((1.0-a)*original + a*event.transmission*receiver) / t;
+    let background = mix(original, event.transmission * receiver, a) / t;
     return WaterTransport(t, w, background);
 }
 `);
 
+// One G-buffer texel in world space: its stored depth, texel-center position and face normal.
+export const chunk_water_receiver_texel = CodeChunk.from(/* language=WGSL */ `
+struct WaterReceiverTexel { depth: f32, position: vec3f, 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));
+}
+`, [chunk_decode_g_buffer_normal, chunk_inv_project_position, chunk_texel_coordinate_to_uv]);
+
 // Filtering radiance across a silhouette must not introduce a surface that the ray never hit.
 // The center depth/face normal define receiver ownership; taps must lie on that same local plane.
 export const chunk_water_receiver_radiance = CodeChunk.from(/* language=WGSL */ `
-// Depth is stored at the texel center. Intersect the lookup's camera ray with that
-// local plane so subpixel lookup motion does not quantize water thickness.
+// Depth is stored at the texel center. Reconstruct the lookup on that texel's tangent
+// plane so subpixel lookup motion does not quantize water thickness.
 fn water_receiver_path(depth: texture_2d<f32>, normals: texture_2d<u32>, uv: vec2f,
     inverse_projection: mat4x4f, world_to_view: mat4x4f, origin: vec3f) -> f32 {
-    let size = vec2f(textureDimensions(depth, 0));
-    let coord = clamp(vec2i(uv*size), vec2i(0), vec2i(size)-1);
-    let d = textureLoad(depth, coord, 0).r;
-    let p = inv_project_position(vec3f((vec2f(coord)+0.5)/size,d), inverse_projection);
-    let direction = inv_project_position(vec3f(uv,d), inverse_projection);
-    let n = (world_to_view * vec4f(decode_g_buffer_normal(textureLoad(normals,coord,0).zw),0.0)).xyz;
-    let denominator = dot(n,direction);
-    if (abs(denominator) <= 1e-6) { return distance(origin,p); }
-    return distance(origin, direction * (dot(n,p)/denominator));
+    let receiver = screen_space_ray_load_receiver(uv, depth, normals, inverse_projection, world_to_view);
+    return distance(origin, screen_space_ray_lookup_position(uv, receiver, inverse_projection).xyz);
 }
 fn water_receiver_radiance(scene: texture_2d<f32>, depth: texture_2d<f32>, normals: texture_2d<u32>,
-    uv: vec2f, inverse_projection: mat4x4f, inverse_view: mat4x4f, level: f32, below_interface: bool) -> vec4f {
+    uv: vec2f, inverse_projection: mat4x4f, inverse_view: mat4x4f, surface: vec3f, surface_normal: vec3f, below_interface: bool) -> vec4f {
     let size = vec2i(textureDimensions(depth, 0));
-    let center = clamp(vec2i(uv * vec2f(size)), vec2i(0), size-1);
-    let center_depth = textureLoad(depth, center, 0).r;
-    if (is_background(center_depth)) { return vec4f(0.0); }
-    let center_vs = inv_project_position(vec3f((vec2f(center)+0.5)/vec2f(size), center_depth), inverse_projection);
-    let p = (inverse_view * vec4f(center_vs, 1.0)).xyz;
-    let n = decode_g_buffer_normal(textureLoad(normals, center, 0).zw);
-    if (below_interface && p.y > level + 0.02) { return vec4f(0.0); }
-    let texel = uv * vec2f(size) - 0.5;
-    let base = vec2i(floor(texel));
-    let f = fract(texel);
+    let center = water_receiver_texel(depth, normals, clamp(vec2i(uv * vec2f(size)), vec2i(0), size-1),
+        inverse_projection, inverse_view);
+    if (is_background(center.depth)
+        || (below_interface && dot(center.position - surface, surface_normal) > WATER_LEVEL_TOLERANCE)) { return vec4f(0.0); }
+    let bilinear = get_bilinear_filter_uv(uv, vec2u(size));
+    let base = vec2i(bilinear.origin);
+    let f = bilinear.weights;
     var color = vec3f(0.0);
     var weight = 0.0;
     for (var y = 0; y < 2; y++) {
         for (var x = 0; x < 2; x++) {
             let coord = clamp(base + vec2i(x,y), vec2i(0), size-1);
-            let d = textureLoad(depth, coord, 0).r;
-            if (is_background(d)) { continue; }
-            let tap_vs = inv_project_position(vec3f((vec2f(coord)+0.5)/vec2f(size), d), inverse_projection);
-            let tap = (inverse_view * vec4f(tap_vs, 1.0)).xyz;
-            let tap_n = decode_g_buffer_normal(textureLoad(normals, coord, 0).zw);
-            if ((below_interface && tap.y > level+0.02) || dot(n,tap_n) < 0.95
-                || abs(dot(tap-p,n)) > 0.02) { continue; }
+            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; }
             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;
@@ -91,4 +101,5 @@ fn water_receiver_radiance(scene: texture_2d<f32>, depth: texture_2d<f32>, norma
     }
     return vec4f(color / max(weight, 1e-20), weight);
 }
-`, [chunk_decode_g_buffer_normal, chunk_inv_project_position, chunk_is_background]);
+`, [chunk_is_background, chunk_screen_space_newton_ray, chunk_get_bilinear_filter_uv,
+    chunk_water_receiver_texel, WATER_LEVEL_TOLERANCE_DECLARATION]);

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

@@ -0,0 +1,15 @@
+/** GPU work over the scene's water table; no per-body render commands or transient body uniforms. */
+export class GPUWaterBodies {
+    record({ graph, scene }: {
+        graph: any;
+        scene: any;
+    }): void;
+    /** Ordered prefix expansion preserves equal-depth ownership, including after holes and reuse. */
+    meshlets({ graph, view, camera, meshlet_capacity }: {
+        graph: any;
+        view: any;
+        camera: any;
+        meshlet_capacity: any;
+    }): any;
+}
+//# sourceMappingURL=GPUWaterBodies.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"GPUWaterBodies.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/water/medium/GPUWaterBodies.js"],"names":[],"mappings":"AAUA,qGAAqG;AACrG;IACI;;;aASC;IAED,iGAAiG;IACjG;;;;;YAsCC;CACJ"}

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

@@ -0,0 +1,64 @@
+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 { INDIRECT_COMPUTE_COMMAND_DESCRIPTOR } from "../../gpu_primitive/indirect/IndirectComputeCommandBuildPass.js";
+import { shader_prefix_sum_to_command } from "../../rasterize/expand/mesh/shader_prefix_sum_to_command.js";
+import { shader_increment_count_by_prefix_sum } from "../../rasterize/expand/mesh/shader_increment_count_by_prefix_sum.js";
+import { graph_compute_pass } from "../../shader/graph/compute/graph_compute_pass.js";
+import { shader_water_meshlet_counts, shader_water_meshlets_expand } from "./shader_water_meshlets.js";
+import { shader_water_bodies_derive, WORKGROUP_SIZE } from "./shader_water_bodies_derive.js";
+
+/** GPU work over the scene's water table; no per-body render commands or transient body uniforms. */
+export class GPUWaterBodies {
+    record({ graph, scene }) {
+        const table = scene.scene_database.get('water_bodies');
+        const groups = table.dispatch_group_count(WORKGROUP_SIZE);
+        if (groups === 0) { return; }
+        const pass = graph.add('Water / bodies derive', {}, (_data, _resources, { encoder }) => {
+            shader_water_bodies_derive.dispatch({ encoder, bindings: { scene_database: scene.scene_database_buffer },
+                group_count_x: Math.min(groups, 65535), group_count_y: Math.ceil(groups / 65535) });
+        });
+        pass.make_side_effect();
+    }
+
+    /** Ordered prefix expansion preserves equal-depth ownership, including after holes and reuse. */
+    meshlets({ graph, view, camera, meshlet_capacity }) {
+        const scene = view.scene, table = scene.scene_database.get('water_bodies');
+        const capacity = table.element_capacity;
+        const data = {};
+        const pass = graph.add('Water / meshlet counts', data, (d, resources, { encoder }) => {
+            const groups = table.dispatch_group_count(64);
+            shader_water_meshlet_counts.dispatch({ encoder, bindings: {
+                capacity: round_up(capacity, 4), camera: resources.get(d.camera), scene_database: scene.scene_database_buffer,
+                geometries: scene.geometries.buffer_metadata, counts: resources.get(d.counts),
+            }, group_count_x: Math.min(groups, 65535), group_count_y: Math.ceil(groups / 65535) });
+        });
+        data.camera = pass.read(camera);
+        // The shared scan reads vec4u blocks, including the padded final block.
+        const bytes = 16 + round_up(capacity, 4) * 4;
+        data.counts = pass.create('counts', BufferResourceDescriptor.from(bytes, GPUBufferUsage.STORAGE, 0, bytes));
+        const sums = graph_prefix_scan_csdldf({ graph, data: data.counts, 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: {
+                prefix_sums: resources.get(d.sums), command: resources.get(d.command),
+            } });
+        });
+        command_data.sums = command_pass.read(sums);
+        const command = command_data.command = command_pass.create('command', INDIRECT_COMPUTE_COMMAND_DESCRIPTOR);
+        const expand_data = {};
+        const expand = graph.add('Water / expand meshlets', expand_data, (d, resources, { encoder }) => {
+            shader_water_meshlets_expand.dispatchIndirect({ encoder, command: resources.get(d.command), bindings: {
+                prefix_sums: resources.get(d.sums), output: resources.get(d.output),
+                scene_database: scene.scene_database_buffer, geometries: scene.geometries.buffer_metadata,
+            } });
+        });
+        expand_data.command = expand.read(command);
+        expand_data.sums = expand.read(sums);
+        expand_data.output = expand.create('meshlets', BufferResourceDescriptor.from(16 + meshlet_capacity * 8,
+            GPUBufferUsage.STORAGE, 0, 16));
+        const { output } = graph_compute_pass({ graph, shader: shader_increment_count_by_prefix_sum,
+            bindings: { prefix_sums: sums, output: expand_data.output } });
+        return output;
+    }
+}

package/src/shade/renderer/water/medium/WATER_BODIES_STRUCT.d.ts

@@ -0,0 +1,4 @@
+/** A persistent scene row. Geometry and node refer to the shared scene resources. */
+export const WATER_BODY_STRUCT: WebGPUStruct;
+import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
+//# sourceMappingURL=WATER_BODIES_STRUCT.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"WATER_BODIES_STRUCT.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/water/medium/WATER_BODIES_STRUCT.js"],"names":[],"mappings":"AAIA,qFAAqF;AACrF,6CAIgB;6BAPa,mCAAmC"}

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

@@ -0,0 +1,10 @@
+import { MEDIUM_STRUCT } from "../../medium/MEDIUM_STRUCT.js";
+import { f32, u32, vec4f } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
+
+/** A persistent scene row. Geometry and node refer to the shared scene resources. */
+export const WATER_BODY_STRUCT = WebGPUStruct.from({
+    geometry: u32, node: u32, wave: u32, roughness: f32, dirty: u32,
+    medium: MEDIUM_STRUCT, ior: f32,
+    backscattering: vec4f, extinction: vec4f, diffuse_transmittance: f32,
+}, "WaterBody");

package/src/shade/renderer/water/medium/chunk_water_bodies.d.ts

@@ -0,0 +1,3 @@
+export const WATER_BODIES_TABLE: import("../../buffer/table/GPUTypedTableDescriptor.js").GPUTypedTableDescriptor;
+export const WATER_WAVES_TABLE: import("../../buffer/table/GPUTypedTableDescriptor.js").GPUTypedTableDescriptor;
+//# sourceMappingURL=chunk_water_bodies.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_water_bodies.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/water/medium/chunk_water_bodies.js"],"names":[],"mappings":"AACA,iHAA0E;AAC1E,gHAAwE"}

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

@@ -0,0 +1,3 @@
+import { SCENE_DATABASE_SPEC } from "../../scene/SCENE_DATABASE_SPEC.js";
+export const WATER_BODIES_TABLE = SCENE_DATABASE_SPEC.get('water_bodies');
+export const WATER_WAVES_TABLE = SCENE_DATABASE_SPEC.get('water_waves');

package/src/shade/renderer/water/medium/chunk_water_medium_derived.d.ts

@@ -0,0 +1,9 @@
+/**
+ * What water's lighting needs from a medium beyond its coefficients, integrated from the medium's own
+ * phase functions and from the exact Fresnel term rather than tabulated beside them.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_water_medium_derived: CodeChunk;
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_water_medium_derived.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_water_medium_derived.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/water/medium/chunk_water_medium_derived.js"],"names":[],"mappings":"AAMA;;;;;GAKG;AACH,yCAFU,SAAS,CA4CgF;0BAlDzE,oCAAoC"}

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

@@ -0,0 +1,55 @@
+import { chunk_medium_lobe_phase } from "../../medium/chunk_medium_lobe_phase.js";
+import { MEDIUM_STRUCT } from "../../medium/MEDIUM_STRUCT.js";
+import { chunk_F_dielectric } from "../../shader/chunk/brdf/fresnel/chunk_F_dielectric.js";
+import { PI_DECLARATION } from "../../shader/chunk/math/PI_DECLARATION.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+
+/**
+ * What water's lighting needs from a medium beyond its coefficients, integrated from the medium's own
+ * phase functions and from the exact Fresnel term rather than tabulated beside them.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_water_medium_derived = CodeChunk.from(/* language=WGSL */ `
+const WATER_DERIVE_PANELS: u32 = 64u;
+
+// Simpson weight of node i of WATER_DERIVE_PANELS panels.
+fn water_simpson_weight(i: u32) -> f32 {
+    if (i == 0u || i == WATER_DERIVE_PANELS) { return 1.0; }
+    return select(2.0, 4.0, i % 2u == 1u);
+}
+
+// Fraction of one lobe's scattering sent backwards: the integral of its phase function over the
+// backward hemisphere. That hemisphere holds no forward peak, so Simpson's rule in cos θ over
+// [-1, 0] converges quickly even for a Fournier-Forand lobe.
+fn water_lobe_backscatter_fraction(lobe: MediumPhaseLobe) -> f32 {
+    let h = 1.0 / f32(WATER_DERIVE_PANELS);
+    var sum = 0.0;
+    for (var i = 0u; i <= WATER_DERIVE_PANELS; i++) {
+        let mu = -1.0 + f32(i) * h;
+        sum += water_simpson_weight(i) * medium_lobe_phase(lobe, mu, 0.5 * (1.0 - mu));
+    }
+    return 2.0 * PI * sum * h / 3.0;
+}
+
+// Backscattering coefficient b_b = Σ b_i · B_i of a medium, RGB 1/m.
+fn water_medium_backscattering(medium: ParticipatingMedium) -> vec3<f32> {
+    var result = vec3<f32>(0.0);
+    for (var l = 0u; l < medium.lobe_count; l++) {
+        result += medium.lobes[l].scattering * water_lobe_backscatter_fraction(medium.lobes[l]);
+    }
+    return result;
+}
+
+// Hemispherical Fresnel transmittance into the water for a uniform sky: 2 ∫ (1 − F(μ)) μ dμ over
+// μ in [0, 1], F the exact dielectric reflectance at the given index.
+fn water_diffuse_fresnel_transmittance(ior: f32) -> f32 {
+    let h = 1.0 / f32(WATER_DERIVE_PANELS);
+    var sum = 0.0;
+    for (var i = 0u; i <= WATER_DERIVE_PANELS; i++) {
+        let mu = f32(i) * h;
+        sum += water_simpson_weight(i) * (1.0 - F_dielectric(mu, ior)) * mu;
+    }
+    return 2.0 * sum * h / 3.0;
+}
+`, [MEDIUM_STRUCT.declaration_chunk, chunk_medium_lobe_phase, chunk_F_dielectric, PI_DECLARATION]);

package/src/shade/renderer/water/medium/chunk_water_medium_scattering.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Total scattering coefficient of a medium, the sum of its lobes', RGB 1/m.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_water_medium_scattering: CodeChunk;
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_water_medium_scattering.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_water_medium_scattering.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/water/medium/chunk_water_medium_scattering.js"],"names":[],"mappings":"AAGA;;;;GAIG;AACH,4CAFU,SAAS,CAUmB;0BAfZ,oCAAoC"}

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

@@ -0,0 +1,17 @@
+import { MEDIUM_STRUCT } from "../../medium/MEDIUM_STRUCT.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+
+/**
+ * Total scattering coefficient of a medium, the sum of its lobes', RGB 1/m.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_water_medium_scattering = CodeChunk.from(/* language=WGSL */ `
+fn water_medium_scattering(medium: ParticipatingMedium) -> vec3<f32> {
+    var result = vec3<f32>(0.0);
+    for (var l = 0u; l < medium.lobe_count; l++) {
+        result += medium.lobes[l].scattering;
+    }
+    return result;
+}
+`, [MEDIUM_STRUCT.declaration_chunk]);

package/src/shade/renderer/water/medium/shader_water_bodies_derive.d.ts

@@ -0,0 +1,4 @@
+export const WORKGROUP_SIZE: 64;
+export const shader_water_bodies_derive: ComputeShader;
+import { ComputeShader } from "../../shader/ComputeShader.js";
+//# sourceMappingURL=shader_water_bodies_derive.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"shader_water_bodies_derive.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/water/medium/shader_water_bodies_derive.js"],"names":[],"mappings":"AASA,gCAAiC;AAIjC,uDAkBG;8BA/B2B,+BAA+B"}

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

@@ -0,0 +1,32 @@
+import { ComputeShader } from "../../shader/ComputeShader.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
+import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
+import { chunk_water_medium_derived } from "./chunk_water_medium_derived.js";
+import { chunk_water_medium_scattering } from "./chunk_water_medium_scattering.js";
+import { WATER_BODIES_TABLE as table } from "./chunk_water_bodies.js";
+import { chunk_folded_workgroup_index } from "../../shader/chunk/grid/chunk_folded_workgroup_index.js";
+
+export const WORKGROUP_SIZE = 64;
+const pg = table.page_iterator_symbol_prefix(WORKGROUP_SIZE, true);
+const resources = new ShaderResourceSetDescriptor();
+resources.createGroup().addStorageBuffer('scene_database', WebGPUArray.u32, true);
+export const shader_water_bodies_derive = ComputeShader.from({
+    label: "Water / bodies derive", resources,
+    body: CodeChunk.from(/* language=WGSL */ `
+@compute @workgroup_size(${WORKGROUP_SIZE})
+fn main(@builtin(workgroup_id) group: vec3u, @builtin(local_invocation_index) lane: u32) {
+    if (!${pg}_setup(&scene_database, folded_workgroup_index(group), lane)) { return; }
+    let slot = ${pg}_slot_in_page(lane);
+    if (slot >= ${pg}_ELEMENTS_PER_PAGE || !${pg}_is_occupied(slot)) { return; }
+    var body = ${pg}_read(&scene_database, slot);
+    if (body.dirty == 0u) { return; }
+    body.backscattering = vec4f(water_medium_backscattering(body.medium), 0.0);
+    body.extinction = vec4f(body.medium.absorption + water_medium_scattering(body.medium), 0.0);
+    body.diffuse_transmittance = water_diffuse_fresnel_transmittance(body.ior);
+    body.dirty = 0u;
+    ${table.marshalling_method_write}(&scene_database, ${pg}_slot_to_index(slot), body);
+}
+`, [table.chunk_iterate(WORKGROUP_SIZE, true), table.chunk_write, chunk_water_medium_derived,
+        chunk_water_medium_scattering, chunk_folded_workgroup_index]),
+});

package/src/shade/renderer/water/medium/shader_water_meshlets.d.ts

@@ -0,0 +1,4 @@
+export const shader_water_meshlet_counts: ComputeShader;
+export const shader_water_meshlets_expand: ComputeShader;
+import { ComputeShader } from "../../shader/ComputeShader.js";
+//# sourceMappingURL=shader_water_meshlets.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"shader_water_meshlets.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/water/medium/shader_water_meshlets.js"],"names":[],"mappings":"AAyBA,wDAsBkH;AAOlH,yDAcsF;8BAhExD,+BAA+B"}

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

@@ -0,0 +1,69 @@
+import { CAMERA_UNIFORM_STRUCT } from "../../camera/CAMERA_UNIFORM_STRUCT.js";
+import { GEOMETRY_METADATA_STRUCT } from "../../geometry/GEOMETRY_METADATA_STRUCT.js";
+import { MESHLET_COLLECTION_STRUCT } from "../../rasterize/MESHLET_COLLECTION_STRUCT.js";
+import { COLLECTION_U32_STRUCT_READ } from "../../gpu_primitive/COLLECTION_U32_STRUCT_READ.js";
+import { ComputeShader } from "../../shader/ComputeShader.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
+import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
+import { chunk_scene_database_access } from "../../scene/chunk_scene_database_access.js";
+import { chunk_folded_workgroup_index } from "../../shader/chunk/grid/chunk_folded_workgroup_index.js";
+import { chunk_lower_bound_branchless } from "../../shader/chunk/math/chunk_lower_bound_branchless.js";
+import { WATER_BODIES_TABLE as table, WATER_WAVES_TABLE } from "./chunk_water_bodies.js";
+import { chunk_aabb3_project } from "../../shader/chunk/geometry/aabb3/chunk_aabb3_project.js";
+import { chunk_aabb3_intersects_frustum } from "../../shader/chunk/geometry/aabb3/chunk_aabb3_intersects_frustum.js";
+import { chunk_array_to_aabb3 } from "../../shader/chunk/geometry/aabb3/chunk_array_to_aabb3.js";
+import { chunk_mat4_linear_determinant } from "../../shader/chunk/geometry/mat4/chunk_mat4_linear_determinant.js";
+import { u32 } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+
+const pg = table.page_iterator_symbol_prefix(64);
+const counts_resources = new ShaderResourceSetDescriptor();
+counts_resources.setImmediate('capacity', u32);
+counts_resources.createGroup().addUniform('camera', CAMERA_UNIFORM_STRUCT)
+    .addStorageBuffer('scene_database', WebGPUArray.u32)
+    .addStorageBuffer('geometries', WebGPUArray.from(GEOMETRY_METADATA_STRUCT))
+    .addStorageBuffer('counts', COLLECTION_U32_STRUCT_READ, true);
+export const shader_water_meshlet_counts = ComputeShader.from({ label: 'Water / meshlet counts', resources: counts_resources,
+    body: CodeChunk.from(/* language=WGSL */ `
+@compute @workgroup_size(64)
+fn main(@builtin(workgroup_id) group: vec3u, @builtin(local_invocation_index) lane: u32) {
+    if (all(group == vec3u(0)) && lane == 0u) { counts.count = capacity; }
+    if (!${pg}_setup(&scene_database, folded_workgroup_index(group), lane)) { return; }
+    let slot = ${pg}_slot_in_page(lane);
+    if (slot >= ${pg}_ELEMENTS_PER_PAGE || !${pg}_is_occupied(slot)) { return; }
+    let body = ${pg}_read(&scene_database, slot);
+    let geometry = geometries[body.geometry];
+    let node = scene_read_node(&scene_database, body.node);
+    if (abs(mat4_linear_determinant(node.global)) < 1e-20) { return; }
+    var box = geometry.bounding_box;
+    if (body.wave != ~0u) {
+        let displacement = ${WATER_WAVES_TABLE.marshalling_method_read}(&scene_database, body.wave).displacement_bounds;
+        box[1] += displacement.x; box[4] += displacement.y;
+    }
+    let bounds = aabb3_project(array_to_aabb3(box), node.global);
+    if (!aabb3_intersects_frustum(bounds, camera.frustum)) { return; }
+    counts.elements[${pg}_slot_to_index(slot)] = geometry.meshlets_count;
+}
+`, [table.chunk_iterate(64), WATER_WAVES_TABLE.chunk_read, chunk_scene_database_access, chunk_folded_workgroup_index,
+    chunk_aabb3_project, chunk_array_to_aabb3, chunk_aabb3_intersects_frustum, chunk_mat4_linear_determinant]) });
+
+const expand_resources = new ShaderResourceSetDescriptor();
+expand_resources.createGroup().addStorageBuffer('prefix_sums', COLLECTION_U32_STRUCT_READ)
+    .addStorageBuffer('scene_database', WebGPUArray.u32)
+    .addStorageBuffer('geometries', WebGPUArray.from(GEOMETRY_METADATA_STRUCT))
+    .addStorageBuffer('output', MESHLET_COLLECTION_STRUCT, true);
+export const shader_water_meshlets_expand = ComputeShader.from({ label: 'Water / expand meshlets', resources: expand_resources,
+    body: CodeChunk.from(/* language=WGSL */ `
+@compute @workgroup_size(128)
+fn main(@builtin(workgroup_id) group: vec3u, @builtin(local_invocation_index) lane: u32) {
+    let i = folded_workgroup_index(group) * 128u + lane;
+    let row = lower_bound_branchless(&prefix_sums.elements, i + 1u, prefix_sums.count);
+    if (row >= prefix_sums.count) { return; }
+    var previous = 0u;
+    if (row > 0u) { previous = prefix_sums.elements[row - 1u]; }
+    let body = ${table.marshalling_method_read}(&scene_database, row);
+    let geometry = geometries[body.geometry];
+    output.elements[i].index = geometry.meshlets_address + i - previous;
+    output.elements[i].mesh = row;
+}
+`, [table.chunk_read, chunk_folded_workgroup_index, chunk_lower_bound_branchless]) });

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

@@ -0,0 +1,28 @@
+/**
+ * Light the water body sends back towards a viewer above it (WATER_OPTICS_PLAN_2026_10_02.md §4.4):
+ * the column term of Lee et al.'s shallow-water model (1998), with the deep-water reflectance from
+ * QAA (Lee et al. 2002, v6), integrated along the refracted view ray.
+ *
+ * Per channel, with κ = a + b_b and u = b_b / κ:
+ *
+ * - deep-water subsurface remote-sensing reflectance r_rs∞ = (0.089 + 0.1245 u) u, a fit to full
+ *   radiative transfer, so it carries every order of scattering, not one;
+ * - the upwelling light attenuates along the view ray at κ_u = 1.03 √(1 + 2.4 u) κ, Lee's D_u^C κ:
+ *   light scattered forward stays in the upwelling stream, which beam attenuation would throw away;
+ * - each source j — the refracted sun, shadowed by the cascaded shadow map per segment, and the sky the
+ *   active GI mode reports at the surface — feeds the ray r_rs∞ (K_j + κ_u) E_d,j(z) per metre, where
+ *   E_d,j(z) is its plane irradiance at depth decaying at Gordon's K_j. Deep water seen from straight
+ *   above then returns exactly r_rs∞ E_d(0−), and a column of depth H the factor 1 − e^−(K + κ_u) H;
+ * - the upwelling light the surface reflects back down returns again: 1 / (1 − 1.7 r_rs∞).
+ *
+ * The medium's phase functions enter through b_b, which the bodies table integrates from them on the
+ * GPU. The model is gated against the Monte Carlo slab oracle (`water_inscatter_oracle.spec.js`).
+ *
+ * Expects `light_data` and the shadow atlas bindings, and a `water_gi_irradiance` from one of the GI
+ * modules. Returns radiance arriving at the surface from below; the caller takes it out of the water.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_water_inscatter: CodeChunk;
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_water_inscatter.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_water_inscatter.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/water/optics/chunk_water_inscatter.js"],"names":[],"mappings":"AAYA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,oCAFU,SAAS,CAwFmF;0BApH5E,oCAAoC"}