@woosh/meep-engine 3.49.0 → 3.50.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,50 @@ 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_*`.

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

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

@@ -5,14 +5,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 {
     /**
@@ -24,14 +27,17 @@ export class SceneVolumetrics {
     version = 0;
 
     /**
-     * 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 = [0, 0, 0];
+    noise_version = 0;
 
     /**
      *
@@ -75,4 +81,17 @@ export class SceneVolumetrics {
     invalidate() {
         this.version++;
     }
+
+    /**
+     * 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() {
+        this.noise_version++;
+    }
 }

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

@@ -0,0 +1,17 @@
+/**
+ * The froxel grid's parameters (`VOLUMETRICS_METADATA_STRUCT`).
+ * @type {ShaderResourceDescriptor}
+ */
+export const VOLUMETRICS_METADATA_RESOURCE: ShaderResourceDescriptor;
+/**
+ * The integrated froxel volume.
+ * @type {ShaderResourceDescriptor}
+ */
+export const VOLUMETRICS_RESOURCE: ShaderResourceDescriptor;
+/**
+ * The participating media's extinction, per froxel.
+ * @type {ShaderResourceDescriptor}
+ */
+export const PARTICIPATING_MEDIA_1_RESOURCE: ShaderResourceDescriptor;
+import { ShaderResourceDescriptor } from "../shader/resource/ShaderResourceDescriptor.js";
+//# sourceMappingURL=VOLUMETRICS_RESOURCES.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"VOLUMETRICS_RESOURCES.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/volumetrics/VOLUMETRICS_RESOURCES.js"],"names":[],"mappings":"AAGA;;;GAGG;AACH,4CAFU,wBAAwB,CAEiG;AAEnI;;;GAGG;AACH,mCAFU,wBAAwB,CAEkE;AAEpG;;;GAGG;AACH,6CAFU,wBAAwB,CAEoF;yCAnB7E,gDAAgD"}

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

@@ -0,0 +1,20 @@
+import { ShaderResourceDescriptor } from "../shader/resource/ShaderResourceDescriptor.js";
+import { VOLUMETRICS_METADATA_STRUCT } from "./VOLUMETRICS_METADATA_STRUCT.js";
+
+/**
+ * The froxel grid's parameters (`VOLUMETRICS_METADATA_STRUCT`).
+ * @type {ShaderResourceDescriptor}
+ */
+export const VOLUMETRICS_METADATA_RESOURCE = ShaderResourceDescriptor.uniform("volumetrics_metadata", VOLUMETRICS_METADATA_STRUCT);
+
+/**
+ * The integrated froxel volume.
+ * @type {ShaderResourceDescriptor}
+ */
+export const VOLUMETRICS_RESOURCE = ShaderResourceDescriptor.texture("tVolumetrics", "float", "3d");
+
+/**
+ * The participating media's extinction, per froxel.
+ * @type {ShaderResourceDescriptor}
+ */
+export const PARTICIPATING_MEDIA_1_RESOURCE = ShaderResourceDescriptor.texture("tParticipatingMedia1", "float", "3d");

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

@@ -161,7 +161,15 @@ of the volume, identical for every thread, so a uniform branch and not a variant
 
 **Global wind — `SceneVolumetrics.wind`, felt per medium.** Per Alex's F7: effective velocity
 `= wind × noise_wind_factor + noise_velocity`, two explicit fields on the component, folded by the
-system into the phase. The row carries phases only.
+system into the phase. The row carries phases only. *Superseded 2026-10-16 (GPU fluid S3,
+`GPU_FLUID_CASCADES_PROPOSAL_2026_10_16.md` §6): `SceneVolumetrics.wind` is removed, and a scroll
+writes each row's phase words through `SceneVolumetrics.invalidate_noise()` instead of repacking the
+table. The phases fold the scene's far field (`GPUFluidSystem.far_field`, still air without one);
+the fluid's departure from it is sampled on the GPU wherever the noise is evaluated and carries the
+noise as a flow map, on a flow clock the host folds into the row (`noise_flow_phase`, period 2.5 s),
+scaled by `noise_wind_factor`, which the row now carries too. A per-volume read-back of the wind was
+built first and withdrawn on Alex's word: the data is on the GPU. The scroll also changed sign: it
+had carried the noise upwind.*
 
 **Where the froxel pass evaluates it.** Once per froxel, before the volume loop, a world point
 inside the slab at an STBN jitter with a **third** decorrelation offset `(53, 97)` — the aerial pass
@@ -248,7 +256,7 @@ ECS, flat on `ParticipatingMedia`:
     noise_wind_factor = 1        // how much of the scene wind it feels
     noise_texture     = 0        // atlas slot; 0 = the engine's
 
-Scene: `SceneVolumetrics.wind` (m/s). Tiles: `GPUSceneVolumetrics.noise_atlas` —
+Scene: `SceneVolumetrics.wind` (m/s) — removed 2026-10-16, see above. Tiles: `GPUSceneVolumetrics.noise_atlas` —
 `allocate()`, `write(slot, Uint8Array(128³))`, `free(slot)`.
 
 Renderer-side `ParticipatingMediaVolume`: `noise_strength`, `noise_scale`, `noise_warp`,
@@ -259,7 +267,9 @@ anything moved.
 GPU row, appended to `PARTICIPATING_MEDIA_VOLUME_STRUCT`: `noise_offset: vec3f`,
 `noise_warp_offset: vec3f`, `noise_slot: u32`, `noise_strength: f32`, `noise_inverse_scale: f32`,
 `noise_warp: f32`. Packed by `GPUSceneVolumetrics` whenever the version moves — which, while any
-volume's phase moves, is every frame (tens of rows).
+volume's phase moves, is every frame (tens of rows). *Since 2026-10-16 a scroll moves
+`SceneVolumetrics.noise_version` instead, and only the moved rows' phase words go up: seven, with
+`noise_flow_phase`; `noise_wind_factor` and `noise_flow_phase` sit in the padding after `density`.*
 
 Serialization: `ParticipatingMediaSerializationAdapter` version 1 (eighteen doubles),
 `ParticipatingMediaSerializationUpgrader_0_1` fills a version-0 save with the defaults.

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

@@ -1 +1 @@
-{"version":3,"file":"chunk_integrate_optical_depth.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/volumetrics/chunk_integrate_optical_depth.js"],"names":[],"mappings":"AAKA,sDAsEC;0BAzEyB,iCAAiC"}
+{"version":3,"file":"chunk_integrate_optical_depth.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/volumetrics/chunk_integrate_optical_depth.js"],"names":[],"mappings":"AAOA,sDAsEC;0BA3EyB,iCAAiC"}