@woosh/meep-engine 3.50.0 → 3.51.0

package/src/shade/renderer/shader/chunk/texture/sample/chunk_sample_environment_map.js

@@ -2,10 +2,28 @@ import {
     chunk_sphere_probe_roughness_to_lod
 } from "../../../../light/environment/chunk_sphere_probe_roughness_to_lod.js";
 import { CodeChunk } from "../../../compiler/CodeChunk.js";
-import { chunk_texture_octahedral_sample_bilinear } from "../octahedral/chunk_texture_octahedral_sample_bilinear.js";
+import { chunk_uv_octahedral_unit_encode } from "../../geometry/octahedron/chunk_uv_octahedral_unit_encode.js";
+import { chunk_texture_octahedral_skirt_uv } from "../octahedral/chunk_texture_octahedral_skirt_uv.js";
 
 /**
- * Works on ann octahedral-encoded pre-filtered environment map
+ * Works on an octahedral-encoded pre-filtered environment map with a one-texel octahedral skirt on
+ * every level it reads (see `texture_octahedral_skirt_uv`).
+ *
+ * Trilinear as two hardware bilinear taps, one per level, blended here: each level's interior is its
+ * own size less the skirt, so one uv cannot address two levels and the sampler's own mip blend would
+ * read the coarser one up to a texel off. Most texture units filter trilinear at half the bilinear
+ * rate anyway, so the second tap costs about what the hardware blend would.
+ *
+ * Measured against the manual form this replaces (8 loads, 4 octahedral wraps a level, each wrap
+ * two integer divisions and remainders), radiance + irradiance over 1920x1080: 88 → 17 µs on an RTX
+ * 4090, 15.4 → 1.3 ms on an RDNA2 iGPU, whose integer division is emulated.
+ *
+ * Every level the roughness mapping reaches (0 to `SPHERE_PROBE_MIPMAP_LEVELS - 1`) must be at least
+ * 3 texels wide to have an interior. A level's size is the texture's halved and kept at 1 or more, as
+ * a level's extent is, so a smaller map (the renderer's 1x1 black stand-in, a test's constant) still
+ * samples at a finite uv. At the roughest level the second tap reads the level past it at weight 0; a
+ * texture without one clamps to the last level, which the weight discards just the same.
+ *
  * @see https://github.com/GPUOpen-LibrariesAndSDKs/FidelityFX-SDK/blob/1bbe66e7ea0d358e84af4471a90aa9c35b583de0/samples/hybridreflections/shaders/Common.hlsl#L118
  * @type {CodeChunk}
  */
@@ -13,39 +31,39 @@ export const chunk_sample_environment_map = CodeChunk.from(
     //language=WGSL
     `
 fn sample_environment_map(
-    tEnvironment:texture_2d<f32>, 
-    direction: vec3<f32>, 
+    tEnvironment: texture_2d<f32>,
+    sEnvironment: sampler,
+    direction: vec3<f32>,
     roughness: f32
 ) -> vec3<f32> {
-    
+
     let lod = sphere_probe_roughness_to_lod(roughness);
-        
-    let lod_0 = u32(floor(lod));
-    let f = fract(lod);
-    
-    let color_0 = texture_octahedral_sample_bilinear(
+
+    let lod_0 = floor(lod);
+    let level_0 = u32(lod_0);
+
+    let octahedral_uv = uv_octahedral_unit_encode(direction);
+    let size = textureDimensions(tEnvironment).x;
+
+    let color_0 = textureSampleLevel(
         tEnvironment,
-        vec2(0u),
-        textureDimensions(tEnvironment, lod_0).x,
-        direction,
+        sEnvironment,
+        texture_octahedral_skirt_uv(octahedral_uv, f32(max(size >> level_0, 1u))),
         lod_0
-    ).rgb;  
-     
-    let lod_1 = lod_0 + 1u;
-    
-    let color_1 = texture_octahedral_sample_bilinear(
+    ).rgb;
+
+    let color_1 = textureSampleLevel(
         tEnvironment,
-        vec2(0u),
-        textureDimensions(tEnvironment, lod_1).x,
-        direction,
-        lod_1
+        sEnvironment,
+        texture_octahedral_skirt_uv(octahedral_uv, f32(max(size >> (level_0 + 1u), 1u))),
+        lod_0 + 1.0
     ).rgb;
-    
-    
-    return mix(color_0, color_1, f);
+
+    return mix(color_0, color_1, lod - lod_0);
 }
     `, [
         chunk_sphere_probe_roughness_to_lod,
-        chunk_texture_octahedral_sample_bilinear,
+        chunk_uv_octahedral_unit_encode,
+        chunk_texture_octahedral_skirt_uv,
     ]
-);
+);

package/src/shade/renderer/view/GPUViewSkyContext.js

@@ -1,170 +1,170 @@
-import { m3_cm_compose_transform } from "../../../core/geom/mat3/m3_cm_compose_transform.js";
-import { FrameGraph } from "../../../engine/graphics/render/frame_graph/FrameGraph.js";
-import { Sampler2D } from "../../../engine/graphics/texture/sampler/Sampler2D.js";
-import sampler2d_to_html_canvas
-    from "../../../engine/graphics/texture/sampler/sampler2d_to_html_canvas.js";
-import { writeCssTransformMatrix } from "../../../view/writeCssTransformMatrix.js";
-import { TextureResourceDescriptor } from "../../device/graph/TextureResourceDescriptor.js";
-import { ShadeGPUCommandContext } from "../../device/ShadeGPUCommandContext.js";
-import { SPHERE_PROBE_MIPMAP_LEVELS } from "../light/environment/DEFINES.js";
-import { graph_filter_environment_map } from "../light/environment/graph_filter_environment_map.js";
-import { shader_sky_irradiance_lut } from "../atmosphere/shader_sky_irradiance_lut.js";
-import { graph_image_pass } from "../shader/graph/graph_image_pass.js";
-import { GPUTextureContext } from "../texture/GPUTextureContext.js";
-import { sampler_linear_to_sRGB } from "../texture/sampler_linear_to_sRGB.js";
-
-let debug_counter = 0;
-
-export class GPUViewSkyContext {
-
-
-    /**
-     * @type {GraphicsContext}
-     */
-    #graphics;
-
-    /**
-     * @type {GPUTextureContext}
-     */
-    #lut_sky;
-
-
-    /**
-     *
-     * @returns {GPUTextureContext}
-     */
-    get irradiance_lut() {
-        return this.#lut_sky;
-    }
-
-    /**
-     *
-     * @param {GraphicsContext} graphics
-     */
-    constructor(graphics) {
-        this.#graphics = graphics;
-
-        const device = graphics.device;
-
-        this.#lut_sky = new GPUTextureContext(device);
-        this.#lut_sky.descriptor.label = "Sky / Irradiance LUT";
-        this.#lut_sky.descriptor.format = "rgba16float";
-        this.#lut_sky.descriptor.mipLevelCount = SPHERE_PROBE_MIPMAP_LEVELS;
-        this.#lut_sky.descriptor.usage = GPUTextureUsage.RENDER_ATTACHMENT
-            | GPUTextureUsage.TEXTURE_BINDING
-            | GPUTextureUsage.STORAGE_BINDING
-            | GPUTextureUsage.COPY_SRC
-        ;
-        this.#lut_sky.resize(1024, 1024);
-
-    }
-
-    #needs_update = true;
-
-    set needs_update(v) {
-        if (v) {
-            this.#needs_update = true;
-        }
-    }
-
-    /**
-     *
-     * @param {GPUCameraContext} camera
-     * @param {GPUSceneContext} scene
-     */
-    update(camera, scene) {
-
-        if (!this.#needs_update) {
-            return;
-        }
-
-        this.#needs_update = false;
-
-        // ensure base sky LUTs are up-to-date
-        /**
-         *
-         * @type {GPUSky}
-         */
-        const scene_sky = scene.sky;
-        scene_sky.update();
-
-        const graph = new FrameGraph("sky update");
-
-        const command_ctx = ShadeGPUCommandContext.create(
-            this.#graphics,
-            "Renderer/main"
-        );
-
-        const gr_transmittance = graph.import_resource("transmittance", TextureResourceDescriptor.fromTexture(scene_sky.lut_transmittance.gpu_texture), scene_sky.lut_transmittance);
-        const gr_multiscatter = graph.import_resource("multiscatter", TextureResourceDescriptor.fromTexture(scene_sky.lut_multiple_scattering.gpu_texture), scene_sky.lut_multiple_scattering);
-        const gr_sky = graph.import_resource("sky_irradiance", TextureResourceDescriptor.fromTexture(this.#lut_sky.gpu_texture), this.#lut_sky);
-
-        let [out] = graph_image_pass({
-            graph,
-            shader: shader_sky_irradiance_lut,
-            inputs: {
-                camera: camera.buffer,
-
-                light_data: scene.lights.buffer_data,
-
-                tSkyLutTransmittance: gr_transmittance,
-                tSkyLutMultiscatter: gr_multiscatter
-            },
-            output: [gr_sky]
-        });
-
-        // convolve
-        out = graph_filter_environment_map({
-            graph,
-            map: out
-        });
-
-        command_ctx.encodeGraph(graph);
-
-        command_ctx.finish();
-
-        debug_counter++;
-
-
-        // this.debug(3);
-    }
-
-    async debug(mip = 0) {
-        if (this.__debug_waiting) {
-            return;
-        }
-
-        this.__debug_waiting = true;
-
-        const texture = this.#lut_sky;
-
-        const data = await texture.download(mip);
-
-        const s = new Sampler2D(data, 4, texture.size[0] >> mip, texture.size[1] >> mip);
-        sampler_linear_to_sRGB(s);
-
-        const canvas = sampler2d_to_html_canvas(s, 255, 0, this.__debug_canvas);
-
-        if (this.__debug_canvas === undefined) {
-
-            canvas.style.zIndex = "100";
-            canvas.style.position = "absolute";
-            canvas.style.bottom = `${32}px`;
-            canvas.style.right = `${32}px`;
-
-            const transform = new Float32Array(9);
-            m3_cm_compose_transform(transform, 0, 0, 1, -1, 0, 0, 0);
-            writeCssTransformMatrix(transform, canvas);
-
-            document.body.appendChild(canvas);
-        }
-
-        this.__debug_canvas = canvas;
-
-        this.__debug_waiting = false;
-    }
-
-    destroy() {
-        this.#lut_sky.destroy();
-    }
+import { m3_cm_compose_transform } from "../../../core/geom/mat3/m3_cm_compose_transform.js";
+import { FrameGraph } from "../../../engine/graphics/render/frame_graph/FrameGraph.js";
+import { Sampler2D } from "../../../engine/graphics/texture/sampler/Sampler2D.js";
+import sampler2d_to_html_canvas
+    from "../../../engine/graphics/texture/sampler/sampler2d_to_html_canvas.js";
+import { writeCssTransformMatrix } from "../../../view/writeCssTransformMatrix.js";
+import { TextureResourceDescriptor } from "../../device/graph/TextureResourceDescriptor.js";
+import { ShadeGPUCommandContext } from "../../device/ShadeGPUCommandContext.js";
+import { SPHERE_PROBE_MIPMAP_LEVELS } from "../light/environment/DEFINES.js";
+import { graph_filter_environment_map } from "../light/environment/graph_filter_environment_map.js";
+import { SKY_IRRADIANCE_LUT_RESOLUTION, shader_sky_irradiance_lut } from "../atmosphere/shader_sky_irradiance_lut.js";
+import { graph_image_pass } from "../shader/graph/graph_image_pass.js";
+import { GPUTextureContext } from "../texture/GPUTextureContext.js";
+import { sampler_linear_to_sRGB } from "../texture/sampler_linear_to_sRGB.js";
+
+let debug_counter = 0;
+
+export class GPUViewSkyContext {
+
+
+    /**
+     * @type {GraphicsContext}
+     */
+    #graphics;
+
+    /**
+     * @type {GPUTextureContext}
+     */
+    #lut_sky;
+
+
+    /**
+     *
+     * @returns {GPUTextureContext}
+     */
+    get irradiance_lut() {
+        return this.#lut_sky;
+    }
+
+    /**
+     *
+     * @param {GraphicsContext} graphics
+     */
+    constructor(graphics) {
+        this.#graphics = graphics;
+
+        const device = graphics.device;
+
+        this.#lut_sky = new GPUTextureContext(device);
+        this.#lut_sky.descriptor.label = "Sky / Irradiance LUT";
+        this.#lut_sky.descriptor.format = "rgba16float";
+        this.#lut_sky.descriptor.mipLevelCount = SPHERE_PROBE_MIPMAP_LEVELS;
+        this.#lut_sky.descriptor.usage = GPUTextureUsage.RENDER_ATTACHMENT
+            | GPUTextureUsage.TEXTURE_BINDING
+            | GPUTextureUsage.STORAGE_BINDING
+            | GPUTextureUsage.COPY_SRC
+        ;
+        this.#lut_sky.resize(SKY_IRRADIANCE_LUT_RESOLUTION, SKY_IRRADIANCE_LUT_RESOLUTION);
+
+    }
+
+    #needs_update = true;
+
+    set needs_update(v) {
+        if (v) {
+            this.#needs_update = true;
+        }
+    }
+
+    /**
+     *
+     * @param {GPUCameraContext} camera
+     * @param {GPUSceneContext} scene
+     */
+    update(camera, scene) {
+
+        if (!this.#needs_update) {
+            return;
+        }
+
+        this.#needs_update = false;
+
+        // ensure base sky LUTs are up-to-date
+        /**
+         *
+         * @type {GPUSky}
+         */
+        const scene_sky = scene.sky;
+        scene_sky.update();
+
+        const graph = new FrameGraph("sky update");
+
+        const command_ctx = ShadeGPUCommandContext.create(
+            this.#graphics,
+            "Renderer/main"
+        );
+
+        const gr_transmittance = graph.import_resource("transmittance", TextureResourceDescriptor.fromTexture(scene_sky.lut_transmittance.gpu_texture), scene_sky.lut_transmittance);
+        const gr_multiscatter = graph.import_resource("multiscatter", TextureResourceDescriptor.fromTexture(scene_sky.lut_multiple_scattering.gpu_texture), scene_sky.lut_multiple_scattering);
+        const gr_sky = graph.import_resource("sky_irradiance", TextureResourceDescriptor.fromTexture(this.#lut_sky.gpu_texture), this.#lut_sky);
+
+        let [out] = graph_image_pass({
+            graph,
+            shader: shader_sky_irradiance_lut,
+            inputs: {
+                camera: camera.buffer,
+
+                light_data: scene.lights.buffer_data,
+
+                tSkyLutTransmittance: gr_transmittance,
+                tSkyLutMultiscatter: gr_multiscatter
+            },
+            output: [gr_sky]
+        });
+
+        // convolve
+        out = graph_filter_environment_map({
+            graph,
+            map: out
+        });
+
+        command_ctx.encodeGraph(graph);
+
+        command_ctx.finish();
+
+        debug_counter++;
+
+
+        // this.debug(3);
+    }
+
+    async debug(mip = 0) {
+        if (this.__debug_waiting) {
+            return;
+        }
+
+        this.__debug_waiting = true;
+
+        const texture = this.#lut_sky;
+
+        const data = await texture.download(mip);
+
+        const s = new Sampler2D(data, 4, texture.size[0] >> mip, texture.size[1] >> mip);
+        sampler_linear_to_sRGB(s);
+
+        const canvas = sampler2d_to_html_canvas(s, 255, 0, this.__debug_canvas);
+
+        if (this.__debug_canvas === undefined) {
+
+            canvas.style.zIndex = "100";
+            canvas.style.position = "absolute";
+            canvas.style.bottom = `${32}px`;
+            canvas.style.right = `${32}px`;
+
+            const transform = new Float32Array(9);
+            m3_cm_compose_transform(transform, 0, 0, 1, -1, 0, 0, 0);
+            writeCssTransformMatrix(transform, canvas);
+
+            document.body.appendChild(canvas);
+        }
+
+        this.__debug_canvas = canvas;
+
+        this.__debug_waiting = false;
+    }
+
+    destroy() {
+        this.#lut_sky.destroy();
+    }
 }

package/src/shade/renderer/volumetrics/NOTES.md

@@ -1118,3 +1118,212 @@ uniform wind of zero). On the software device, the froxel build dispatches the u
 scene with no fluid and the full one when the field has a cascade, judged by the module it was
 handed (red against a pass that never and one that always picks it). Driver: `wfu_*` in session
 f2a32857's scratchpad, a one-off, adapted from the GPU fluid session's `s3g_*`.
+
+## The media build walks its workgroup's volumes, pre-culled by a bin — measured on the iGPU, 2026-10-17
+
+`shader_volumetrics_build_participating_media` walked every volume of the scene from every froxel.
+Each volume cost a plane transform and a six-plane box test even where it was nowhere near the
+froxel, and on a modest GPU that was the pass. On the box's AMD RDNA2 iGPU (2 CUs, headless
+Chrome, `--use-adapter-luid`) at 1898×982, small volumes placed beyond the far plane, where no
+froxel can reach them, cost the build **0.78 ms each**:
+
+| volumes beyond the far plane | 0 | 16 | 64 | 256 |
+|---|---|---|---|---|
+| build participating media (ms) | 7.78 | 20.18 | 57.53 | 207.05 |
+
+Lighting and TAA did not move in any arm (4.0–4.4 and 5.73–5.77 ms).
+
+**Now a bin runs first.** `shader_volumetrics_bin_participating_media` dispatches one 64-lane
+workgroup per workgroup of the build (16×16 froxels × 1 slice). Its lanes take the volumes in
+turn, test each against the group's slab with the build's own rejection
+(`volumetrics_volume_in_slab`), and set the volume's bit in that group's list. The build then walks
+its group's list in row order. There is a list a group, a bit a volume, in a FrameGraph transient
+sized from the scene's volume count and cleared by the graph. A lane of the bin tests ⌈volumes /
+64⌉ volumes, whatever the resolution and however large a volume is.
+
+**The output does not change.** A volume adds to a froxel only where its coverage is above zero,
+and coverage samples points inside the froxel. The group's slab holds every froxel of the group,
+widened a quarter froxel in xy and, in z, by the column jitter's half slice plus a quarter. So a
+volume that adds anything is in the list. The walk is in row order, so the sums add in the order
+they did. `shader_volumetrics_bin_participating_media.spec.js` runs both passes under the emulator
+and compares the build's bits through the bin's lists against lists holding every volume. It is red
+with the z widening cut to the jitter-free quarter slice (1,536 and 24 differing words), and green
+with it.
+
+**The walk has a budget**, `VOLUMETRICS_MEDIA_GROUP_VOLUME_BUDGET` = 32, chosen. Past it a froxel
+drops its group's highest-indexed volumes. Before the bin the loop had no budget at all.
+
+**After**, same driver, same scene, before/after/before/after in separate processes:
+
+| volumes beyond the far plane | 0 | 16 | 64 | 256 | 1,024 |
+|---|---|---|---|---|---|
+| build participating media (ms) | 4.48 | 4.48 | 4.58 | 4.95 | 6.99 |
+| bin participating media (ms) | 0.37 | 0.37 | 0.56 | 1.15 | 3.54 |
+| sum, against before | 4.85 / 7.78 | 4.85 / 20.18 | 5.14 / 57.53 | 6.10 / 207.05 | 10.53 / — |
+
+The two runs of each side agree to 0.01 ms. The scene's own six volumes, with nothing added, go
+from 7.78 to 4.85 ms. The old build was not run at 1,024; at 0.78 ms a volume it would be about
+0.8 s. At 1,024 the build's remaining growth is the list itself: 33 words a froxel to load.
+
+The picture, by the README's protocol (45 frames settled, 16 averaged, block means of 32×32
+pixels): before against after reads a mean |d| of 0.117–0.156 with signed means within ±0.004,
+inside the floor between two processes running the *same* build (0.121 and 0.151).
+
+**A defect this turned up, fixed below.** The build's Y flip negates as well as swapping
+(`planes[2] = -planes[3]; planes[3] = -t`), so its froxel's two Y planes face *out*. The corners
+`frustum_sample_point` builds are unchanged, being intersections, but `aabb3_intersects_frustum`
+on those planes keeps a box only when it spans the froxel's whole row. Measured on the emulator: a
+1×1×1 box at depth 10 covers rows 8.8–11.2 of a 20-row grid and fogs rows 9 and 10 only. The fog
+loses up to a row at every volume's top and bottom edge, and a volume thinner than a row is never
+drawn. The bin slices its slab with the planes facing in (`volumetrics_froxel_planes`: a swap, no
+negation). Inverted planes across a group's 16 rows rejected nearly every volume, and that is how
+it showed. The build keeps its arithmetic, so the output above stays byte-identical. Fixing it
+changes the fog.
+
+**Not covered:** the aerial pass's far field, `far_sample_volumes` in
+`shader_volumetrics_build_scattering_lut`, still walks every volume at every march sample past
+`froxel_far`. With `froxel_far` at its default, the camera's far, that is only each column's last
+step, whose dithered depth can land past it: about one far-field sample a column a frame. The
+playground's `froxel_far` slider below 120 hands the whole tail to the far field, many samples a
+column. Measured in the same runs, at the default, the pass reads 0.40–0.47 ms with the scene's own
+volumes and 2.27 ms with 256 added. In the 1,024 run it reads 9.56 ms.
+
+### The split ahead of the bin: a near field and a far field — measured on the iGPU, 2026-10-17
+
+`shader_volumetrics_split_participating_media` runs before the bin, with one thread per volume.
+It drops a volume outside any of the grid's four side planes or its near plane. Those are the bin's
+planes, widened the same quarter froxel. The plane at `froxel_far` then sorts the rest:
+
+- any part of a volume nearer than `froxel_far` puts it in the near field;
+- any part beyond it puts it in the far field;
+- a volume across it goes in both.
+
+Each field is a list, a count and rows in no particular order, which the split appends to from a
+count of zero. The bin now tests only the near field, and the aerial pass's far field walks the
+far field (see "The aerial pass's far field walks the far-field list" below).
+
+**The near field holds every volume the bin could keep, at the default `froxel_far`.** That
+default is the camera's far, where the bin's last groups end. The emulator spec runs split, bin
+and build together against lists holding every volume, byte for byte. It is red with the
+discriminator at half of `froxel_far`, and its own split cases are red with the far test's
+negation dropped. With `froxel_far` pulled nearer, the grid's last slice still reaches the camera's
+far, because its jittered slab clamps there. A volume wholly between the two now belongs to the
+far field alone and no longer reaches that slice. It had been counted by both until now.
+
+**After**, against master (bin only), master/split/master/split in separate processes, with a third
+master run. Same driver, scene and 1898×982 as the section above, figures in ms:
+
+| volumes beyond the far plane | 0 | 64 | 256 | 1,024 |
+|---|---|---|---|---|
+| split | 0.012–0.014 | 0.020–0.022 | 0.009–0.011 | 0.016–0.018 |
+| bin, master → split | 0.36–0.37 → 0.35 | 0.55–0.56 → 0.35 | 1.14–1.15 → 0.35 | 3.54 → 0.35 |
+| build, master → split | 4.48–4.50 → 4.17–4.18 | 4.57–4.61 → 4.29–4.31 | 4.94–4.98 → 4.69–4.71 | 7.03–7.11 → 6.87–6.95 |
+
+The bin no longer grows with volumes the camera cannot see. The build's code is unchanged, yet it
+reads 0.3 ms less at every count. Its lists are now built from the near field only, which fits
+the split dropping volumes that a group's plane-by-plane test let through. That account is not
+verified.
+
+The picture reads the same. Master against split gives a mean |d| of 0.057–0.164, with signed means
+within ±0.003. Two runs of the same build differ by 0.177 (master) and 0.284 (split). One master
+run read 1.54 against every other run, its own build's included, and is left out.
+
+## The media build's Y planes face in — measured on the emulator and the iGPU, 2026-10-17
+
+The build turned the metadata frustum's Y pair to the grid's rows by swapping and negating. That
+left both of a froxel's Y planes facing out (the defect above). It now takes the pair from
+`volumetrics_froxel_planes`, the same swap the bin slices its slabs with, and both planes face in.
+A plane and its negation meet the other planes at the same points, so the froxel's corners do not
+move. `frustum_sample_point`, the coverage estimate and the fade therefore read exactly what they
+did. Only the box test changes. It now rejects a volume only where the froxel lies wholly outside
+it. Before, it kept a volume only in the rows the volume spanned from top to bottom.
+
+**On the emulator** (`shader_volumetrics_build_participating_media.spec.js`, a 40×20×8 grid, the
+bin spec's camera). Take a box 1 tall and 1 deep, across the whole view at depth 10. It projects
+onto rows 8.73–11.27. With its fade off, a froxel's fog is its coverage alone: the box fogged rows 9
+and 10, and now fogs 8 to 11, the rows it reaches. A box half a row tall across the middle of row 9,
+with the volume's default fade, fogged nothing and now fogs row 9. Both tests were red against the
+old flip (`[9, 10]` and `[]`) and are green. The bin's spec stays green against the corrected
+build: through the bin's lists the build still writes, bit for bit, what it writes with every volume
+listed.
+
+**The fade hides half of what the box test dropped.** A froxel whose centre ray misses the box
+takes the fallback in `compute_volume_fade_factor`, the fade at the froxel's centre. Outside the
+box that is 0. So an edge froxel gets its fog back only when its centre ray reaches into the
+volume, which means only rows the volume covers past their middle. The 1×1×1 box at depth 10 with a
+fade of 0.25 still fogs rows 9 and 10 only: it covers rows 8 and 11 to about a quarter of their
+height, short of their middles. The fallback's comment calls this case "rare if coverage > 0", but
+at a volume's edges it is every froxel whose centre ray misses. Not changed here.
+
+**In the playground, on the iGPU** (headless Chrome, `--use-adapter-luid`, 1898×982, so 119×62
+froxels of 16 px). Both flips ran in one page behind a temporary switch, on the bin as committed at
+`7f09e80b4`, before the split above; the split's spec holds the build's output byte for byte at the
+default `froxel_far`. By the README's protocol at each of the 11 viewpoints: old, new, old, new, each
+after a view change, a 45-frame settle and a 16-frame average. Each floor compares a flip with its own repeat. Mean luminance in 8-bit codes, per
+pixel:
+
+| viewpoint | signed mean, old → new | floor, old / new | mean \|d\|, old → new | floor, old / new |
+|---|---|---|---|---|
+| Dead overview | +0.011, −0.013 | −0.000 / −0.025 | 0.162, 0.160 | 0.213 / 0.214 |
+| Fog bank, wide | +0.001, +0.000 | +0.001 / +0.000 | 0.303, 0.236 | 0.320 / 0.301 |
+| Inside the fog | +0.001, +0.002 | +0.002 / +0.003 | 0.138, 0.137 | 0.163 / 0.163 |
+| Island broadside | −0.007, −0.004 | +0.001 / +0.004 | 0.114, 0.124 | 0.153 / 0.168 |
+| Island from above | −0.008, −0.003 | −0.003 / +0.002 | 0.100, 0.093 | 0.134 / 0.124 |
+| Inside the cloud deck | −0.003, −0.002 | −0.003 / −0.002 | 0.081, 0.081 | 0.093 / 0.093 |
+| Volume edge | −0.007, −0.002 | −0.009 / −0.004 | 0.129, 0.141 | 0.185 / 0.199 |
+| Volume edge, above | −0.003, +0.001 | +0.006 / +0.010 | 0.130, 0.133 | 0.179 / 0.176 |
+| Beside the fog box | −0.003, −0.022 | +0.031 / +0.012 | 0.129, 0.131 | 0.159 / 0.158 |
+| Beside the fog box, deeper | +0.023, +0.023 | −0.013 / −0.013 | 0.126, 0.127 | 0.155 / 0.153 |
+| Under the island | +0.001, +0.002 | +0.011 / +0.013 | 0.129, 0.126 | 0.165 / 0.166 |
+
+On 32×32 block means one block, in *Fog bank, wide*, moved the same way in both pairs by more
+than the largest block move between repeats of one flip: +0.09 and +0.07 against 0.06. No other
+block at any viewpoint did. The one viewpoint whose signed means agree and clear their floors,
+*Beside the fog box, deeper*, moves by 0.023 of a code. **The change is inside the picture's noise
+at every viewpoint.** The six volumes are large on screen and fade over 0.5–7 m, so a row at their
+edge carries little of their density. What the defect hid was fog in volumes that are thin or small
+on screen: one under 16 px tall here never drew at all. The floors span two captures and the
+signals one, so a slow drift (the noise scrolling with the wind) counts double in a floor. That is
+why the signals' mean |d| sits below the floors'.
+
+**Cost: unchanged.** Old against new, alternating which goes first, two rounds a viewpoint: the
+media build reads 3.19–5.62 ms across the viewpoints, and new/old has a median of 0.998 (range
+0.982–1.026). More froxels at a volume's edge now run the coverage estimate, but too few to show.
+
+Driver: `bench/job_flip.js` and `summarize_flip.mjs` in session b5223342's scratchpad, run by the
+bin session's `drive.mjs`.
+
+## The aerial pass's far field walks the far-field list — measured on the iGPU, 2026-10-17
+
+`far_sample_volumes` in `shader_volumetrics_build_scattering_lut` used to walk every volume of the
+scene at each march sample past `froxel_far`. It now walks the split's far field. The list holds
+every volume with some part beyond `froxel_far` and inside the grid's widened side planes. A sample
+on a column's view ray past `froxel_far` lies inside both, so a volume left off the list cannot
+contain it.
+
+The list is in no particular order, so the sums round differently from frame to frame. Alex
+accepted that: the volumetric TAA and the final image's TAA absorb it.
+`shader_volumetrics_build_scattering_lut.far_field.spec.js` pins that the far field adds the
+volumes the list names and no others. It is red against the shader that walked every volume.
+
+Master (the split, the far field unread) against this, in separate processes, at 1898×982, ms:
+
+| aerial pass (`build scattering lut`) | 0 volumes added | 256 | 1,024 |
+|---|---|---|---|
+| `froxel_far` 40 m (camera far 120), master | 0.68–0.75 | 12.87–12.90 | 55.75–56.27 |
+| `froxel_far` 40 m, far-field list | 0.62–0.68 | 1.60–1.63 | 5.86–5.88 |
+| `froxel_far` at its default, master | 0.54 | 2.39 | 10.72 |
+| `froxel_far` at its default, far-field list | 0.63 | 0.69 | 1.13 |
+
+The added volumes are the ones the earlier sections place beyond the far plane in random
+directions. The far field keeps only those inside the view's side planes. At the default the far
+field is reached only by each column's dithered last step, and the pass grew a tenth as fast to
+begin with. One run each at the default: its 0.09 ms at no added volumes is inside the 0.54–0.75
+the pass reads across all runs, and is not shown to be a cost. The media build reads the same in
+every arm.
+
+The picture reads the same. At the default, master against list gives a mean |d| of 0.083 against
+floors of 0.075. At 40 m the pairs give 0.15 and 0.41, against 0.55 between the two runs of the
+list's own build. The first run of the batch read 1.58 against every other run, its own build's
+included, as one master run did in the section above. Both times it was the first run of a batch,
+so it is left out and taken as a property of the driver, not of either build.

package/src/shade/renderer/volumetrics/VOLUMETRICS_METADATA_STRUCT.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"VOLUMETRICS_METADATA_STRUCT.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/volumetrics/VOLUMETRICS_METADATA_STRUCT.js"],"names":[],"mappings":"AAKA,uDA+EG;6BAlF0B,gCAAgC"}
+{"version":3,"file":"VOLUMETRICS_METADATA_STRUCT.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/volumetrics/VOLUMETRICS_METADATA_STRUCT.js"],"names":[],"mappings":"AAKA,uDA+EU;6BAlFmB,gCAAgC"}

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

@@ -82,4 +82,4 @@ export const VOLUMETRICS_METADATA_STRUCT = WebGPUStruct.from({
      * are short and local and there is far less to amortize.
      */
     sun_shadow_light_index: u32,
-});
+}).pack();