@woosh/meep-engine 3.60.4 → 3.60.5

package/src/shade/renderer/material/resident/GPUResidentMaterialContext.js

@@ -1,13 +1,11 @@
 import { assert } from "../../../../core/assert.js";
 import { HashMap } from "../../../../core/collection/map/HashMap.js";
-import Signal from "../../../../core/events/signal/Signal.js";
 import IdPool from "../../../../core/IdPool.js";
 import { isPowerOfTwo } from "../../../../core/math/isPowerOfTwo.js";
 import { round_up } from "../../../../core/math/round_up.js";
 import { TextureViewDescriptor } from "../../../descriptor/texture/TextureViewDescriptor.js";
 import { ShadeGPUCommandContext } from "../../../device/ShadeGPUCommandContext.js";
 import { GPU_DATABASE_NULL } from "../../buffer/table/GPU_DATABASE_NULL.js";
-import { WEBGPU_GUARANTEED_MAX_COMPUTE_WORKGROUPS_PER_DIMENSION } from "../../gpu_primitive/indirect/WEBGPU_GUARANTEED_MAX_COMPUTE_WORKGROUPS_PER_DIMENSION.js";
 import { MEDIA_TABLE_CAPACITY, MEDIA_TABLE_STRUCT } from "../../medium/MEDIA_TABLE_STRUCT.js";
 import { MEDIUM_STRUCT } from "../../medium/MEDIUM_STRUCT.js";
 import { write_gpu_typed_buffer } from "../../shader/type/serde/write_gpu_typed_buffer.js";
@@ -25,7 +23,6 @@ import {
     RESIDENT_MATERIAL_TEXTURE_RESOLUTION,
     RESIDENT_MATERIAL_TEXTURE_SLOT_RESOLUTION
 } from "./RESIDENT_MATERIAL_TEXTURE_LAYOUT.js";
-import { shader_resident_texture_means, shader_resident_texture_rows } from "./shader_resident_texture_means.js";
 
 /**
  * @typedef {import("../../GraphicsContext.js").GraphicsContext} GraphicsContext
@@ -131,13 +128,6 @@ const NEUTRAL_SURFACE = Object.freeze({
 
 export class GPUResidentMaterialContext {
 
-    /**
-     * Sent with a material when it is repacked because its {@link ShadeMaterial#version} moved: the
-     * row the device reads changes with the next {@link update}. Not sent for a material's first pack.
-     * @type {Signal<ShadeMaterial>}
-     */
-    onMaterialRepacked = new Signal();
-
     /**
      * @type {GraphicsContext}
      */
@@ -200,31 +190,6 @@ export class GPUResidentMaterialContext {
         return this.#buffer_textures;
     }
 
-    /**
-     * Each texture slot's mean, `vec4<f32>`, of its texels as the atlas stores them: an albedo's colour
-     * premultiplied by its coverage. Written whenever the textures are (§6.6 of
-     * PROBE_CLIPMAP_PROPOSAL_2026_10_27.md): what a GI hit that no card sees takes of its material.
-     * Replaced when the slots outgrow it, so take it each frame.
-     *
-     * @type {GPUBuffer}
-     */
-    #buffer_texture_means;
-
-    /** The rows' sums the means are made of. @type {GPUBuffer|null} */
-    #buffer_texture_rows = null;
-
-    /** Slots the means hold. */
-    #texture_means_capacity = 0;
-
-    #texture_means_settings = { slot_count: 0 };
-
-    /**
-     * @returns {GPUBuffer}
-     */
-    get buffer_texture_means() {
-        return this.#buffer_texture_means;
-    }
-
     /**
      *
      * @returns {GPUTextureView}
@@ -368,13 +333,6 @@ export class GPUResidentMaterialContext {
             size: MEDIA_TABLE_STRUCT.size,
         });
 
-        // a slot's worth until the first textures are written
-        this.#buffer_texture_means = device.createBuffer({
-            label: 'Material Texture Means',
-            usage: GPUBufferUsage.STORAGE,
-            size: 16,
-        });
-
         this.#buffer_textures = new GPUTextureContext(device);
         const descriptor = this.#buffer_textures.descriptor;
 
@@ -485,8 +443,8 @@ export class GPUResidentMaterialContext {
      * Make a material resident, or repack it if its {@link ShadeMaterial#version} has moved since —
      * the same contract {@link GPUMaterialManager} restages by. A hit used to be final, so a factor
      * set after the first pack never reached the row. Every caller re-obtains what it needs before
-     * {@link update}: the scene's drawn list, and the manager's materials whenever its version
-     * moves, so the check rides on walks that already happen.
+     * {@link update} or {@link commit}: the scene's drawn list, the manager's materials whenever its
+     * version moves, or what a card capture traces, so the check rides on walks that already happen.
      *
      * @param {ShadeMaterial} material
      * @returns {MaterialInfo}
@@ -505,8 +463,6 @@ export class GPUResidentMaterialContext {
             this.#pack_material(info);
         } else if (info.version !== material.version) {
             this.#pack_material(info);
-
-            this.onMaterialRepacked.send1(material);
         }
 
         return info;
@@ -592,8 +548,6 @@ export class GPUResidentMaterialContext {
             }
         }
 
-        this.#record_texture_means(encoder, textures);
-
         encoder.finish();
 
     }
@@ -683,65 +637,6 @@ export class GPUResidentMaterialContext {
         }
     }
 
-    /**
-     * Every texture slot's mean, after the slots are written (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §6.6):
-     * the rows' sums, then the slots' means, which {@link buffer_texture_means} holds.
-     *
-     * @param {ShadeGPUCommandContext} encoder
-     * @param {TextureInfo[]} textures
-     */
-    #record_texture_means(encoder, textures) {
-        let slot_count = 0;
-
-        for (let i = 0; i < textures.length; i++) {
-            slot_count = Math.max(slot_count, textures[i].id + 1);
-        }
-
-        if (slot_count === 0) {
-            return;
-        }
-
-        if (this.#texture_means_capacity < slot_count) {
-            // textures arrive a few at a time as a scene loads: doubling replaces the buffers a
-            // logarithmic number of times
-            const capacity = Math.max(slot_count, 2 * this.#texture_means_capacity);
-
-            this.#buffer_texture_means.destroy();
-            this.#buffer_texture_rows?.destroy();
-
-            this.#texture_means_capacity = capacity;
-            this.#buffer_texture_means = this.#device.createBuffer({
-                label: 'Material Texture Means',
-                usage: GPUBufferUsage.STORAGE,
-                size: 16 * capacity,
-            });
-            this.#buffer_texture_rows = this.#device.createBuffer({
-                label: 'Material Texture Rows',
-                usage: GPUBufferUsage.STORAGE,
-                size: 16 * RESIDENT_MATERIAL_TEXTURE_RESOLUTION * capacity,
-            });
-        }
-
-        const settings = this.#texture_means_settings;
-
-        settings.slot_count = slot_count;
-
-        // a workgroup a slot, folded as folded_workgroup_index reads it: the array holds more slots than a
-        // dimension does
-        shader_resident_texture_rows.dispatch({
-            encoder,
-            group_count_x: Math.min(slot_count, WEBGPU_GUARANTEED_MAX_COMPUTE_WORKGROUPS_PER_DIMENSION),
-            group_count_y: Math.ceil(slot_count / WEBGPU_GUARANTEED_MAX_COMPUTE_WORKGROUPS_PER_DIMENSION),
-            bindings: { settings, textures: this.textureView, texture_rows: this.#buffer_texture_rows },
-        });
-
-        shader_resident_texture_means.dispatch({
-            encoder,
-            group_count_x: Math.ceil(slot_count / 64),
-            bindings: { settings, texture_rows: this.#buffer_texture_rows, texture_means: this.#buffer_texture_means },
-        });
-    }
-
     build_materials() {
 
         /**
@@ -871,25 +766,29 @@ export class GPUResidentMaterialContext {
 
     }
 
-    update() {
-
-        this.#update_from_manager();
-
+    /**
+     * Write what {@link obtain_material} made resident or repacked since the last commit, and the media
+     * that moved. Takes none of the manager's materials, unlike {@link update}: for a reader that makes
+     * resident only what it reads.
+     */
+    commit() {
         this.#write_media();
-
-        if (this.#version === this.#version_commited) {
-            return;
-        }
-
         this.#commit();
     }
 
+    /**
+     * Make every material the manager holds resident, then {@link commit}: for the readers that trace
+     * the whole scene.
+     */
+    update() {
+        this.#update_from_manager();
+        this.commit();
+    }
+
 
     destroy() {
         this.#buffer_materials.destroy();
         this.#buffer_media.destroy();
         this.#buffer_textures.destroy();
-        this.#buffer_texture_means.destroy();
-        this.#buffer_texture_rows?.destroy();
     }
 }

package/src/shade/renderer/shadow/map/GPUSceneShadowmapContext.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUSceneShadowmapContext.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shadow/map/GPUSceneShadowmapContext.js"],"names":[],"mappings":"AA0JA;;GAEG;AACH;IA8aI;;;;;;;;OAQG;IACH,sBAPW,eAAe,aACf,eAAe,SAGf,kBAAkB,EAiE5B;IApfD,2BAAwG;IAExG;;;OAGG;IACH,SAFU,iBAAiB,CAEnB;IAQR;;;;;;;;OAQG;IACH,qBAFU,WAAW,CAED;IAsCpB;;;;;;;;OAQG;IACH,SAFU,OAAO,CAEF;IAEf;;;;;;;;;;OAUG;IACH,+BAFU,OAAO,CAEqB;IAEtC;;;;;;OAMG;IACH,yBAFU,OAAO,CAEe;IAehC;;;;;OAKG;IACH,mCAIC;IAjBD;;OAEG;IACH,kCAEC;IAcD;;;;;OAKG;IACH,kBAFU,MAAM,CAEK;IAiBrB;;;;OAIG;IACH,uCAMC;IAlBD;;OAEG;IACH,sCAEC;IA6BD;;;;OAIG;IACH,uCAMC;IAlBD;;OAEG;IACH,sCAEC;IA6BD;;;;OAIG;IACH,4CAKC;IAjBD;;OAEG;IACH,2CAEC;IA2BD;;;;;OAKG;IACH,wCAKC;IAlBD;;OAEG;IACH,uCAEC;IA4BD;;;;;;;;OAQG;IACH,6BAIC;IApBD;;OAEG;IACH,4BAEC;IA0CD;;;;OAIG;IACH,6BAIC;IAhBD;;OAEG;IACH,4BAEC;IA2FD;;OAEG;IACH,iCAEC;IAED;;;;;;OAMG;IACH,oCAEC;IAED;;;;;OAKG;IACH,oCAEC;IAoGD;;;;;OAKG;IACH,4BAMC;IA2MD;;;;;;;;;;;;OAYG;IACH;QAN+B,KAAK,EAAzB,UAAU;QACqD,IAAI,EAAnE,OAAO,8BAA8B,EAAE,cAAc;QACrC,KAAK,EAArB,MAAM;QACU,MAAM,EAAtB,MAAM;aA+BhB;IA0LD;;;;OAIG;IACH,eAHW,KAAK,GACH,SAAS,GAAC,SAAS,CAI/B;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4CG;IACH,6BAPW,MAAM,SAEN,eAAe,eACf,MAAM,mBACN,UAAU,MAAM,CAAC,QA0G3B;IA2GD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA+BG;IACH,kBAFW,sBAAsB,QA0FhC;IAwbD;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,kBALa,OAAO,CAsTnB;IAED;;;;;;;;;;OAUG;IACH,iBALW,MAAM,SACN,MAAM,GACJ,KAAK,CAejB;IA2DD,gBAiBC;;CACJ;qCAruEY,OAAO,2CAA2C,EAAE,sBAAsB;8BAC1E,OAAO,0BAA0B,EAAE,eAAe;qBAClD,OAAO,wBAAwB,EAAE,MAAM;iCACvC,OAAO,mCAAmC,EAAE,kBAAkB;oBAC9D,OAAO,4BAA4B,EAAE,KAAK;8BAC1C,OAAO,gCAAgC,EAAE,eAAe;wBACxD,OAAO,gBAAgB,EAAE,SAAS;8BAClC,OAAO,oDAAoD,EAAE,eAAe;oCAhFrD,+DAA+D;kCAkBjE,oCAAoC;4BAG1C,2BAA2B;2BApB5B,8DAA8D;kBAFvE,wCAAwC"}
+{"version":3,"file":"GPUSceneShadowmapContext.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shadow/map/GPUSceneShadowmapContext.js"],"names":[],"mappings":"AA+JA;;GAEG;AACH;IA8aI;;;;;;;;OAQG;IACH,sBAPW,eAAe,aACf,eAAe,SAGf,kBAAkB,EAiE5B;IApfD,2BAAwG;IAExG;;;OAGG;IACH,SAFU,iBAAiB,CAEnB;IAQR;;;;;;;;OAQG;IACH,qBAFU,WAAW,CAED;IAsCpB;;;;;;;;OAQG;IACH,SAFU,OAAO,CAEF;IAEf;;;;;;;;;;OAUG;IACH,+BAFU,OAAO,CAEqB;IAEtC;;;;;;OAMG;IACH,yBAFU,OAAO,CAEe;IAehC;;;;;OAKG;IACH,mCAIC;IAjBD;;OAEG;IACH,kCAEC;IAcD;;;;;OAKG;IACH,kBAFU,MAAM,CAEK;IAiBrB;;;;OAIG;IACH,uCAMC;IAlBD;;OAEG;IACH,sCAEC;IA6BD;;;;OAIG;IACH,uCAMC;IAlBD;;OAEG;IACH,sCAEC;IA6BD;;;;OAIG;IACH,4CAKC;IAjBD;;OAEG;IACH,2CAEC;IA2BD;;;;;OAKG;IACH,wCAKC;IAlBD;;OAEG;IACH,uCAEC;IA4BD;;;;;;;;OAQG;IACH,6BAIC;IApBD;;OAEG;IACH,4BAEC;IA0CD;;;;OAIG;IACH,6BAIC;IAhBD;;OAEG;IACH,4BAEC;IA2FD;;OAEG;IACH,iCAEC;IAED;;;;;;OAMG;IACH,oCAEC;IAED;;;;;OAKG;IACH,oCAEC;IAoGD;;;;;OAKG;IACH,4BAMC;IA2MD;;;;;;;;;;;;OAYG;IACH;QAN+B,KAAK,EAAzB,UAAU;QACqD,IAAI,EAAnE,OAAO,8BAA8B,EAAE,cAAc;QACrC,KAAK,EAArB,MAAM;QACU,MAAM,EAAtB,MAAM;aA+BhB;IA0LD;;;;OAIG;IACH,eAHW,KAAK,GACH,SAAS,GAAC,SAAS,CAI/B;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4CG;IACH,6BAPW,MAAM,SAEN,eAAe,eACf,MAAM,mBACN,UAAU,MAAM,CAAC,QA0G3B;IA2GD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA+BG;IACH,kBAFW,sBAAsB,QA0FhC;IAwbD;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,kBALa,OAAO,CAsTnB;IAED;;;;;;;;;;OAUG;IACH,iBALW,MAAM,SACN,MAAM,GACJ,KAAK,CAejB;IA2DD,gBAiBC;;CACJ;qCA1uEY,OAAO,2CAA2C,EAAE,sBAAsB;8BAC1E,OAAO,0BAA0B,EAAE,eAAe;qBAClD,OAAO,wBAAwB,EAAE,MAAM;iCACvC,OAAO,mCAAmC,EAAE,kBAAkB;oBAC9D,OAAO,4BAA4B,EAAE,KAAK;8BAC1C,OAAO,gCAAgC,EAAE,eAAe;wBACxD,OAAO,gBAAgB,EAAE,SAAS;8BAClC,OAAO,oDAAoD,EAAE,eAAe;oCAhFrD,+DAA+D;kCAkBjE,oCAAoC;4BAG1C,2BAA2B;2BApB5B,8DAA8D;kBAFvE,wCAAwC"}

package/src/shade/renderer/shadow/map/GPUSceneShadowmapContext.js

@@ -95,11 +95,16 @@ const DEFAULT_SHADOWMAP_ATLAS_RESOLUTION = 4096;
 /**
  * Resolution by cascade.
  * If the number of cascades is greater than the array length, the last resolution is used.
+ *
+ * 1536 is chosen for the cascade's HZB: half of it, 768 = 3·2⁸, is a mip 0 the HZB takes as it is, with
+ * no padding, so mip 0 halves the cascade exactly (a 2x2 footprint) and the rest of the pyramid is two
+ * 4-mip SPD passes and one single-mip pass. 1740 and 1440 padded mip 0 to 880 and 736, a 3x3 footprint
+ * and five single-mip passes each. Three cascades at 1536² hold about the texels 1740² + 2·1440² did.
+ *
  * @type {number[]}
  */
 const DEFAULT_SHADOWMAP_DIRECTIONAL_RESOLUTION = [
-    1740, // first cascade
-    1440,
+    1536,
 ];
 
 /**

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

@@ -17,12 +17,6 @@ export class GPUWaterRenderer {
         inscatter_segments: number;
         tessellation_pixels: number;
     };
-    /**
-     * 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: import("./medium/GPUWaterBodies.js").GPUWaterBodies | null;
     /**
      * What the lattice's per-frame lists may hold (WATER_SURFACE_DISTANCE_LOD_PROPOSAL_2026_10_06.md §4.3). Grown from
      * each view's totals, read back a frame or two later; a frame over a budget drops its tail until then.

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":"AAoBA,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;IAmBd;;;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;gCA3X+B,uCAAuC"}
+{"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;IAmB7B;;;OAGG;IACH;;;;;MAA8F;IAC9F;;;OAGG;IACH,wBAAyD;IAMzD,oCAIC;IAED,8FAA8F;IAC9F,qCAgBC;IAED,gBASC;IAuDD;;;;;;;;;;;;;;;;;MAyIC;IAQD;;;;;YAMC;IAED;;;;;;;;;;MAOC;IAED;;;;;;;;;;;;;;MAwBC;IAED,gGAAgG;IAChG,mEAYC;;CAyBJ;gCAtX+B,uCAAuC"}

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"}