@woosh/meep-engine 3.47.0 → 3.49.0

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

@@ -1,49 +1,28 @@
-import { chunk_ndc_to_uv } from "../shader/chunk/texture/chunk_ndc_to_uv.js";
-import { CodeChunk } from "../shader/compiler/CodeChunk.js";
-import { chunk_volumetrics_froxel_content_offset } from "./chunk_volumetrics_froxel_content_offset.js";
-
-/**
- * NOTE: we don't clamp final slice coordinate, this is intentional, we let the linear texture sampler take care of that.
- * See {@link build_light_cluster_parameters}
- * @type {CodeChunk}
- */
-export const volumetrics_position_world_to_froxel_uvw = CodeChunk.from(
-    //language=WGSL
-    `
-fn volumetrics_position_world_to_froxel_uvw(
-    position_ws: vec3<f32>
-) -> vec3<f32>{
-
-    let position_vs = camera.view_matrix * vec4(position_ws, 1.0);
-    let position_clip = camera.projection_matrix * position_vs;
-    
-    let uv = ndc_to_uv(position_clip.xy / position_clip.w);
- 
-    let view_depth = -position_vs.z;
-
-    // froxel_cluster_parameters, NOT cluster_parameters: this addresses the FROXEL grid, which the
-    // participating-media pass builds on that curve. cluster_parameters is the aerial LUT's. The
-    // two are identical while froxel_far is unset — which is why the mix-up went unnoticed — and
-    // diverge as soon as the grid is packed into a shorter range.
-    let cluster_parameters = volumetrics_metadata.froxel_cluster_parameters;
-
-    // see 'cluster_depth_to_z_slice' for explanation
-    let slice_position:f32 = log2(fma(view_depth, cluster_parameters.x, cluster_parameters.y)) * cluster_parameters.z;
-
-    // A cell-averaged grid: texel k holds the slab [k+j, k+1+j], not the point at slice k, so the
-    // texel-centre convention alone reads about half a froxel too far out. See
-    // chunk_volumetrics_froxel_content_offset for where the ~0.53 comes from.
-    let content_offset = volumetrics_froxel_content_offset(cluster_parameters.z);
-
-    let w = (slice_position + 0.5 - content_offset) / f32(volumetrics_metadata.resolution.z);
-    
-    return vec3(
-        uv,
-        w
-    );
-}
-    `, [
-        chunk_ndc_to_uv,
-        chunk_volumetrics_froxel_content_offset,
-    ]
-)
+import { CodeChunk } from "../shader/compiler/CodeChunk.js";
+import { chunk_volumetrics_froxel_content_offset } from "./chunk_volumetrics_froxel_content_offset.js";
+import { chunk_volumetrics_froxel_uvw_from_clip } from "./chunk_volumetrics_froxel_uvw_from_clip.js";
+
+/**
+ * NOTE: we don't clamp final slice coordinate, this is intentional, we let the linear texture sampler take care of that.
+ * See {@link build_light_cluster_parameters}
+ * @type {CodeChunk}
+ */
+export const volumetrics_position_world_to_froxel_uvw = CodeChunk.from(
+    //language=WGSL
+    `
+fn volumetrics_position_world_to_froxel_uvw(
+    position_ws: vec3<f32>
+) -> vec3<f32>{
+
+    let position_vs = camera.view_matrix * vec4(position_ws, 1.0);
+    let position_clip = camera.projection_matrix * position_vs;
+
+    let content_offset = volumetrics_froxel_content_offset(volumetrics_metadata.froxel_cluster_parameters.z);
+
+    return volumetrics_froxel_uvw_from_clip(position_clip, -position_vs.z, content_offset);
+}
+    `, [
+        chunk_volumetrics_froxel_content_offset,
+        chunk_volumetrics_froxel_uvw_from_clip,
+    ]
+)

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

@@ -42,7 +42,7 @@ export class GPUWaterRenderer {
     /** Optional single-pixel readback on the next rendered water frame. No per-frame readback. */
     request_probe(uv: any): Promise<any>;
     dispose(): void;
-    avboit_prepare({ graph, view_ctx, camera, color_texture, depth_texture, normal_texture, hzb_texture, environment_texture, light_cluster_parameters, light_cluster_lookup, light_cluster_data, shadowmap_atlas, indirect_lighting_mode }: {
+    avboit_prepare({ graph, view_ctx, camera, color_texture, depth_texture, normal_texture, hzb_texture, environment_texture, light_cluster_parameters, light_cluster_lookup, light_cluster_data, shadowmap_atlas, indirect_lighting_mode, shader_switches }: {
         graph: any;
         view_ctx: any;
         camera: any;
@@ -56,6 +56,7 @@ export class GPUWaterRenderer {
         light_cluster_data: any;
         shadowmap_atlas: any;
         indirect_lighting_mode?: number;
+        shader_switches?: ShaderSwitchSet;
     }): {
         background_color: any;
     };
@@ -95,4 +96,5 @@ export class GPUWaterRenderer {
     inspect(graph: any, view_ctx: any, output_resolution: any): number;
     #private;
 }
+import { ShaderSwitchSet } from "../shader/compiler/ShaderSwitchSet.js";
 //# sourceMappingURL=GPUWaterRenderer.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"GPUWaterRenderer.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/water/GPUWaterRenderer.js"],"names":[],"mappings":"AAqBA,sFAAsF;AACtF;IACI,WAAa;IACb,mBAAe;IACf,yBAAqB;IACrB,aAAS;IACT,WAAa;IACb;;;;;;;;;;;MAE6B;IAC7B;;;;OAIG;IACH,QAFU,OAAO,4BAA4B,EAAE,cAAc,GAAC,IAAI,CAEpD;IAOd;;;OAGG;IACH;;;;;MAA8F;IAC9F;;;OAGG;IACH,wBAAyD;IAMzD,oCAIC;IAED,8FAA8F;IAC9F,qCAgBC;IAED,gBASC;IAuDD;;;;;;;;;;;;;;;;MAgJC;IAQD;;;;;YAMC;IAED;;;;;;;;;;MAOC;IAED;;;;;;;;;;;;;;MAwBC;IAED,gGAAgG;IAChG,mEAYC;;CA4BJ"}
+{"version":3,"file":"GPUWaterRenderer.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/water/GPUWaterRenderer.js"],"names":[],"mappings":"AAqBA,sFAAsF;AACtF;IACI,WAAa;IACb,mBAAe;IACf,yBAAqB;IACrB,aAAS;IACT,WAAa;IACb;;;;;;;;;;;MAE6B;IAC7B;;;;OAIG;IACH,QAFU,OAAO,4BAA4B,EAAE,cAAc,GAAC,IAAI,CAEpD;IAuBd;;;OAGG;IACH;;;;;MAA8F;IAC9F;;;OAGG;IACH,wBAAyD;IAMzD,oCAIC;IAED,8FAA8F;IAC9F,qCAgBC;IAED,gBASC;IAuDD;;;;;;;;;;;;;;;;;MAuIC;IAQD;;;;;YAMC;IAED;;;;;;;;;;MAOC;IAED;;;;;;;;;;;;;;MAwBC;IAED,gGAAgG;IAChG,mEAYC;;CA2BJ;gCAhY+B,uCAAuC"}

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

@@ -3,6 +3,7 @@ import { DEFAULT_DEPTH_TEXTURE_VIEW } from "../depth/DEFAULT_DEPTH_TEXTURE_VIEW.
 import { graph_compute_pass } from "../shader/graph/compute/graph_compute_pass.js";
 import { graph_image_pass } from "../shader/graph/graph_image_pass.js";
 import { ShadeIndirectLightingMode } from "../ShadeIndirectLightingMode.js";
+import { ShaderSwitchSet } from "../shader/compiler/ShaderSwitchSet.js";
 import { graph_water_tessellation } from "./surface/graph_water_tessellation.js";
 import { water_lod_view, WATER_LOD_VIEW_STRUCT } from "./surface/lod/WATER_LOD.js";
 import { WATER_LOD_LIMITS_STRUCT, WATER_LOD_PATCH_INDICES, WATER_LOD_STATISTICS_WORDS,
@@ -16,8 +17,7 @@ import { create_water_finalize_pipeline_brick4, create_water_finalize_pipeline_i
     WATER_TRACE_STRUCT } from "./shader_water.js";
 import { WATER_BAND_SAMPLER } from "./surface/GPUWaterSurface.js";
 import { shader_water_background_copy, shader_water_debug, shader_water_draw,
-    shader_water_occupancy, shader_water_splat, shader_water_confidence_seed,
-    shader_water_confidence_x, shader_water_confidence_y } from "./shader_water_avboit.js";
+    shader_water_occupancy, shader_water_splat } from "./shader_water_avboit.js";
 
 /** Production water channel. Only AVBOIT's shared resolve composites its radiance. */
 export class GPUWaterRenderer {
@@ -36,8 +36,24 @@ export class GPUWaterRenderer {
      */
     bodies = null;
     #pipeline = create_water_pipeline();
-    #finalize_pipeline_ibl = create_water_finalize_pipeline_ibl();
-    #finalize_pipeline_brick4 = create_water_finalize_pipeline_brick4();
+    /** The optics pipelines under IBL and under Brick4, each by the shader switch set it was built for. */
+    #finalize_pipelines_ibl = new Map();
+    #finalize_pipelines_brick4 = new Map();
+    /**
+     * @param {boolean} use_brick4
+     * @param {ShaderSwitchSet} shader_switches
+     * @returns {import("../../descriptor/pipeline/render/RenderPipelineDescriptor.js").RenderPipelineDescriptor}
+     */
+    #finalize_pipeline(use_brick4, shader_switches) {
+        const cache = use_brick4 ? this.#finalize_pipelines_brick4 : this.#finalize_pipelines_ibl;
+        let pipeline = cache.get(shader_switches);
+        if (pipeline === undefined) {
+            pipeline = use_brick4 ? create_water_finalize_pipeline_brick4(shader_switches)
+                : create_water_finalize_pipeline_ibl(shader_switches);
+            cache.set(shader_switches, pipeline);
+        }
+        return pipeline;
+    }
     #prepared = new WeakMap();
     #inspection = new WeakMap();
     #probe = null;
@@ -147,7 +163,7 @@ export class GPUWaterRenderer {
 
     avboit_prepare({ graph, view_ctx, camera, color_texture, depth_texture, normal_texture,
         hzb_texture, environment_texture, light_cluster_parameters, light_cluster_lookup, light_cluster_data,
-        shadowmap_atlas, indirect_lighting_mode = ShadeIndirectLightingMode.IBL }) {
+        shadowmap_atlas, indirect_lighting_mode = ShadeIndirectLightingMode.IBL, shader_switches = ShaderSwitchSet.EMPTY }) {
         const scene = view_ctx.scene;
         const settings = { ...this.settings };
         const probe = this.#probe;
@@ -223,19 +239,11 @@ export class GPUWaterRenderer {
             if (views === undefined) { views = new Map(); this.#inspection.set(graph, views); }
             views.set(view_ctx, { data, mode: settings.debug_view, resolution });
         }
-        const visibility_resolution = resolution.map(v => Math.ceil(v / 4));
-        const [seeds] = graph_image_pass({ graph, shader: shader_water_confidence_seed,
-            inputs: { trace_metadata: data.trace_metadata, scene_depth: data.scene_depth }, output_resolution: visibility_resolution });
-        const [horizontal] = graph_image_pass({ graph, shader: shader_water_confidence_x,
-            inputs: { distance_field: seeds }, output_resolution: visibility_resolution });
-        const [visibility_distance] = graph_image_pass({ graph, shader: shader_water_confidence_y,
-            inputs: { distance_field: horizontal }, output_resolution: visibility_resolution });
-        data.visibility_distance = visibility_distance;
         const finalize_data = {};
         // the optics read the GI mode the meshes in this frame are lit by: a reflection or a sky that
         // misses on screen falls back to it, as SSR's resolve does
         const use_brick4 = indirect_lighting_mode === ShadeIndirectLightingMode.Brick4;
-        const finalize_pipeline = use_brick4 ? this.#finalize_pipeline_brick4 : this.#finalize_pipeline_ibl;
+        const finalize_pipeline = this.#finalize_pipeline(use_brick4, shader_switches);
         const finalize_resources = use_brick4 ? WATER_FINALIZE_RESOURCES_BRICK4 : WATER_FINALIZE_RESOURCES_IBL;
         const finalize = graph.add('Water / coherent optics', finalize_data, (d, resources, {encoder, graphics}) => {
             const shared = {
@@ -244,7 +252,6 @@ export class GPUWaterRenderer {
                 tNormal: resources.get(d.normal).obtainView(), tHZB: resources.get(d.hzb).obtainView(),
                 tScene: resources.get(d.color).obtainView(),
                 receiver: resources.get(d.receiver).obtainView(), trace_metadata: resources.get(d.trace_metadata).obtainView(),
-                visibility_distance: resources.get(d.visibility_distance).obtainView(),
                 ...geometry_bindings(graphics, encoder, resources, d),
                 // the lights, as the transparent meshes bind them
                 light_data: view_ctx.scene.lights.buffer_data,
@@ -274,7 +281,7 @@ export class GPUWaterRenderer {
             draw(render, resources.get(d.commands), graphics.device);
             render.end();
         });
-        for (const key of ['camera','scene_depth','normal','hzb','color','receiver','trace_metadata','visibility_distance','interface_depth',
+        for (const key of ['camera','scene_depth','normal','hzb','color','receiver','trace_metadata','interface_depth',
             'lod_bodies','candidates','cells','commands']) {
             finalize_data[key] = finalize.read(data[key]);
         }
@@ -370,10 +377,9 @@ export class GPUWaterRenderer {
                     const mapped = buffer.getMappedRange();
                     const half = offset => Array.from(new Float16Array(mapped, offset, 4));
                     const radiance = half(512);
-                    const confidence = radiance[3];
                     radiance[3] = new Float32Array(mapped, 768, 4)[1];
                     probe.resolve({ pixel, resolution, frame_time: optical.frame_time, receiver: Array.from(new Float32Array(mapped, 0, 4)),
-                        transmission: Array.from(new Float32Array(mapped, 256, 4)), radiance, confidence, stale: false });
+                        transmission: Array.from(new Float32Array(mapped, 256, 4)), radiance, stale: false });
                 } catch (error) { probe.reject(error); }
                 finally { buffer.destroy(); }
             });

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

@@ -1,5 +1,4 @@
 export const WATER_LEVEL_TOLERANCE_DECLARATION: CodeChunk;
-export const chunk_water_refraction_confidence: CodeChunk;
 export const chunk_water_transport: CodeChunk;
 export const chunk_water_receiver_texel: CodeChunk;
 export const chunk_water_receiver_radiance: CodeChunk;

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

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

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

@@ -12,23 +12,6 @@ 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 {
-    return mix(original, receiver, clamp(confidence, 0.0, 1.0));
-}
-fn water_refraction_confidence(uv: vec2f, original_uv: vec2f, size: vec2f, distance_tiles: f32) -> f32 {
-    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);
-    // 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(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 }

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

@@ -1,6 +1,8 @@
 export function create_water_pipeline(): RenderPipelineDescriptor;
-export function create_water_finalize_pipeline_ibl(): RenderPipelineDescriptor;
-export function create_water_finalize_pipeline_brick4(): RenderPipelineDescriptor;
+/** The optics pipeline under IBL, its shader built for `switches` (a ShaderSwitchSet). */
+export function create_water_finalize_pipeline_ibl(switches: any): RenderPipelineDescriptor;
+/** The optics pipeline under Brick4, its shader built for `switches` (a ShaderSwitchSet). */
+export function create_water_finalize_pipeline_brick4(switches: any): RenderPipelineDescriptor;
 export const WATER_TRACE_STRUCT: WebGPUStruct;
 /** Optics under IBL (and LPV, which has no transparent variant): the lights and the environment. */
 export const WATER_FINALIZE_RESOURCES_IBL: ShaderResourceSetDescriptor;

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

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

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

@@ -13,7 +13,6 @@ 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 { ShaderResourceSetDescriptor } from "../shader/resource/ShaderResourceSetDescriptor.js";
 import { ShaderDescriptor } from "../shader/ShaderDescriptor.js";
@@ -38,8 +37,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,
@@ -73,7 +72,7 @@ function water_resources(finalize = false) {
         .addStorageBuffer('water_particle_offsets', COLLECTION_U32_STRUCT_READ)
         .addStorageBuffer('water_particle_entries', WebGPUArray.from(WATER_PARTICLE_ENTRY_STRUCT));
     if (finalize) {
-        group.addTexture('receiver').addTexture('trace_metadata').addTexture('visibility_distance');
+        group.addTexture('receiver').addTexture('trace_metadata');
     }
     return resources;
 }
@@ -366,6 +365,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;
 }
@@ -529,11 +535,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 +548,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,14 +580,13 @@ 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]);
 
 export const water_shader = ShaderDescriptor.from({ label: "Water / receivers", resources, body });
 /** The optics pass under IBL, and under LPV, which has no transparent variant. */
@@ -617,5 +622,11 @@ 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 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);
+}

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/wgsl/emulator/WGSLJavaScriptCompiler.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"WGSLJavaScriptCompiler.d.ts","sourceRoot":"","sources":["../../../../../src/shade/wgsl/emulator/WGSLJavaScriptCompiler.js"],"names":[],"mappings":"AAsmBA;IAEI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IACH,oBAFa,MAAM,CAMlB;CACJ;;UAloBa,WAAW,GAAG,UAAU,GAAG,KAAK,GAAG,KAAK,GAAG,OAAO,GAAG,QAAQ,GAAG,YAAY,GAAG,SAAS,GAAG,QAAQ,GAAG,SAAS;WAC/G,MAAM;WACN,MAAM;WACN,MAAM;WACN,MAAM;aACN,MAAM;cACN,QAAQ;YACR,MAAM"}
+{"version":3,"file":"WGSLJavaScriptCompiler.d.ts","sourceRoot":"","sources":["../../../../../src/shade/wgsl/emulator/WGSLJavaScriptCompiler.js"],"names":[],"mappings":"AA+nBA;IAEI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IACH,oBAFa,MAAM,CAMlB;CACJ;;UA1pBa,WAAW,GAAG,UAAU,GAAG,KAAK,GAAG,KAAK,GAAG,OAAO,GAAG,QAAQ,GAAG,YAAY,GAAG,SAAS,GAAG,QAAQ,GAAG,SAAS;WAC/G,MAAM;WACN,MAAM;WACN,MAAM;WACN,MAAM;aACN,MAAM;cACN,QAAQ;YACR,MAAM"}

package/src/shade/wgsl/emulator/WGSLJavaScriptCompiler.js

@@ -1,4 +1,5 @@
 import { assert } from "../../../core/assert.js";
+import { FLOAT32_MAX } from "../../../core/binary/FLOAT32_MAX.js";
 import LineBuilder from "../../../core/codegen/LineBuilder.js";
 
 // =========================================================================
@@ -83,12 +84,25 @@ class Scope {
          * @type {Set<string>}
          */
         this.boxed = new Set();
+        /**
+         * The value of each abstract `const` declared here whose initializer folds, so a use of
+         * the name converts it at compile time as a use of the literal does.
+         * @type {Map<string, number>}
+         */
+        this.values = new Map();
     }
 
-    declare(name, type) {
+    /**
+     * @param {string} name
+     * @param {WgslType} type
+     * @param {number} [value] the folded value of an abstract `const`
+     */
+    declare(name, type, value) {
         this.symbols.set(name, type || T_UNKNOWN);
         this.pointers.delete(name);
         this.boxed.delete(name);
+        if (value !== undefined) this.values.set(name, value);
+        else this.values.delete(name);
     }
 
     /**
@@ -104,6 +118,7 @@ class Scope {
      */
     declarePointer(name, type, boxed) {
         this.symbols.set(name, type || T_UNKNOWN);
+        this.values.delete(name);
         this.pointers.add(name);
         if (boxed) this.boxed.add(name);
         else this.boxed.delete(name);
@@ -136,6 +151,16 @@ class Scope {
         return T_UNKNOWN;
     }
 
+    /**
+     * @param {string} name
+     * @returns {number | undefined} the folded value of `name`, as seen from here, if it is an abstract `const` that has one
+     */
+    lookupValue(name) {
+        if (this.symbols.has(name)) return this.values.get(name);
+        if (this.parent) return this.parent.lookupValue(name);
+        return undefined;
+    }
+
     push() {
         return new Scope(this);
     }
@@ -1135,7 +1160,7 @@ function collectGlobalValue(c, node) {
         type = keeps_abstract ? expr.type : concreteDefault(expr.type);
     }
 
-    c.scope.declare(name, type);
+    c.scope.declare(name, type, isAbstractType(type) ? expr.value : undefined);
     c.privateGlobals.push({
         name,
         kind: 'const',
@@ -1402,7 +1427,7 @@ function emitVariableOrValueStatement(c, node) {
         if (var_decl === null && isPointerExpression(c, expr_node)) {
             c.scope.declarePointer(name, type, false);
         } else {
-            c.scope.declare(name, type);
+            c.scope.declare(name, type, isAbstractType(type) ? expr.value : undefined);
         }
         c.out.add(`${kind} ${identToJs(name)} = ${value};`);
     } else {
@@ -2054,10 +2079,10 @@ function compileExpressionAbstract(c, node) {
     if (u.type === 'template_elaborated_ident') {
         const ident = namedChildByType(u, 'ident');
         const name = ident !== null ? ident.text : u.text;
-        return { code: identToJs(name), type: c.scope.lookup(name), pointer_box: c.scope.isBoxedPointer(name) };
+        return { code: identToJs(name), type: c.scope.lookup(name), value: c.scope.lookupValue(name), pointer_box: c.scope.isBoxedPointer(name) };
     }
     if (u.type === 'ident') {
-        return { code: identToJs(u.text), type: c.scope.lookup(u.text), pointer_box: c.scope.isBoxedPointer(u.text) };
+        return { code: identToJs(u.text), type: c.scope.lookup(u.text), value: c.scope.lookupValue(u.text), pointer_box: c.scope.isBoxedPointer(u.text) };
     }
 
     c.error(u, `unsupported expression: ${u.type}`);
@@ -2277,10 +2302,16 @@ function concreteDefault(t) {
  * An abstract operand converted to the concrete scalar type it meets.
  *
  * Only a float target changes the value. An AbstractFloat becoming an f32 is rounded to one, and
- * so is an AbstractInt too large for f32 to hold. A literal is folded at compile time, and is
- * emitted unchanged when f32 holds it already, which most literals in a shader are. An integer
- * target changes nothing: an AbstractInt has the same value in i32 and u32, and an AbstractFloat
- * cannot meet an integer in a valid shader.
+ * so is an AbstractInt too large for f32 to hold. A literal, or a `const` initialized with one, is
+ * folded at compile time, and is emitted unchanged when f32 holds it already, which most literals
+ * in a shader are. An integer target changes nothing: an AbstractInt has the same value in i32 and
+ * u32, and an AbstractFloat cannot meet an integer in a valid shader.
+ *
+ * A folded value beyond the largest finite f32 is refused, as a device refuses it: WGSL makes that
+ * conversion a shader-creation error rather than a rounding, so `3.4028235e38` — the shortest
+ * decimal that names the largest f32 — does not compile where it meets an f32, although it would
+ * round to one. Rounding it here instead let ReSTIR DI's resample and spatial passes run under the
+ * emulator while neither compiled on a device.
  *
  * @param {{ code: string, type: WgslType, value?: number }} operand
  * @param {string} scalar the concrete scalar type's name
@@ -2295,6 +2326,9 @@ function convertAbstract(operand, scalar) {
         if (operand.value === undefined) {
             return { code: `wgsl.f32(${operand.code})`, type };
         }
+        if (!(Math.abs(operand.value) <= FLOAT32_MAX)) {
+            throw new Error(`WGSL compiler: value ${operand.value} cannot be represented as 'f32' (at ${JSON.stringify(operand.code)})`);
+        }
         const rounded = Math.fround(operand.value);
         return { code: rounded === operand.value ? operand.code : `(${rounded})`, type };
     }