@woosh/meep-engine 3.60.3 → 3.60.5

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

@@ -4,6 +4,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 { ShaderSwitchSet } from "../shader/compiler/ShaderSwitchSet.js";
+import { graph_water_meshlets } from "./medium/graph_water_meshlets.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,
@@ -28,12 +29,6 @@ export class GPUWaterRenderer {
     settings = { enabled: true, max_distance: 300, distance_tolerance: 0.15,
         max_updates: 4, fallback_steps: 48, mode: 0, reflections: 1, debug_view: 0, inscatter_segments: 4,
         tessellation_pixels: 4 };
-    /**
-     * The frame's water bodies table, recorded by whoever owns the surfaces at the head of the frame;
-     * each drawable surface carries its row as `body_index`.
-     * @type {import("./medium/GPUWaterBodies.js").GPUWaterBodies|null}
-     */
-    bodies = null;
     #pipeline = create_water_pipeline();
     /** The optics pipelines, each by the shader switch set it was built for. */
     #finalize_pipelines = new Map();
@@ -169,7 +164,7 @@ export class GPUWaterRenderer {
         // the lattice is chosen from the camera's position and its pixel angle, not its jittered projection's offset:
         // raster jitter moves samples, not the mesh
         const lod = water_lod_view(view_ctx.camera.camera.projection_matrix, resolution[1], Math.max(0.5, settings.tessellation_pixels));
-        const { meshlets, lod_bodies } = this.bodies.meshlets({ graph, view: view_ctx, camera, meshlet_capacity: this.meshlet_capacity,
+        const { meshlets, lod_bodies } = graph_water_meshlets({ graph, scene, camera, meshlet_capacity: this.meshlet_capacity,
             visible_rows: surface.visible_rows, lod, steep: surface.steep });
         const limits = { ...this.lod_budgets, triangles: Math.max(this.meshlet_capacity, 1) * GEOMETRY_MESHLET_TRIANGLE_LIMIT };
         const patches = graph_water_tessellation({ graph, scene, camera, meshlets, lod_bodies, meshlet_capacity: this.meshlet_capacity,
@@ -225,7 +220,8 @@ export class GPUWaterRenderer {
         data.commands = pass.read(patches.commands);
         // Keep the accepted UV and both paths at f32 precision through final shading.
         data.receiver = target("receiver", "rgba32float");
-        data.trace_metadata = target("trace metadata", "rgba32float");
+        // the fragment's control path, shaded surface, coverage and body, bit-packed (shader_water.js WaterReceiver)
+        data.trace_metadata = target("trace metadata", "rgba32uint");
         data.interface_depth = target("interface depth", "depth32float");
         let states = this.#prepared.get(graph);
         if (states === undefined) { states = new Map(); this.#prepared.set(graph, states); }
@@ -264,9 +260,10 @@ export class GPUWaterRenderer {
             const bindings = WATER_FINALIZE_RESOURCES.generateBindings(shared, encoder);
             const copy_pipeline = shader_water_background_copy.pipeline;
             const copy_bindings = shader_water_background_copy.descriptor.resources.generateBindings({tScene: shared.tScene}, encoder);
+            // away from water nothing is transmitted through and nothing is added: the background copy leaves both
             const render = encoder.constructRenderPass({label: 'Water / coherent optics', pipeline: finalize_pipeline, bindings: [],
-                colorAttachments: [d.transmission,d.radiance,d.background].map(handle => ({
-                    view: resources.get(handle).obtainView(), loadOp: 'clear', storeOp: 'store', clearValue: [0,0,0,0],
+                colorAttachments: [[d.transmission, [1,1,1,0]], [d.radiance, [0,0,0,0]], [d.background, [0,0,0,0]]].map(([handle, clearValue]) => ({
+                    view: resources.get(handle).obtainView(), loadOp: 'clear', storeOp: 'store', clearValue,
                 })), depthStencilAttachment: {view: resources.get(d.interface_depth).obtainView(DEFAULT_DEPTH_TEXTURE_VIEW), depthReadOnly: true},
             });
             render.setPipeline(graphics.render_pipelines.obtain(copy_pipeline)); render.record_pipeline(copy_pipeline);
@@ -353,7 +350,7 @@ export class GPUWaterRenderer {
         const [color] = graph_image_pass({ graph, shader: shader_water_debug, output_resolution: resolution,
             inputs: { inspection: { mode, resolution }, camera: data.camera, warp: data.warp, tIntegral: data.integral,
                 transmission: data.transmission, radiance: data.radiance,
-                receiver: data.receiver, interface_depth: data.interface_depth, trace_metadata: data.trace_metadata } });
+                receiver: data.receiver, interface_depth: data.interface_depth } });
         return color;
     }
 
@@ -362,7 +359,7 @@ export class GPUWaterRenderer {
         const pass = graph.add("Water / pixel probe", data, (data, resources, { encoder, graphics }) => {
             const buffer = graphics.device.createBuffer({ size: 1024, usage: GPUBufferUsage.MAP_READ | GPUBufferUsage.COPY_DST });
             const pixel = probe.uv.map((v, i) => Math.min(resolution[i]-1, Math.max(0, Math.floor(v*resolution[i]))));
-            [data.receiver, data.transmission, data.radiance, data.trace_metadata].forEach((handle, i) => {
+            [data.receiver, data.transmission, data.radiance].forEach((handle, i) => {
                 encoder.copyTextureToBuffer({ texture: resources.get(handle).gpu_texture, origin: [...pixel, 0] },
                     { buffer, offset: i*256, bytesPerRow: 256 }, [1,1,1]);
             });
@@ -370,16 +367,14 @@ export class GPUWaterRenderer {
                 try {
                     await buffer.mapAsync(GPUMapMode.READ);
                     const mapped = buffer.getMappedRange();
-                    const half = offset => Array.from(new Float16Array(mapped, offset, 4));
-                    const radiance = half(512);
-                    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, stale: false });
+                        transmission: Array.from(new Float32Array(mapped, 256, 4)), radiance: Array.from(new Float16Array(mapped, 512, 4)),
+                        stale: false });
                 } catch (error) { probe.reject(error); }
                 finally { buffer.destroy(); }
             });
         });
-        for (const key of ["receiver", "transmission", "radiance", "trace_metadata"]) { data[key] = pass.read(optical[key]); }
+        for (const key of ["receiver", "transmission", "radiance"]) { data[key] = pass.read(optical[key]); }
         pass.make_side_effect();
     }
 }

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

@@ -0,0 +1,35 @@
+/**
+ * A view's water bodies: which the view draws and how, and their meshlets in row order.
+ *
+ * Draw culling over the frame's visible list (WATER_SURFACE_DISTANCE_LOD_PROPOSAL_2026_10_06.md §4.3), each drawn
+ * body's lattice frame at its row, and the drawn bodies' meshlets. The expansion is an ordered prefix scan over the
+ * rows, which preserves equal-depth ownership, including after holes and reuse.
+ *
+ * @param {object} options
+ * @param {import("../../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph} options.graph
+ * @param {object} options.scene GPU scene context
+ * @param {number} options.camera the view's camera uniform resource
+ * @param {number} options.meshlet_capacity every water meshlet the scene holds
+ * @param {GPUBuffer} options.visible_rows the frame's visible water rows
+ * @param {{ranges: number, orthographic: number, level: number, distance: number}} options.lod the view's lattice choice
+ * @param {GPUBuffer} options.steep per wave row: set for a body with a triangle too steep for the lattice
+ * @returns {{meshlets: number, lod_bodies: number}} resources
+ */
+export function graph_water_meshlets({ graph, scene, camera, meshlet_capacity, visible_rows, lod, steep }: {
+    graph: import("../../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph;
+    scene: object;
+    camera: number;
+    meshlet_capacity: number;
+    visible_rows: GPUBuffer;
+    lod: {
+        ranges: number;
+        orthographic: number;
+        level: number;
+        distance: number;
+    };
+    steep: GPUBuffer;
+}): {
+    meshlets: number;
+    lod_bodies: number;
+};
+//# sourceMappingURL=graph_water_meshlets.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"graph_water_meshlets.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/water/medium/graph_water_meshlets.js"],"names":[],"mappings":"AAsBA;;;;;;;;;;;;;;;;GAgBG;AACH;IATsG,KAAK,EAAhG,OAAO,8DAA8D,EAAE,UAAU;IACjE,KAAK,EAArB,MAAM;IACU,MAAM,EAAtB,MAAM;IACU,gBAAgB,EAAhC,MAAM;IACa,YAAY;IACkD,GAAG,EAApF;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,YAAY,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAC;IACpD,KAAK;IACtB;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAC,CAmDlD"}

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

@@ -0,0 +1,89 @@
+import { BufferResourceDescriptor } from "../../../device/graph/BufferResourceDescriptor.js";
+import { round_up } from "../../../../core/math/round_up.js";
+import {
+    graph_prefix_scan_csdldf,
+    prefix_scan_csdldf_output_descriptor
+} from "../../gpu_primitive/prefix_sum/v1/graph_prefix_scan_csdldf.js";
+import { graph_create_buffer } from "../../shader/graph/graph_create_buffer.js";
+import {
+    build_indirect_compute_dispatch_command,
+    INDIRECT_COMPUTE_COMMAND_DESCRIPTOR
+} 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_meshlets_expand } from "./shader_water_meshlets.js";
+import { shader_water_lod_bodies } from "../surface/lod/shader_water_lod.js";
+import { WATER_LOD_BODY_STRUCT, WATER_LOD_VIEW_STRUCT } from "../surface/lod/WATER_LOD.js";
+import { MESHLET_COLLECTION_STRUCT } from "../../rasterize/MESHLET_COLLECTION_STRUCT.js";
+import { MESHLET_DEFINITION_STRUCT } from "../../geometry/meshlet/encoding/MESHLET_DEFINITION_STRUCT.js";
+
+const MESHLETS_OFFSET = MESHLET_COLLECTION_STRUCT.get('elements').offset;
+
+/**
+ * A view's water bodies: which the view draws and how, and their meshlets in row order.
+ *
+ * Draw culling over the frame's visible list (WATER_SURFACE_DISTANCE_LOD_PROPOSAL_2026_10_06.md §4.3), each drawn
+ * body's lattice frame at its row, and the drawn bodies' meshlets. The expansion is an ordered prefix scan over the
+ * rows, which preserves equal-depth ownership, including after holes and reuse.
+ *
+ * @param {object} options
+ * @param {import("../../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph} options.graph
+ * @param {object} options.scene GPU scene context
+ * @param {number} options.camera the view's camera uniform resource
+ * @param {number} options.meshlet_capacity every water meshlet the scene holds
+ * @param {GPUBuffer} options.visible_rows the frame's visible water rows
+ * @param {{ranges: number, orthographic: number, level: number, distance: number}} options.lod the view's lattice choice
+ * @param {GPUBuffer} options.steep per wave row: set for a body with a triangle too steep for the lattice
+ * @returns {{meshlets: number, lod_bodies: number}} resources
+ */
+export function graph_water_meshlets({ graph, scene, camera, meshlet_capacity, visible_rows, lod, steep }) {
+    const table = scene.scene_database.get('water_bodies');
+    const capacity = Math.max(table.element_capacity, 1);
+    const data = {};
+    const pass = graph.add('Water / lod bodies', data, (d, resources, { encoder }) => {
+        const command = resources.get(d.command);
+        build_indirect_compute_dispatch_command(64, encoder, visible_rows, 0, command, 0, true);
+        shader_water_lod_bodies.dispatchIndirect({ encoder, command, bindings: {
+            capacity: round_up(capacity, 4), lod: encoder.allocateTransientValueBuffer(WATER_LOD_VIEW_STRUCT, lod),
+            camera: resources.get(d.camera), scene_database: scene.scene_database_buffer,
+            geometries: scene.geometries.buffer_metadata, visible_rows, steep,
+            lod_bodies: resources.get(d.lod_bodies), counts: resources.get(d.counts),
+        } });
+    });
+    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));
+    data.command = pass.create('Water lod bodies command', INDIRECT_COMPUTE_COMMAND_DESCRIPTOR);
+    data.lod_bodies = pass.create('Water lod bodies', BufferResourceDescriptor.from(capacity * WATER_LOD_BODY_STRUCT.size,
+        GPUBufferUsage.STORAGE));
+    const sums = graph_prefix_scan_csdldf({ graph, input: data.counts,
+        output: graph_create_buffer(graph, 'Water lod body meshlet sums', prefix_scan_csdldf_output_descriptor(capacity)),
+        element_max_count: capacity });
+    const command_data = {};
+    const command_pass = graph.add('Water / expand command', command_data, (d, resources, { encoder }) => {
+        shader_prefix_sum_to_command.dispatch({ encoder, bindings: {
+            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);
+    // The collection struct holding this many meshlets, padded to its alignment: one meshlet is the binding's minimum.
+    const meshlets_bytes = round_up(MESHLETS_OFFSET + Math.max(meshlet_capacity, 1) * MESHLET_DEFINITION_STRUCT.aligned_size,
+        MESHLET_COLLECTION_STRUCT.align);
+    expand_data.output = expand.create('meshlets', BufferResourceDescriptor.from(meshlets_bytes,
+        GPUBufferUsage.STORAGE, 0, MESHLETS_OFFSET));
+    const { output } = graph_compute_pass({ graph, shader: shader_increment_count_by_prefix_sum,
+        bindings: { prefix_sums: sums, output: expand_data.output } });
+    return { meshlets: output, lod_bodies: data.lod_bodies };
+}

package/src/shade/renderer/water/query/GPUWaterQueries.d.ts

@@ -24,7 +24,7 @@ export class GPUWaterQueries {
      * @param {PipelineEnquiry} enquiry
      */
     static enquirePipelines(enquiry: PipelineEnquiry): void;
-    static "__#273@#execute"(pass: any, resources: any, context: any): void;
+    static "__#275@#execute"(pass: any, resources: any, context: any): void;
     /**
      * @param {object} options
      * @param {GPUDevice} options.device

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":"AA+oBA,kEAAuH;AACvH,gFAAgF;AAChF,wFAEC;AA9lBD,8CAKwB;AAwCxB;;;;GAIG;AACH,mEAA8D;AAgP9D,+CAsFmB;AAoMnB,4CAAmG;AACnG,uGAAuG;AACvG,qDACgE;AAChE,0DAAyC;yCAnnBA,8DAA8D;6BAyB1E,gCAAgC;4CAJjB,mDAAmD;0BAPrE,iCAAiC;iCAQ1B,+BAA+B"}
+{"version":3,"file":"shader_water.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/water/shader_water.js"],"names":[],"mappings":"AAwpBA,kEAAsH;AACtH,gFAAgF;AAChF,wFAEC;AArmBD,8CAKwB;AAwCxB;;;;GAIG;AACH,mEAA8D;AAgP9D,+CAsFmB;AA2MnB,4CAAmG;AACnG,uGAAuG;AACvG,qDACgE;AAChE,0DAAyC;yCA5nBA,8DAA8D;6BA2B1E,gCAAgC;4CAJjB,mDAAmD;0BAPrE,iCAAiC;iCAQ1B,+BAA+B"}

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

@@ -7,6 +7,8 @@ import { BRICK4_DATA_STRUCT } from "../global_illumination/brick4/gpu/BRICK4_DAT
 import { PROBE_CLIPMAP_SAMPLING_GROUP } from "../global_illumination/probe_clipmap/probe/chunk_probe_clipmap_pick.js";
 import { chunk_F_dielectric } from "../shader/chunk/brdf/fresnel/chunk_F_dielectric.js";
 import { chunk_direction_view_to_world } from "../shader/chunk/camera/chunk_direction_view_to_world.js";
+import { chunk_uv_octahedral_unit_decode } from "../shader/chunk/geometry/octahedron/chunk_uv_octahedral_unit_decode.js";
+import { chunk_uv_octahedral_unit_encode } from "../shader/chunk/geometry/octahedron/chunk_uv_octahedral_unit_encode.js";
 import { chunk_direction_world_to_view } from "../shader/chunk/camera/chunk_direction_world_to_view.js";
 import { chunk_ray_at } from "../shader/chunk/geometry/ray/chunk_ray_at.js";
 import { chunk_ffx_sssr_advance_ray } from "../shader/chunk/screen_space/chunk_ffx_sssr_advance_ray.js";
@@ -90,7 +92,7 @@ function water_resources(finalize = false) {
         .add(WATER_PARTICLE_OFFSETS_RESOURCE)
         .add(WATER_PARTICLE_ENTRIES_RESOURCE);
     if (finalize) {
-        group.addTexture('receiver').addTexture('trace_metadata');
+        group.addTexture('receiver').addTexture('trace_metadata', 'uint');
     }
     return resources;
 }
@@ -435,9 +437,12 @@ for (const resource of [CAMERA_RESOURCE, TRACE_RESOURCE, SCREEN_DEPTH_RESOURCE,
 
 const body = CodeChunk.from(/* language=WGSL */ `
 struct WaterReceiver {
-    @location(0) receiver: vec4<f32>,
-    @location(1) metadata: vec4<f32>,
     // Receiver UV, bounded path, classified status + Newton updates / 32. Readback is opt-in.
+    @location(0) receiver: vec4<f32>,
+    // The fragment's control path (f32 bits); the surface it was shaded with, its normal octahedral in two unorm16
+    // and its slope variance beside its shore coverage in two f16; its body + 1. The optics take that surface from
+    // here rather than evaluate it again.
+    @location(1) metadata: vec4<u32>,
 }
 
 // A screen-space receiver must lie below the surface point the ray entered at: the refracted ray runs
@@ -515,10 +520,11 @@ fn fs_main(in: WaterVertexOut, @builtin(front_facing) above: bool) -> WaterRecei
     else if (status == 8u) { status = 24u + newton_failure; }
     else if (status == 9u) { status = 31u; }
     return WaterReceiver(vec4f(hit.uv, hit.distance, f32(status) + f32(newton_updates)/32.0),
-        vec4f(control_path, min(hit.residual, 65504.0), coverage, f32(in.body_index + 1u)));
+        vec4<u32>(bitcast<u32>(control_path), pack2x16unorm(uv_octahedral_unit_encode(pixel.normal)),
+            pack2x16float(vec2f(pixel.variance, coverage)), in.body_index + 1u));
 }
 `, [surface_body, chunk_water_screen_ray, chunk_direction_view_to_world,
-    chunk_water_receiver_texel, WATER_LEVEL_TOLERANCE_DECLARATION]);
+    chunk_water_receiver_texel, WATER_LEVEL_TOLERANCE_DECLARATION, chunk_uv_octahedral_unit_encode]);
 
 const finalize_body = CodeChunk.from(/* language=WGSL */ `
 struct WaterOptics {
@@ -528,12 +534,15 @@ struct WaterOptics {
 }
 @fragment
 fn fs_main(in: WaterVertexOut, @builtin(front_facing) above: bool) -> WaterOptics {
-    let pixel = water_pixel_surface(in, in.pixel_footprint);
-    let water = ${WATER_BODIES_TABLE.marshalling_method_read}(&scene_database, in.body_index);
     let coord = vec2i(in.clip.xy);
     let metadata = textureLoad(trace_metadata, coord, 0);
     // Equal-depth surfaces must retain the same deterministic owner as receiver selection.
-    if (metadata.w != f32(in.body_index + 1u)) { discard; }
+    if (metadata.w != in.body_index + 1u) { discard; }
+    // the surface the receivers shaded this fragment with
+    let shading = unpack2x16float(metadata.z);
+    let pixel = WaterPixelSurface(uv_octahedral_unit_decode(unpack2x16unorm(metadata.y)), shading.x);
+    let coverage = shading.y;
+    let water = ${WATER_BODIES_TABLE.marshalling_method_read}(&scene_database, in.body_index);
     let dimensions = vec2f(textureDimensions(tDepth, 0));
     let uv = in.clip.xy / dimensions;
     let receiver_data = textureLoad(receiver, coord, 0);
@@ -577,7 +586,7 @@ fn fs_main(in: WaterVertexOut, @builtin(front_facing) above: bool) -> WaterOptic
     // wave height across a few metres, against a tolerance the gather already allows.
     let gathered = water_receiver_radiance(tScene, tDepth, tNormal, lookup,
         camera.projection_matrix_inverse, camera.view_matrix_inverse, in.world, interface_normal, above);
-    var path = metadata.x;
+    var path = bitcast<f32>(metadata.x);
     var color = original.rgb;
     // the receiver seen through the surface: refracted, or the pixel's own when there is none
     var receiver_coord = coord;
@@ -612,8 +621,8 @@ fn fs_main(in: WaterVertexOut, @builtin(front_facing) above: bool) -> WaterOptic
         scattered = exit * water_inscatter(body, in.world, direction, normalize(in.rest_normal), max(path, 0.0), trace.inscatter_segments);
     }
     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, 0.0),
+    let optical = water_transport(event, original.rgb, color, coverage);
+    return WaterOptics(vec4f(optical.transmission, coverage), vec4f(optical.radiance, 0.0),
         vec4f(optical.background, original.a));
 }
 `, [surface_body, chunk_water_screen_ray, chunk_F_dielectric, chunk_ffx_sssr_validate_hit,
@@ -621,7 +630,7 @@ fn fs_main(in: WaterVertexOut, @builtin(front_facing) above: bool) -> WaterOptic
     chunk_water_receiver_downwelling, chunk_water_receiver_texel,
     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]);
+    chunk_water_gi, chunk_uv_octahedral_unit_decode]);
 
 export const water_shader = ShaderDescriptor.from({ label: "Water / receivers", resources, body });
 /** The optics pass; its variants differ in the indirect lighting they fall back to, and bind alike. */
@@ -653,7 +662,7 @@ function water_pipeline(shader, targets, finalize) {
         primitive: { topology: "triangle-list", cullMode: "none" },
     });
 }
-export function create_water_pipeline() { return water_pipeline(water_shader, ['rgba32float', 'rgba32float'], false); }
+export function create_water_pipeline() { return water_pipeline(water_shader, ['rgba32float', 'rgba32uint'], false); }
 /** The optics pipeline, its shader built for `switches` (a ShaderSwitchSet). */
 export function create_water_finalize_pipeline(switches) {
     return water_pipeline(water_finalize_shader.variant(switches), ['rgba32float', 'rgba16float', 'rgba16float'], true);

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

@@ -1 +1 @@
-{"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"}
+{"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;AAOH,uDAYG;AAOH,6CAqCG;8BA3L2B,4BAA4B;4BAC9B,0BAA0B"}

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

@@ -141,21 +141,22 @@ fn main(@builtin(position) coord: vec4f) -> WaterContribution {
     }), targets: AVBOIT_DRAW_TARGETS,
 });
 
-// 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.
+// Initialize the background target in the same render pass as water shading: the AVBOIT resolve reads it over the
+// whole screen. Transmission and radiance are constants away from water, and the pass's clear gives them; this draw
+// leaves them alone. It samples opaque HDR and needs no COPY_SRC usage or renderer changes.
 const background_resources = new ShaderResourceSetDescriptor();
 background_resources.createGroup().addTexture('tScene');
 export const shader_water_background_copy = ImageShader.from({
     descriptor: ShaderDescriptor.from({label: 'Water / background initialization', resources: background_resources,
         body: CodeChunk.from(/* language=WGSL */ `
 struct WaterBackground {
-    @location(0) transmission: vec4f, @location(1) radiance: vec4f, @location(2) background: vec4f,
+    @location(2) background: vec4f,
 }
 @fragment
 fn main(@builtin(position) coord: vec4f) -> WaterBackground {
-    return WaterBackground(vec4f(1.0,1.0,1.0,0.0), vec4f(0.0), textureLoad(tScene, vec2i(coord.xy), 0));
+    return WaterBackground(textureLoad(tScene, vec2i(coord.xy), 0));
 }
-`)}), targets: [{format:'rgba32float'}, {format:'rgba16float'}, {format:'rgba16float'}],
+`)}), targets: [{format:'rgba32float', writeMask: 0}, {format:'rgba16float', writeMask: 0}, {format:'rgba16float'}],
     depthStencil: DepthStencilState.from({format:'depth32float', depthWriteEnabled:false, depthCompare:'always'}),
 });
 
@@ -163,7 +164,7 @@ const debug_resources = new ShaderResourceSetDescriptor();
 debug_resources.createGroup().addUniform("inspection", WebGPUStruct.from({ mode: u32, resolution: vec2f }, "WaterInspection").pack())
     .addUniform("camera", CAMERA_UNIFORM_STRUCT).addStorageBuffer("warp", AVBOIT_WARP_STRUCT)
     .addTexture("tIntegral", "float", "3d").addSampler("sLinear", "filtering", SAMPLER_LINEAR_UPSCALE).addTexture("transmission")
-    .addTexture("radiance").addTexture("receiver").addTexture("interface_depth").addTexture("trace_metadata");
+    .addTexture("radiance").addTexture("receiver").addTexture("interface_depth");
 export const shader_water_debug = ImageShader.from({
     descriptor: ShaderDescriptor.from({ label: "Water / inspection", resources: debug_resources,
         body: CodeChunk.from(/* language=WGSL */ `
@@ -188,7 +189,6 @@ fn main(@builtin(position) coord: vec4f) -> @location(0) vec4f {
             color.r = max(color.r, fract(r.w) * 2.0);
         }
         case 5u: { color = textureLoad(radiance, pixel, 0).rgb; }
-        case 6u: { color = vec3f(min(textureLoad(trace_metadata, pixel, 0).g, 1.0)); }
         case 8u, 9u: {
             let z = get_view_space_depth(textureLoad(interface_depth, pixel, 0).r, camera);
             // without the draw's footprint (a derivative this switch cannot take): where the water is

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

@@ -30,7 +30,7 @@ export function water_lod_cell_layout(limits: {
  * @param {import("../../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph} options.graph
  * @param {object} options.scene GPU scene context
  * @param {number} options.camera the view's camera uniform resource
- * @param {number} options.meshlets the drawn bodies' meshlets resource, from {@link GPUWaterBodies#meshlets}
+ * @param {number} options.meshlets the drawn bodies' meshlets resource, from {@link graph_water_meshlets}
  * @param {number} options.lod_bodies the view's per-body lattice frames resource, from the same
  * @param {number} options.meshlet_capacity every water meshlet the scene holds: the triangle slots there can be
  * @param {{ranges: number, orthographic: number, level: number, distance: number}} options.lod the view's lattice choice

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

@@ -62,7 +62,7 @@ export function water_lod_cell_layout(limits) {
  * @param {import("../../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph} options.graph
  * @param {object} options.scene GPU scene context
  * @param {number} options.camera the view's camera uniform resource
- * @param {number} options.meshlets the drawn bodies' meshlets resource, from {@link GPUWaterBodies#meshlets}
+ * @param {number} options.meshlets the drawn bodies' meshlets resource, from {@link graph_water_meshlets}
  * @param {number} options.lod_bodies the view's per-body lattice frames resource, from the same
  * @param {number} options.meshlet_capacity every water meshlet the scene holds: the triangle slots there can be
  * @param {{ranges: number, orthographic: number, level: number, distance: number}} options.lod the view's lattice choice

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

@@ -3218,7 +3218,15 @@ function inferBuiltinReturnType(name, args) {
         // the two values; the third argument is the condition
         return commonArgumentType(args.slice(0, 2));
     }
-    if (name === 'textureLoad' || name === 'textureSampleLevel' || name === 'textureSample' || name === 'textureSampleBias' || name === 'textureSampleGrad') {
+    if (name === 'textureLoad') {
+        // A texel is the texture's declared sample type, its format's for a storage texture: an integer texture
+        // loads integers, and a `bitcast` of one must see a u32 or i32, not an f32 that happens to hold the word.
+        const texture = args[0] !== undefined ? args[0].type : null;
+        const scalar = texture !== null && texture.kind === 'texture' ? texture.scalar : 'f32';
+        return { kind: 'vec', size: 4, scalar: scalar === 'u32' || /uint$/.test(scalar) ? 'u32'
+            : scalar === 'i32' || /sint$/.test(scalar) ? 'i32' : 'f32' };
+    }
+    if (name === 'textureSampleLevel' || name === 'textureSample' || name === 'textureSampleBias' || name === 'textureSampleGrad') {
         return { kind: 'vec', size: 4, scalar: 'f32' };
     }
     // Both gathers return the four texels of a 2x2 footprint. Saying so here matters more than

package/src/view/elements/progress/segmented/SegmentedResourceBarView.d.ts

@@ -140,25 +140,6 @@ export class SegmentedResourceBarView extends View {
      * @private
      */
     private __columns;
-    /**
-     * scratch for {@link segment_frame_transform}: [scale, offset]
-     * @type {number[]}
-     * @private
-     */
-    private __frame;
-    /**
-     * The timer that re-checks the placement while linked; 0 when none
-     * @type {number}
-     * @private
-     */
-    private __recheck_timer;
-    /**
-     * Place again if anything moved that no event reports: an ancestor's transform, the transform of an iframe the
-     * bar sits in, a move by a fraction of a pixel. Cheap when nothing did — a computed width and a few rects —
-     * and {@link updateSegments} rebuilds only on a change.
-     * @private
-     */
-    private __recheck;
     /**
      *
      * @type {List<NumericInterval>}

package/src/view/elements/progress/segmented/SegmentedResourceBarView.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SegmentedResourceBarView.d.ts","sourceRoot":"","sources":["../../../../../../src/view/elements/progress/segmented/SegmentedResourceBarView.js"],"names":[],"mappings":"AAoCA;;;;;;;;;;;;;;;;;GAiBG;AACH;IACI;;;;;;;;;;;;OAYG;IACH;QAVgD,MAAM,EAA3C,CAAC,OAAO,kBAAgB,CAAC,EAAE;QAC0B,GAAG,GAAxD,OAAO,uCAAmC;QACvB,SAAS,GAA5B,MAAM,EAAE;QAC6E,KAAK,GAA1F;YAAC,IAAI,EAAC,MAAM,CAAC;YAAC,UAAU,EAAC,MAAM,CAAC;YAAC,QAAQ,EAAC,MAAM,CAAC;YAAC,cAAc,EAAC,MAAM,CAAA;SAAC,EAAE;QAC9B,KAAK,GAAjD;YAAC,KAAK,EAAC,MAAM,CAAC;YAAC,KAAK,EAAC,MAAM,CAAA;SAAC,GAAC,IAAI;QAChB,cAAc,GAA/B,MAAM;QACW,qBAAqB,GAAtC,MAAM;QACW,qBAAqB,GAAtC,MAAM;OAyThB;IA5RG;;;;OAIG;IACH,yBAA8B;IAE9B;;;;OAIG;IACH,oBAAsB;IAEtB;;;OAGG;IACH,gBAAoB;IAEpB;;;OAGG;IACH,gBAAoB;IAEpB;;;OAGG;IACH,gBAA+B;IAG/B;;;OAGG;IACH,gCAAoD;IAEpD;;;OAGG;IACH,gCAAoD;IAEpD;;;;OAIG;IACH,yBAAyB;IAEzB;;;OAGG;IACH,yBAAgH;IAEhH;;;;OAIG;IACH,oBAAuB;IA0kB3B;;OAEG;IACH,4BASC;IAllBG,yBAA4B;IAC5B,mBAAmB;IAuiBvB;;OAEG;IACH,wBAQC;IA/iBG;;;;OAIG;IACH,oBAAwB;IAGxB,oBAAsB;IACtB,sBAAwB;IACxB,sBAAwB;IACxB,6BAA+B;IAE/B;;;;OAIG;IACH,sBAAyB;IAEzB;;;;OAIG;IACH,qBAAqB;IAErB;;;;OAIG;IACH,kBAAmB;IAEnB;;;;OAIG;IACH,gBAAqB;IAErB;;;;OAIG;IACH,wBAAwB;IA0e5B;;;;;OAKG;IACH,kBAIC;IAhfG;;;OAGG;IACH,YAFU,qBAAqB,CAEH;IAG5B,mBAAuC;IASvC;;;OAGG;IACH,mBAA+C;IAG/C;;;OAGG;IACH,sBAAuB;IAEvB;;;;OAIG;IACH,sBAAuB;IAEvB;;;;OAIG;IACH,mBAAsB;IACtB,gCAA2B;IAC3B,+BAA0B;IAkBtB;;;;OAIG;IACH,oBAAgD;IAoCpD;;;OAGG;IACH,gBAFU,QAAQ,CAsChB;IAWF;;;;OAIG;IACH,uBAA2C;IAgD/C,eAGC;IAED,wBAMC;IAED;;;;;;;OAOG;IACH,uBAiEC;IAED;;;;;;OAMG;IACH,sBAKC;IAED;;;;;;OAMG;IACH,wBA2CC;IAED;;;;;OAKG;IACH,sBAoBC;IAED,mBAiDC;IAED;;;;OAIG;IACH,eAaC;IAED;;;;OAIG;IACH,qBAoBC;IA2BD;;;;OAIG;IACH,mCAUC;CAeJ;iBA9uBgB,kBAAkB;iBALlB,0CAA0C;qBAGtC,6BAA6B;oBAF9B,kCAAkC"}
+{"version":3,"file":"SegmentedResourceBarView.d.ts","sourceRoot":"","sources":["../../../../../../src/view/elements/progress/segmented/SegmentedResourceBarView.js"],"names":[],"mappings":"AA4BA;;;;;;;;;;;;;;;;;GAiBG;AACH;IACI;;;;;;;;;;;;OAYG;IACH;QAVgD,MAAM,EAA3C,CAAC,OAAO,kBAAgB,CAAC,EAAE;QAC0B,GAAG,GAAxD,OAAO,uCAAmC;QACvB,SAAS,GAA5B,MAAM,EAAE;QAC6E,KAAK,GAA1F;YAAC,IAAI,EAAC,MAAM,CAAC;YAAC,UAAU,EAAC,MAAM,CAAC;YAAC,QAAQ,EAAC,MAAM,CAAC;YAAC,cAAc,EAAC,MAAM,CAAA;SAAC,EAAE;QAC9B,KAAK,GAAjD;YAAC,KAAK,EAAC,MAAM,CAAC;YAAC,KAAK,EAAC,MAAM,CAAA;SAAC,GAAC,IAAI;QAChB,cAAc,GAA/B,MAAM;QACW,qBAAqB,GAAtC,MAAM;QACW,qBAAqB,GAAtC,MAAM;OAyShB;IA5QG;;;;OAIG;IACH,yBAA8B;IAE9B;;;;OAIG;IACH,oBAAsB;IAEtB;;;OAGG;IACH,gBAAoB;IAEpB;;;OAGG;IACH,gBAAoB;IAEpB;;;OAGG;IACH,gBAA+B;IAG/B;;;OAGG;IACH,gCAAoD;IAEpD;;;OAGG;IACH,gCAAoD;IAEpD;;;;OAIG;IACH,yBAAyB;IAEzB;;;OAGG;IACH,yBAAgH;IAEhH;;;;OAIG;IACH,oBAAuB;IAgiB3B;;OAEG;IACH,4BASC;IAxiBG,yBAA4B;IAC5B,mBAAmB;IA6fvB;;OAEG;IACH,wBAQC;IArgBG;;;;OAIG;IACH,oBAAwB;IAGxB,oBAAsB;IACtB,sBAAwB;IACxB,sBAAwB;IACxB,6BAA+B;IAE/B;;;;OAIG;IACH,sBAAyB;IAEzB;;;;OAIG;IACH,qBAAqB;IAErB;;;;OAIG;IACH,kBAAmB;IAEnB;;;OAGG;IACH,YAFU,qBAAqB,CAEH;IAG5B,mBAAuC;IASvC;;;OAGG;IACH,mBAA+C;IAG/C;;;OAGG;IACH,sBAAuB;IAEvB;;;;OAIG;IACH,sBAAuB;IAEvB;;;;OAIG;IACH,mBAAsB;IACtB,gCAA2B;IAC3B,+BAA0B;IAkBtB;;;;OAIG;IACH,oBAAgD;IAoCpD;;;OAGG;IACH,gBAFU,QAAQ,CAsChB;IAWF;;;;OAIG;IACH,uBAA2C;IAuC/C,eAGC;IAED,wBAMC;IAED;;;;;;;OAOG;IACH,uBA4DC;IAED;;;;;;OAMG;IACH,sBAKC;IAED;;;;;;OAMG;IACH,wBA2CC;IAED;;;;;OAKG;IACH,sBAoBC;IAED,mBAiDC;IAED;;;;OAIG;IACH,eAaC;IAED;;;;OAIG;IACH,qBAoBC;IAeD;;;;OAIG;IACH,mCAUC;CAeJ;iBA5rBgB,kBAAkB;iBALlB,0CAA0C;qBAGtC,6BAA6B;oBAF9B,kCAAkC"}

package/src/view/elements/progress/segmented/SegmentedResourceBarView.js

@@ -10,7 +10,6 @@ import { GhostTrail } from "./GhostTrail.js";
 import { SEGMENT_TIERS_DEFAULT } from "./SEGMENT_TIERS_DEFAULT.js";
 import { segment_cell_extent } from "./segment_cell_extent.js";
 import { segment_cell_layout } from "./segment_cell_layout.js";
-import { segment_frame_transform } from "./segment_frame_transform.js";
 import { segment_mask_apply, segment_mask_url } from "./segment_mask_url.js";
 import { segment_mask_width } from "./segment_mask_width.js";
 import { segment_tick_positions } from "./segment_tick_positions.js";
@@ -27,13 +26,6 @@ const REBUILD_WIDTH_THRESHOLD_PX = 0.5;
  */
 const UNSCALED_TOLERANCE = 2e-3;
 
-/**
- * How often a linked bar checks that its notches or cells still sit on the screen's pixels, in milliseconds. A
- * transform on an ancestor or on a containing iframe moves them without any event the bar hears.
- * @type {number}
- */
-const RECHECK_INTERVAL_MS = 250;
-
 /**
  * Resource bar in the style of a MOBA health bar: the values fill it end to end, notches mark fixed amounts, and
  * a ghost behind the fill trails a drop so the loss stays readable for a moment.
@@ -197,22 +189,6 @@ export class SegmentedResourceBarView extends View {
          */
         this.__columns = [];
 
-        /**
-         * scratch for {@link segment_frame_transform}: [scale, offset]
-         * @type {number[]}
-         * @private
-         */
-        this.__frame = [1, 0];
-
-        /**
-         * The timer that re-checks the placement while linked; 0 when none
-         * @type {number}
-         * @private
-         */
-        this.__recheck_timer = 0;
-
-        this.__recheck = this.__recheck.bind(this);
-
         /**
          *
          * @type {List<NumericInterval>}
@@ -388,10 +364,6 @@ export class SegmentedResourceBarView extends View {
         this.__sizeObserver.start();
         this.__watch_device_pixel_ratio();
         this.update();
-
-        if (typeof setInterval === 'function') {
-            this.__recheck_timer = setInterval(this.__recheck, RECHECK_INTERVAL_MS);
-        }
     }
 
     unlink() {
@@ -401,11 +373,6 @@ export class SegmentedResourceBarView extends View {
 
         this.__sizeObserver.stop();
 
-        if (this.__recheck_timer !== 0) {
-            clearInterval(this.__recheck_timer);
-            this.__recheck_timer = 0;
-        }
-
         if (this.__dpr_query !== null) {
             this.__dpr_query.removeEventListener('change', this.__handle_dpr_change);
             this.__dpr_query = null;
@@ -463,21 +430,16 @@ export class SegmentedResourceBarView extends View {
 
         const dpr = typeof devicePixelRatio === 'number' && devicePixelRatio > 0 ? devicePixelRatio : 1;
 
-        // how the iframes this bar sits in are drawn by the pages around them — invisible from in here
-        const frame = segment_frame_transform(el.ownerDocument.defaultView, this.__frame);
-        const frame_scale = frame[0];
-        const frame_offset = frame[1];
-
         // a CSS scale on an ancestor shows each CSS pixel of the bar as `scale` page pixels. The computed width is
         // serialised to a few decimals (175.844 for 175.84375), so an unscaled bar measures a hair off 1 — enough to
         // put a width that should be whole in device pixels just past it — and is read as unscaled
-        const measured_scale = (rect.width > 0 ? rect.width / layout_width : 1) * frame_scale;
+        const measured_scale = rect.width > 0 ? rect.width / layout_width : 1;
         const scale = Math.abs(measured_scale - 1) < UNSCALED_TOLERANCE ? 1 : measured_scale;
 
         // device pixels per CSS pixel of the bar
         const ratio = dpr * scale;
 
-        const origin_device = (frame_offset + rect.left * frame_scale) * dpr;
+        const origin_device = rect.left * dpr;
         const origin_phase = origin_device - Math.round(origin_device);
 
         const max = this.__value_max.getValue();
@@ -699,18 +661,6 @@ export class SegmentedResourceBarView extends View {
         ghost.width = `${segment_cell_extent(layout, ghost_fraction * count) / ratio}px`;
     }
 
-    /**
-     * Place again if anything moved that no event reports: an ancestor's transform, the transform of an iframe the
-     * bar sits in, a move by a fraction of a pixel. Cheap when nothing did — a computed width and a few rects —
-     * and {@link updateSegments} rebuilds only on a change.
-     * @private
-     */
-    __recheck() {
-        if (this.isLinked) {
-            this.updateSegments();
-        }
-    }
-
     /**
      * @private
      */