@woosh/meep-engine 3.49.0 → 3.51.0

package/src/shade/renderer/volumetrics/GPUViewVolumetrics.d.ts

@@ -30,10 +30,12 @@ export class GPUViewVolumetrics {
      * @param {number} options.light_cluster_lookup
      * @param {number} options.light_cluster_parameters
      * @param {number} options.shadowmap_atlas
-     * @param {import("../ShadeIndirectLightingMode.js").ShadeIndirectLightingMode} options.indirect_lighting_mode the renderer's; picks the froxel GI
-     *   module that starts the froxel irradiance volume
      * @param {ShaderSwitchSet} [options.shader_switches] the renderer's; the passes that light froxels are built
-     *   for them
+     *   for them, the froxel GI that starts the froxel irradiance volume among them
+     * @param {import("../global_illumination/brick4/Brick4LightMap.js").Brick4LightMap} [options.brick4] the scene's,
+     *   while Brick4 runs
+     * @param {import("../global_illumination/lpv/GPULightProbeVolume.js").GPULightProbeVolume} [options.lpv] the
+     *   scene's, while LPV runs
      * @returns {{resolved: number, metadata: number, irradiance: {Y: number, CoCg: number}}} the
      *   integrated aerial LUT, the metadata buffer, and the froxel irradiance volume
      *   (chunk_volumetrics_irradiance_sh) that lit particles are lit by. The two do not depend on
@@ -41,14 +43,15 @@ export class GPUViewVolumetrics {
      *   with no participating-media volume records no fog at all, and `resolved` is then a constant:
      *   no in-scatter, full transmittance.
      */
-    graph_update({ graph, light_cluster_data, light_cluster_lookup, light_cluster_parameters, shadowmap_atlas, indirect_lighting_mode, shader_switches, }: {
+    graph_update({ graph, light_cluster_data, light_cluster_lookup, light_cluster_parameters, shadowmap_atlas, shader_switches, brick4, lpv, }: {
         graph: FrameGraph;
         light_cluster_data: number;
         light_cluster_lookup: number;
         light_cluster_parameters: number;
         shadowmap_atlas: number;
-        indirect_lighting_mode: import("../ShadeIndirectLightingMode.js").ShadeIndirectLightingMode;
         shader_switches?: ShaderSwitchSet;
+        brick4?: import("../global_illumination/brick4/Brick4LightMap.js").Brick4LightMap;
+        lpv?: import("../global_illumination/lpv/GPULightProbeVolume.js").GPULightProbeVolume;
     }): {
         resolved: number;
         metadata: number;

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

@@ -1 +1 @@
-{"version":3,"file":"GPUViewVolumetrics.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/volumetrics/GPUViewVolumetrics.js"],"names":[],"mappings":"AAmCA;IA2II;;;;OAIG;IACH,kBAHW,cAAc,qBAyCxB;IAlJD;;OAEG;IACH,4BAOC;IAjBD;;OAEG;IACH,2BAEC;IAsCD;;OAEG;IACH,0BAEC;IAZD;;OAEG;IACH,yBAEC;IAkHD,gBAaC;IA6ND;;;;;;;;;;;;;;;;;;OAkBG;IACH;QAhB+B,KAAK,EAAzB,UAAU;QACM,kBAAkB,EAAlC,MAAM;QACU,oBAAoB,EAApC,MAAM;QACU,wBAAwB,EAAxC,MAAM;QACU,eAAe,EAA/B,MAAM;QACuE,sBAAsB,EAAnG,OAAO,iCAAiC,EAAE,yBAAyB;QAEzC,eAAe,GAAzC,eAAe;QAEb;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE;YAAC,CAAC,EAAE,MAAM,CAAC;YAAC,IAAI,EAAE,MAAM,CAAA;SAAC,CAAA;KAAC,CAsIvF;;CAEJ;yBA/jBY,OAAO,2DAA2D,EAAE,UAAU;6BAC9E,OAAO,2BAA2B,EAAE,cAAc;gCAf/B,uCAAuC"}
+{"version":3,"file":"GPUViewVolumetrics.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/volumetrics/GPUViewVolumetrics.js"],"names":[],"mappings":"AAmCA;IA2II;;;;OAIG;IACH,kBAHW,cAAc,qBAyCxB;IAlJD;;OAEG;IACH,4BAOC;IAjBD;;OAEG;IACH,2BAEC;IAsCD;;OAEG;IACH,0BAEC;IAZD;;OAEG;IACH,yBAEC;IAkHD,gBAaC;IA6ND;;;;;;;;;;;;;;;;;;;;OAoBG;IACH;QAlB+B,KAAK,EAAzB,UAAU;QACM,kBAAkB,EAAlC,MAAM;QACU,oBAAoB,EAApC,MAAM;QACU,wBAAwB,EAAxC,MAAM;QACU,eAAe,EAA/B,MAAM;QACoB,eAAe,GAAzC,eAAe;QAEoE,MAAM,GAAzF,OAAO,iDAAiD,EAAE,cAAc;QAEkB,GAAG,GAA7F,OAAO,mDAAmD,EAAE,mBAAmB;QAE7E;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE;YAAC,CAAC,EAAE,MAAM,CAAC;YAAC,IAAI,EAAE,MAAM,CAAA;SAAC,CAAA;KAAC,CAwIvF;;CAEJ;yBAnkBY,OAAO,2DAA2D,EAAE,UAAU;6BAC9E,OAAO,2BAA2B,EAAE,cAAc;gCAf/B,uCAAuC"}

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

@@ -459,10 +459,12 @@ export class GPUViewVolumetrics {
      * @param {number} options.light_cluster_lookup
      * @param {number} options.light_cluster_parameters
      * @param {number} options.shadowmap_atlas
-     * @param {import("../ShadeIndirectLightingMode.js").ShadeIndirectLightingMode} options.indirect_lighting_mode the renderer's; picks the froxel GI
-     *   module that starts the froxel irradiance volume
      * @param {ShaderSwitchSet} [options.shader_switches] the renderer's; the passes that light froxels are built
-     *   for them
+     *   for them, the froxel GI that starts the froxel irradiance volume among them
+     * @param {import("../global_illumination/brick4/Brick4LightMap.js").Brick4LightMap} [options.brick4] the scene's,
+     *   while Brick4 runs
+     * @param {import("../global_illumination/lpv/GPULightProbeVolume.js").GPULightProbeVolume} [options.lpv] the
+     *   scene's, while LPV runs
      * @returns {{resolved: number, metadata: number, irradiance: {Y: number, CoCg: number}}} the
      *   integrated aerial LUT, the metadata buffer, and the froxel irradiance volume
      *   (chunk_volumetrics_irradiance_sh) that lit particles are lit by. The two do not depend on
@@ -476,8 +478,9 @@ export class GPUViewVolumetrics {
                      light_cluster_lookup,
                      light_cluster_parameters,
                      shadowmap_atlas,
-                     indirect_lighting_mode,
                      shader_switches = ShaderSwitchSet.EMPTY,
+                     brick4,
+                     lpv,
                  }) {
 
         const view = this.#view;
@@ -528,8 +531,9 @@ export class GPUViewVolumetrics {
             shadowmap_atlas,
             volumetrics_metadata: gr_metadata,
             resolution,
-            indirect_lighting_mode,
             shader_switches,
+            brick4,
+            lpv,
         });
 
         if (view.scene.volumetrics.source.volumes.length === 0) {

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

@@ -1071,3 +1071,259 @@ Not done on the device: the froxel-versus-tracer parity check for a noisy volume
 one function and `chunk_participating_media_noise.spec.js` pins it on the emulator), and the
 giant-particle seam check with a noisy volume (the point is jittered on all three axes exactly as
 the lighting pass's is). Driver and probes: `probe/` in session 2fe0ac92's scratchpad, a one-off.
+
+## The flow map is linked only where the wind field has cascades — measured, 2026-10-16
+
+The noise's flow map (the GPU fluid's volumetrics, `e54461d36`) cost the froxel build 16.4 → 18.3 µs
+in uniform air, a scene with no fluid, where it never runs: a reach of exactly zero takes the one
+tap. The GPU fluid session's breakdown (RTX 4090, 1280×720, camera inside the fog) put it on the code
+being linked, not on running it: without the flow map and the wind sample the shader read 0.1–0.2 µs
+off the old one, and an exact-compare skip, dropping the two taps, or dropping the wind sample, each
+on its own, still cost about 1.8 µs.
+
+So the field's shape is a shader switch, `WIND_FIELD_UNIFORM` (a bool; `false`, the default, is the
+field as it is), decided in two places from one value: `chunk_wind_field_sample` (uniform: return
+`far_velocity`, which the cascaded read returns at every point of a field with no cascades) and
+`chunk_participating_media_noise` (uniform: the one tap at the scrolled lookup, the flow map's value
+at a zero departure). The froxel build picks its variant from the field it binds,
+`scene.wind.cascade_count === 0`, the frame it binds it; the other readers are left at the default.
+`ShaderSwitchSet.with` now remembers the sets it hands out, so deriving the build's set every frame
+allocates nothing (it built two arrays, a key and an assert message a call: 595 B).
+
+**On the device**, the three froxel builds interleaved by blocks of four frames in one capture: the
+pass as built (`new`, the variant it picked), the shader before the flow map (`old`, `ec5f0c093`), and
+master's (`head`, the flow map always linked). Means of ~175 frames an arm a round, µs, three rounds
+each:
+
+| scene | order | new | old | head |
+|---|---|---|---|---|
+| uniform air | new, old, head | 15.89 / 15.71 / 16.28 | 15.80 / 15.65 / 16.27 | 17.32 / 17.17 / 17.80 |
+| uniform air | head, old, new | 14.24 / 14.68 / 14.97 | 14.23 / 14.75 / 15.09 | 15.66 / 16.02 / 16.46 |
+| a domain, a wake, a vortex | head, old, new | 20.13 / 17.05 / 17.05 | 16.76 / 13.98 / 13.87 | 20.18 / 17.17 / 16.79 |
+
+Uniform air is the old cost to within 0.1 µs; disturbed air (the `new` arm on the full variant)
+is master's to within ±0.3 µs either way. TAA, which no arm touches, read alike in every row. The
+labels in the capture confirm which variant the pass picked in each scene.
+
+Every touched shader compiles through Tint on the device and builds a pipeline: both variants of the
+build, the water cull, the fluid query, the accumulating tracer, the Brick4 bake, the LPV trace, both
+lightmap viz bakes. Linked for the default, the seven readers of the wind alone (five particle
+passes, the water cull, the fluid query) are byte-identical to master's WGSL; the six readers of the
+noise differ only by the scroll-and-warp lookup now being one function both alternatives call.
+
+Specs: on the emulator, linked for a uniform field, the multiplier, the multiplier in a wind, the
+density and the wind read what the full variant reads in a field with no cascades, bit for bit (96
+random volumes, three far fields; red against a scrolled alternative that drops the warp and a
+uniform wind of zero). On the software device, the froxel build dispatches the uniform variant in a
+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/PARTICIPATING_MEDIA_VOLUME_STRUCT.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"PARTICIPATING_MEDIA_VOLUME_STRUCT.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/volumetrics/PARTICIPATING_MEDIA_VOLUME_STRUCT.js"],"names":[],"mappings":"AAWA,6DA2CE;6BArD2B,gCAAgC"}
+{"version":3,"file":"PARTICIPATING_MEDIA_VOLUME_STRUCT.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/volumetrics/PARTICIPATING_MEDIA_VOLUME_STRUCT.js"],"names":[],"mappings":"AAWA,6DAuDE;6BAjE2B,gCAAgC"}

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

@@ -23,6 +23,18 @@ export const PARTICIPATING_MEDIA_VOLUME_STRUCT = WebGPUStruct.from({
      * Numeric density of particles. In physics this would be `N`.
      */
     density: f32,
+    /**
+     * How much of the scene's wind the noise feels: the shader scales the published wind field's
+     * departure from its far field by it, as the host scales the far field it folds into
+     * `noise_offset`. 0 reads no wind. Placed here, with the flow phase, in the eight bytes the
+     * vec3 below would otherwise pad.
+     */
+    noise_wind_factor: f32,
+    /**
+     * The flow map's clock, `t / PARTICIPATING_MEDIA_NOISE_FLOW_PERIOD`, wrapped to [0, 1) on the
+     * host: the GPU has no clock of its own. See `chunk_participating_media_noise`.
+     */
+    noise_flow_phase: f32,
     /**
      * Noise: a tile of the volumetrics noise atlas, sampled in world space and multiplied into the
      * density. See `chunk_participating_media_noise`.

package/src/shade/renderer/volumetrics/ParticipatingMediaVolume.d.ts

@@ -1,17 +1,25 @@
 /**
- * Move a volume's noise along by a frame: the base tap's scroll by `velocity` metres a second over
+ * Move a volume's noise along by a frame: the base tap's field by `velocity` metres a second over
  * `dt`, and the warp tap's by the fraction of that its scale and its scroll ratio give it, each
- * wrapped back into [0, 1) in f64 — the fold the GPU is spared.
+ * phase wrapped back into [0, 1) in f64 — the fold the GPU is spared. The field is carried
+ * downwind: the shader looks up `position / scale + offset`, so the offset runs against the
+ * velocity, and what was at `p` is at `p + velocity · dt` after.
  *
- * The caller owns the clock and the velocity: `ParticipatingMediaSystem` folds the scene's wind
+ * A volume that feels the wind (`noise_wind_factor` not 0) also has its flow clock,
+ * `noise_flow_phase`, moved on by `dt / PARTICIPATING_MEDIA_NOISE_FLOW_PERIOD`, wrapped, whatever the
+ * velocity: the shader carries the noise along the wind field's departure from the far field with
+ * it, and the departure is the GPU's to know.
+ *
+ * The caller owns the clock and the velocity: `ParticipatingMediaSystem` folds the scene's far field
  * and the entity's own motion into one and calls this once a frame; a playground calls it from its
  * loop. Not called, the field stands still, which is what an accumulating reference wants.
  *
  * @param {ParticipatingMediaVolume} volume
  * @param {number[]|Float64Array} velocity metres a second, world axes
  * @param {number} dt seconds
- * @returns {boolean} whether anything moved — a zero velocity or a zero `dt` moves nothing, and a
- *   caller that tells the renderer about changes need not when nothing did
+ * @returns {boolean} whether anything moved — a zero `dt` moves nothing, nor does a zero velocity on
+ *   a volume out of the wind, and a caller that tells the renderer about changes need not when
+ *   nothing did
  */
 export function participating_media_volume_advance_noise(volume: ParticipatingMediaVolume, velocity: number[] | Float64Array, dt: number): boolean;
 export class VolumetricsParticleSpec {
@@ -108,6 +116,24 @@ export class ParticipatingMediaVolume {
      * @type {number[]}
      */
     noise_warp_offset: number[];
+    /**
+     * How much of the scene's wind the noise feels, 1 all of it and 0 none: a setting. The caller of
+     * {@link participating_media_volume_advance_noise} folds the far field by it into the scroll; the
+     * shaders scale the wind field's departure from the far field by it where they evaluate the
+     * noise, and a volume at 0 never samples the wind field.
+     *
+     * @type {number}
+     */
+    noise_wind_factor: number;
+    /**
+     * The flow map's clock, `t / PARTICIPATING_MEDIA_NOISE_FLOW_PERIOD`, kept in [0, 1). State, like
+     * {@link noise_offset}: advanced by {@link participating_media_volume_advance_noise} while the
+     * volume feels the wind, and read by the shader to carry the noise along the wind field's
+     * departure from the far field.
+     *
+     * @type {number}
+     */
+    noise_flow_phase: number;
     /**
      * Measured in particles per m3.
      * Default is value for very dense fog.

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

@@ -1 +1 @@
-{"version":3,"file":"ParticipatingMediaVolume.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/volumetrics/ParticipatingMediaVolume.js"],"names":[],"mappings":"AAiOA;;;;;;;;;;;;;;GAcG;AACH,iEANW,wBAAwB,YACxB,MAAM,EAAE,GAAC,YAAY,MACrB,MAAM,GACJ,OAAO,CAmCnB;AAvQD;IA6EI;;;;OAIG;IACH,+BAHW;QAAC,wBAAwB,EAAE,MAAM,EAAE,CAAC;QAAC,wBAAwB,EAAE,MAAM,EAAE,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAC,GAClG,uBAAuB,CAalC;IAED,oDAIC;IAlGD;;;OAGG;IACH,YAFU,MAAM,EAAE,CAEK;IAEvB;;;OAGG;IACH,YAFU,MAAM,EAAE,CAEK;IAEvB;;;OAGG;IACH,QAFU,MAAM,CAEL;IAEX,UAAQ;IAER,iCAIC;IAED;;;OAGG;IACH,YAFW,uBAAuB,QAOjC;IAED;;;;;aA0BC;IAED;;;OAGG;IACH,cAHW,uBAAuB,GACrB,OAAO,CAOnB;CAyBJ;AAED,6EAKI;AAIJ;IAII,iBAEC;IAED;;;;;;;;OAQG;IACH,gBAFU,MAAM,CAEG;IAEnB;;;;OAIG;IACH,aAFU,MAAM,CAEC;IAEjB;;;;OAIG;IACH,YAFU,MAAM,CAEC;IAEjB;;;OAGG;IACH,YAFU,MAAM,CAED;IAEf;;;;;;;;;OASG;IACH,cAFU,MAAM,EAAE,CAEO;IAEzB;;;;OAIG;IACH,mBAFU,MAAM,EAAE,CAEY;IAE9B;;;OAGG;IACH,gBAAc;IAEd;;;;;;;;;OASG;IACH,qCAEC;IAED,uCAA+E;IAE/E;;;;;;OAMG;IACH,eAFU,MAAM,CAEI;IAEpB;;;;;;;;;;;OAWG;IACH,WAFU,WAAW,CAES;;CAEjC;4BA5N2B,8CAA8C"}
+{"version":3,"file":"ParticipatingMediaVolume.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/volumetrics/ParticipatingMediaVolume.js"],"names":[],"mappings":"AAsPA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,iEAPW,wBAAwB,YACxB,MAAM,EAAE,GAAC,YAAY,MACrB,MAAM,GACJ,OAAO,CAgDnB;AA/SD;IA6EI;;;;OAIG;IACH,+BAHW;QAAC,wBAAwB,EAAE,MAAM,EAAE,CAAC;QAAC,wBAAwB,EAAE,MAAM,EAAE,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAC,GAClG,uBAAuB,CAalC;IAED,oDAIC;IAlGD;;;OAGG;IACH,YAFU,MAAM,EAAE,CAEK;IAEvB;;;OAGG;IACH,YAFU,MAAM,EAAE,CAEK;IAEvB;;;OAGG;IACH,QAFU,MAAM,CAEL;IAEX,UAAQ;IAER,iCAIC;IAED;;;OAGG;IACH,YAFW,uBAAuB,QAOjC;IAED;;;;;aA0BC;IAED;;;OAGG;IACH,cAHW,uBAAuB,GACrB,OAAO,CAOnB;CAyBJ;AAED,6EAKI;AAIJ;IAII,iBAEC;IAED;;;;;;;;OAQG;IACH,gBAFU,MAAM,CAEG;IAEnB;;;;OAIG;IACH,aAFU,MAAM,CAEC;IAEjB;;;;OAIG;IACH,YAFU,MAAM,CAEC;IAEjB;;;OAGG;IACH,YAFU,MAAM,CAED;IAEf;;;;;;;;;OASG;IACH,cAFU,MAAM,EAAE,CAEO;IAEzB;;;;OAIG;IACH,mBAFU,MAAM,EAAE,CAEY;IAE9B;;;;;;;OAOG;IACH,mBAFU,MAAM,CAEM;IAEtB;;;;;;;OAOG;IACH,kBAFU,MAAM,CAEK;IAErB;;;OAGG;IACH,gBAAc;IAEd;;;;;;;;;OASG;IACH,qCAEC;IAED,uCAA+E;IAE/E;;;;;;OAMG;IACH,eAFU,MAAM,CAEI;IAEpB;;;;;;;;;;;OAWG;IACH,WAFU,WAAW,CAES;;CAEjC;4BAjP2B,8CAA8C"}

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

@@ -3,6 +3,7 @@ import { isArrayEqualStrict } from "../../../core/collection/array/isArrayEqualS
 import { rgb_to_luminance } from "../../../core/color/rgb_to_luminance.js";
 import { Transform64 } from "../../../engine/ecs/transform/Transform64.js";
 import {
+    PARTICIPATING_MEDIA_NOISE_FLOW_PERIOD,
     PARTICIPATING_MEDIA_NOISE_WARP_SCALE,
     PARTICIPATING_MEDIA_NOISE_WARP_SCROLL
 } from "./noise/PARTICIPATING_MEDIA_NOISE.js";
@@ -176,6 +177,26 @@ export class ParticipatingMediaVolume {
      */
     noise_warp_offset = [0, 0, 0];
 
+    /**
+     * How much of the scene's wind the noise feels, 1 all of it and 0 none: a setting. The caller of
+     * {@link participating_media_volume_advance_noise} folds the far field by it into the scroll; the
+     * shaders scale the wind field's departure from the far field by it where they evaluate the
+     * noise, and a volume at 0 never samples the wind field.
+     *
+     * @type {number}
+     */
+    noise_wind_factor = 1;
+
+    /**
+     * The flow map's clock, `t / PARTICIPATING_MEDIA_NOISE_FLOW_PERIOD`, kept in [0, 1). State, like
+     * {@link noise_offset}: advanced by {@link participating_media_volume_advance_noise} while the
+     * volume feels the wind, and read by the shader to carry the noise along the wind field's
+     * departure from the far field.
+     *
+     * @type {number}
+     */
+    noise_flow_phase = 0;
+
     /**
      * Measured in particles per m3.
      * Default is value for very dense fog.
@@ -224,19 +245,27 @@ export class ParticipatingMediaVolume {
 }
 
 /**
- * Move a volume's noise along by a frame: the base tap's scroll by `velocity` metres a second over
+ * Move a volume's noise along by a frame: the base tap's field by `velocity` metres a second over
  * `dt`, and the warp tap's by the fraction of that its scale and its scroll ratio give it, each
- * wrapped back into [0, 1) in f64 — the fold the GPU is spared.
+ * phase wrapped back into [0, 1) in f64 — the fold the GPU is spared. The field is carried
+ * downwind: the shader looks up `position / scale + offset`, so the offset runs against the
+ * velocity, and what was at `p` is at `p + velocity · dt` after.
  *
- * The caller owns the clock and the velocity: `ParticipatingMediaSystem` folds the scene's wind
+ * A volume that feels the wind (`noise_wind_factor` not 0) also has its flow clock,
+ * `noise_flow_phase`, moved on by `dt / PARTICIPATING_MEDIA_NOISE_FLOW_PERIOD`, wrapped, whatever the
+ * velocity: the shader carries the noise along the wind field's departure from the far field with
+ * it, and the departure is the GPU's to know.
+ *
+ * The caller owns the clock and the velocity: `ParticipatingMediaSystem` folds the scene's far field
  * and the entity's own motion into one and calls this once a frame; a playground calls it from its
  * loop. Not called, the field stands still, which is what an accumulating reference wants.
  *
  * @param {ParticipatingMediaVolume} volume
  * @param {number[]|Float64Array} velocity metres a second, world axes
  * @param {number} dt seconds
- * @returns {boolean} whether anything moved — a zero velocity or a zero `dt` moves nothing, and a
- *   caller that tells the renderer about changes need not when nothing did
+ * @returns {boolean} whether anything moved — a zero `dt` moves nothing, nor does a zero velocity on
+ *   a volume out of the wind, and a caller that tells the renderer about changes need not when
+ *   nothing did
  */
 export function participating_media_volume_advance_noise(volume, velocity, dt) {
     assert.isInstanceOf(volume, ParticipatingMediaVolume, 'volume');
@@ -248,10 +277,21 @@ export function participating_media_volume_advance_noise(volume, velocity, dt) {
     const vy = velocity[1];
     const vz = velocity[2];
 
-    if (dt === 0 || (vx === 0 && vy === 0 && vz === 0)) {
+    if (dt === 0) {
         return false;
     }
 
+    let moved = false;
+
+    if (volume.noise_wind_factor !== 0) {
+        volume.noise_flow_phase = wrap_unit(volume.noise_flow_phase + dt / PARTICIPATING_MEDIA_NOISE_FLOW_PERIOD);
+        moved = true;
+    }
+
+    if (vx === 0 && vy === 0 && vz === 0) {
+        return moved;
+    }
+
     assert.greaterThan(volume.noise_scale, 0, 'noise_scale must be positive to scroll');
 
     // metres to tile units
@@ -261,13 +301,14 @@ export function participating_media_volume_advance_noise(volume, velocity, dt) {
     const offset = volume.noise_offset;
     const warp_offset = volume.noise_warp_offset;
 
-    offset[0] = wrap_unit(offset[0] + vx * step);
-    offset[1] = wrap_unit(offset[1] + vy * step);
-    offset[2] = wrap_unit(offset[2] + vz * step);
+    // the lookup is `position / scale + offset`, so the field moves along +v as the offset moves along -v
+    offset[0] = wrap_unit(offset[0] - vx * step);
+    offset[1] = wrap_unit(offset[1] - vy * step);
+    offset[2] = wrap_unit(offset[2] - vz * step);
 
-    warp_offset[0] = wrap_unit(warp_offset[0] + vx * warp_step);
-    warp_offset[1] = wrap_unit(warp_offset[1] + vy * warp_step);
-    warp_offset[2] = wrap_unit(warp_offset[2] + vz * warp_step);
+    warp_offset[0] = wrap_unit(warp_offset[0] - vx * warp_step);
+    warp_offset[1] = wrap_unit(warp_offset[1] - vy * warp_step);
+    warp_offset[2] = wrap_unit(warp_offset[2] - vz * warp_step);
 
     return true;
 }

package/src/shade/renderer/volumetrics/SceneVolumetrics.d.ts

@@ -4,14 +4,17 @@
 /**
  * Every participating medium in a scene, and a counter saying whether the GPU's copy is stale.
  *
- * **The version is the whole synchronisation protocol.** {@link GPUSceneVolumetrics} repacks the
- * entire table whenever the number moves and does nothing at all when it does not, so a volume
- * changed without moving the counter renders with the values it was last uploaded with — the CPU
+ * **Two versions are the whole synchronisation protocol.** {@link GPUSceneVolumetrics} repacks the
+ * entire table whenever {@link version} moves; while only {@link noise_version} moves it writes the
+ * noise phases of the rows whose phases changed; when neither moves it does nothing at all. A volume
+ * changed without moving a counter renders with the values it was last uploaded with — the CPU
  * object holds the new density, reads back correctly, and only the picture is stale. Anything that
- * writes into a volume in place therefore has to say so; see {@link invalidate}.
+ * writes into a volume in place therefore has to say so; see {@link invalidate} and
+ * {@link invalidate_noise}.
  *
  * **Volumes are packed by array index**, so removing one renumbers the rest. That is free here
- * because the upload is all-or-nothing, and it is the reason no volume carries a slot number.
+ * because adding or removing repacks the whole table, and it is the reason no volume carries a slot
+ * number.
  */
 export class SceneVolumetrics {
     /**
@@ -21,14 +24,17 @@ export class SceneVolumetrics {
     volumes: ParticipatingMediaVolume[];
     version: number;
     /**
-     * The wind every volume's noise scrolls with, metres a second along the world axes. Each
-     * volume feels it through its own `noise_wind_factor` and adds its own velocity; the fold is
-     * `ParticipatingMediaSystem`'s, once a frame, and the result is a scroll phase on the volume —
-     * this number itself never reaches the GPU.
+     * A second counter, for the one change that happens every frame: a volume's noise phases
+     * (`noise_offset`, `noise_warp_offset`) moved and nothing else about any volume did. While only
+     * this one moves, {@link GPUSceneVolumetrics} writes each row's phase words where they differ
+     * from what it last wrote, and nothing else of the table; see {@link invalidate_noise}.
      *
-     * @type {number[]}
+     * A move of {@link version} covers the phases too: the whole table is repacked from the volumes
+     * as they stand.
+     *
+     * @type {number}
      */
-    wind: number[];
+    noise_version: number;
     /**
      *
      * @param {ParticipatingMediaVolume} volume
@@ -48,6 +54,16 @@ export class SceneVolumetrics {
      * from here, and this is how such a change reaches the GPU.
      */
     invalidate(): void;
+    /**
+     * Say that volumes already in the scene had their noise phases advanced in place, and nothing
+     * else about them changed.
+     *
+     * The cheap path: a scrolling field moves its phases every frame, and they are six words of a
+     * row, so a frame that only scrolls writes those words per row instead of repacking the table
+     * (re-inverting every transform). Anything else written into a volume still owes an
+     * {@link invalidate}.
+     */
+    invalidate_noise(): void;
 }
 export type ParticipatingMediaVolume = import("./ParticipatingMediaVolume.js").ParticipatingMediaVolume;
 //# sourceMappingURL=SceneVolumetrics.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"SceneVolumetrics.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/volumetrics/SceneVolumetrics.js"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;;;;;;;;;;GAWG;AACH;IACI;;;OAGG;IACH,SAFU,wBAAwB,EAAE,CAEvB;IAEb,gBAAY;IAEZ;;;;;;;OAOG;IACH,MAFU,MAAM,EAAE,CAED;IAEjB;;;OAGG;IACH,YAFW,wBAAwB,QAQlC;IAED;;;;;OAKG;IACH,eAHW,wBAAwB,GACtB,OAAO,CAenB;IAED;;;;;OAKG;IACH,mBAEC;CACJ;uCA5EY,OAAO,+BAA+B,EAAE,wBAAwB"}
+{"version":3,"file":"SceneVolumetrics.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/volumetrics/SceneVolumetrics.js"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;;;;;;;;;;;;;GAcG;AACH;IACI;;;OAGG;IACH,SAFU,wBAAwB,EAAE,CAEvB;IAEb,gBAAY;IAEZ;;;;;;;;;;OAUG;IACH,eAFU,MAAM,CAEE;IAElB;;;OAGG;IACH,YAFW,wBAAwB,QAQlC;IAED;;;;;OAKG;IACH,eAHW,wBAAwB,GACtB,OAAO,CAenB;IAED;;;;;OAKG;IACH,mBAEC;IAED;;;;;;;;OAQG;IACH,yBAEC;CACJ;uCA/FY,OAAO,+BAA+B,EAAE,wBAAwB"}