@woosh/meep-engine 3.49.0 → 3.50.0

package/src/shade/renderer/volumetrics/noise/PARTICIPATING_MEDIA_NOISE.d.ts

@@ -88,6 +88,41 @@ export const PARTICIPATING_MEDIA_NOISE_WARP_SCROLL: number;
  * @type {readonly number[]}
  */
 export const PARTICIPATING_MEDIA_NOISE_WARP_DIRECTION: readonly number[];
+/**
+ * The flow map's period, seconds: how long each of the two phases that carry the noise along the
+ * wind field's departure from its far field runs before it resets, half a period apart, each reset
+ * at zero weight. See `chunk_participating_media_noise`.
+ *
+ * **The pulse against the stretch, measured** (RTX 4090, 2026-10-16: the engine's tile read back off
+ * the device, and the GPU fluid read back over a fog volume while a wake circled through it at
+ * 10 m/s beside a vortex, at `GPUFluidComponent`'s defaults):
+ * - the pulse: how much of the field's change is the crossfade rather than the transport, the rms
+ *   of the one over the rms of the other for a uniform departure. It depends only on the reach
+ *   `λ = |d| · P / noise_scale`, tile units a period: about 1 (the noise rebuilds in place as fast as
+ *   it travels, and no travel reads) up to λ ≈ 0.08, 0.47 at 0.32, 0.15 at 1 — features have to move
+ *   about a quarter of a tile, the default tile's feature, before they are seen to move;
+ * - the stretch: the deformation a phase puts on the noise, `σ_max(I − φ · P · ∇d) − 1`, averaged
+ *   over the phases by their weights;
+ * - where the departure reads (|d| ≥ 1 m/s, 2,429 lattice points at 0.5 m), at the default
+ *   `noise_scale` of 32 m, the medians cross at 2.48 s: 1.05 against 0.34 at 1 s, 0.98 against 0.73
+ *   at 2 s, 0.88 against 1.15 at 3 s, 0.77 against 1.60 at 4 s. At a 16 m scale they cross at 2.06 s,
+ *   and over |d| ≥ 0.5 m/s at 2.4 to 2.9 s.
+ *
+ * So 2.5 s, the balance at the engine's default scale. It scales as `sqrt(feature · flow length) /
+ * speed`, so no one period is the balance everywhere.
+ * @type {number}
+ */
+export const PARTICIPATING_MEDIA_NOISE_FLOW_PERIOD: number;
+/**
+ * Below this reach, in tile units a flow period, the departure from the far field takes no flow map:
+ * one tap, the uniform-air path. Ignoring a reach moves the lookup by at most the reach, which moves
+ * the multiplier by at most the tile's steepest gradient times it; the engine's tile, read back off
+ * the device, rises at most 35.3 a tile unit (median 9.6), so at this reach the most the neglect
+ * changes the multiplier is half an `r8unorm` step, below what the tile itself resolves. The reach
+ * ramps in from here to twice here, so the branch is continuous.
+ * @type {number}
+ */
+export const PARTICIPATING_MEDIA_NOISE_FLOW_THRESHOLD: number;
 /**
  * How the atlas is sampled: trilinear, and clamped — the wrap is done by the skirt and by `fract`
  * on the tile coordinate, never by the sampler, which would wrap the whole atlas.

package/src/shade/renderer/volumetrics/noise/PARTICIPATING_MEDIA_NOISE.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"PARTICIPATING_MEDIA_NOISE.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/volumetrics/noise/PARTICIPATING_MEDIA_NOISE.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;GAeG;AAEH;;;GAGG;AACH,0DAFU,MAAM,CAE+C;AAE/D;;;GAGG;AACH,oDAFU,MAAM,CAEuC;AAEvD;;;GAGG;AACH,kDAFU,MAAM,CAE2H;AAE3I;;;GAGG;AACH,qEAA+D;AAE/D;;;GAGG;AACH,sDAFU,MAAM,CAEyC;AAEzD;;GAEG;AACH,sDAFU,MAAM,CAEyC;AAEzD;;;;GAIG;AACH,uDAFU,MAAM,CAE0C;AAE1D;;;;GAIG;AACH,qDAFU,MAAM,CAEwC;AAExD;;;;GAIG;AACH,yDAFU,MAAM,CAE4C;AAE5D;;;;;GAKG;AACH,wDAFU,MAAM,CAE2C;AAE3D;;;;GAIG;AACH,mDAFU,MAAM,CAEwC;AAExD;;;;;GAKG;AACH,oDAFU,MAAM,CAE0C;AAE1D;;;;;GAKG;AACH,uDAFU,SAAS,MAAM,EAAE,CAE+D;AAE1F;;;;GAIG;AACH,2DAFU,iBAAiB,CAKxB;kCAlH+B,kDAAkD"}
+{"version":3,"file":"PARTICIPATING_MEDIA_NOISE.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/volumetrics/noise/PARTICIPATING_MEDIA_NOISE.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;GAeG;AAEH;;;GAGG;AACH,0DAFU,MAAM,CAE+C;AAE/D;;;GAGG;AACH,oDAFU,MAAM,CAEuC;AAEvD;;;GAGG;AACH,kDAFU,MAAM,CAE2H;AAE3I;;;GAGG;AACH,qEAA+D;AAE/D;;;GAGG;AACH,sDAFU,MAAM,CAEyC;AAEzD;;GAEG;AACH,sDAFU,MAAM,CAEyC;AAEzD;;;;GAIG;AACH,uDAFU,MAAM,CAE0C;AAE1D;;;;GAIG;AACH,qDAFU,MAAM,CAEwC;AAExD;;;;GAIG;AACH,yDAFU,MAAM,CAE4C;AAE5D;;;;;GAKG;AACH,wDAFU,MAAM,CAE2C;AAE3D;;;;GAIG;AACH,mDAFU,MAAM,CAEwC;AAExD;;;;;GAKG;AACH,oDAFU,MAAM,CAE0C;AAE1D;;;;;GAKG;AACH,uDAFU,SAAS,MAAM,EAAE,CAE+D;AAE1F;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,oDAFU,MAAM,CAEyC;AAEzD;;;;;;;;GAQG;AACH,uDAFU,MAAM,CAE6D;AAE7E;;;;GAIG;AACH,2DAFU,iBAAiB,CAKxB;kCAvJ+B,kDAAkD"}

package/src/shade/renderer/volumetrics/noise/PARTICIPATING_MEDIA_NOISE.js

@@ -104,6 +104,43 @@ export const PARTICIPATING_MEDIA_NOISE_WARP_SCROLL = 0.37;
  */
 export const PARTICIPATING_MEDIA_NOISE_WARP_DIRECTION = Object.freeze([0.6, 0.48, -0.64]);
 
+/**
+ * The flow map's period, seconds: how long each of the two phases that carry the noise along the
+ * wind field's departure from its far field runs before it resets, half a period apart, each reset
+ * at zero weight. See `chunk_participating_media_noise`.
+ *
+ * **The pulse against the stretch, measured** (RTX 4090, 2026-10-16: the engine's tile read back off
+ * the device, and the GPU fluid read back over a fog volume while a wake circled through it at
+ * 10 m/s beside a vortex, at `GPUFluidComponent`'s defaults):
+ * - the pulse: how much of the field's change is the crossfade rather than the transport, the rms
+ *   of the one over the rms of the other for a uniform departure. It depends only on the reach
+ *   `λ = |d| · P / noise_scale`, tile units a period: about 1 (the noise rebuilds in place as fast as
+ *   it travels, and no travel reads) up to λ ≈ 0.08, 0.47 at 0.32, 0.15 at 1 — features have to move
+ *   about a quarter of a tile, the default tile's feature, before they are seen to move;
+ * - the stretch: the deformation a phase puts on the noise, `σ_max(I − φ · P · ∇d) − 1`, averaged
+ *   over the phases by their weights;
+ * - where the departure reads (|d| ≥ 1 m/s, 2,429 lattice points at 0.5 m), at the default
+ *   `noise_scale` of 32 m, the medians cross at 2.48 s: 1.05 against 0.34 at 1 s, 0.98 against 0.73
+ *   at 2 s, 0.88 against 1.15 at 3 s, 0.77 against 1.60 at 4 s. At a 16 m scale they cross at 2.06 s,
+ *   and over |d| ≥ 0.5 m/s at 2.4 to 2.9 s.
+ *
+ * So 2.5 s, the balance at the engine's default scale. It scales as `sqrt(feature · flow length) /
+ * speed`, so no one period is the balance everywhere.
+ * @type {number}
+ */
+export const PARTICIPATING_MEDIA_NOISE_FLOW_PERIOD = 2.5;
+
+/**
+ * Below this reach, in tile units a flow period, the departure from the far field takes no flow map:
+ * one tap, the uniform-air path. Ignoring a reach moves the lookup by at most the reach, which moves
+ * the multiplier by at most the tile's steepest gradient times it; the engine's tile, read back off
+ * the device, rises at most 35.3 a tile unit (median 9.6), so at this reach the most the neglect
+ * changes the multiplier is half an `r8unorm` step, below what the tile itself resolves. The reach
+ * ramps in from here to twice here, so the branch is continuous.
+ * @type {number}
+ */
+export const PARTICIPATING_MEDIA_NOISE_FLOW_THRESHOLD = 1 / (2 * 255 * 35.3);
+
 /**
  * How the atlas is sampled: trilinear, and clamped — the wrap is done by the skirt and by `fract`
  * on the tile coordinate, never by the sampler, which would wrap the whole atlas.

package/src/shade/renderer/volumetrics/noise/bake_volumetrics_noise_tile.d.ts

@@ -11,7 +11,8 @@ export function enquire_bake_volumetrics_noise_tile_pipelines(enquiry: PipelineE
  *
  * @param {object} options
  * @param {import("../../../device/ShadeGPUCommandContext.js").ShadeGPUCommandContext} options.command
- * @param {import("../../texture/atlas/GPUTileAtlas3D.js").GPUTileAtlas3D} options.atlas a one-byte-a-texel atlas
+ * @param {import("../../texture/atlas/GPUTileAtlas3D.js").GPUTileAtlas3D} options.atlas a one-byte-a-texel atlas of
+ * cubic tiles: the field has `features` periods along every edge
  * @param {number} options.slot a live slot of it
  * @param {number} options.features base features along each edge of the content, an integer
  * @param {number} options.octaves octaves to sum, 1 to {@link VOLUMETRICS_NOISE_TILE_BAKE_OCTAVE_LIMIT}

package/src/shade/renderer/volumetrics/noise/bake_volumetrics_noise_tile.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bake_volumetrics_noise_tile.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/volumetrics/noise/bake_volumetrics_noise_tile.js"],"names":[],"mappings":"AAkBA;;;;GAIG;AACH,uEAFW,eAAe,QAIzB;AAED;;;;;;;;;;;GAWG;AACH;IAN+F,OAAO,EAA3F,OAAO,2CAA2C,EAAE,sBAAsB;IACF,KAAK,EAA7E,OAAO,uCAAuC,EAAE,cAAc;IAC9C,IAAI,EAApB,MAAM;IACU,QAAQ,EAAxB,MAAM;IACU,OAAO,EAAvB,MAAM;SAqDhB;8BAjFY,OAAO,6CAA6C,EAAE,eAAe"}
+{"version":3,"file":"bake_volumetrics_noise_tile.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/volumetrics/noise/bake_volumetrics_noise_tile.js"],"names":[],"mappings":"AAkBA;;;;GAIG;AACH,uEAFW,eAAe,QAIzB;AAED;;;;;;;;;;;;GAYG;AACH;IAP+F,OAAO,EAA3F,OAAO,2CAA2C,EAAE,sBAAsB;IACF,KAAK,EAA7E,OAAO,uCAAuC,EAAE,cAAc;IAE9C,IAAI,EAApB,MAAM;IACU,QAAQ,EAAxB,MAAM;IACU,OAAO,EAAvB,MAAM;SAyDhB;8BAtFY,OAAO,6CAA6C,EAAE,eAAe"}

package/src/shade/renderer/volumetrics/noise/bake_volumetrics_noise_tile.js

@@ -32,7 +32,8 @@ export function enquire_bake_volumetrics_noise_tile_pipelines(enquiry) {
  *
  * @param {object} options
  * @param {import("../../../device/ShadeGPUCommandContext.js").ShadeGPUCommandContext} options.command
- * @param {import("../../texture/atlas/GPUTileAtlas3D.js").GPUTileAtlas3D} options.atlas a one-byte-a-texel atlas
+ * @param {import("../../texture/atlas/GPUTileAtlas3D.js").GPUTileAtlas3D} options.atlas a one-byte-a-texel atlas of
+ * cubic tiles: the field has `features` periods along every edge
  * @param {number} options.slot a live slot of it
  * @param {number} options.features base features along each edge of the content, an integer
  * @param {number} options.octaves octaves to sum, 1 to {@link VOLUMETRICS_NOISE_TILE_BAKE_OCTAVE_LIMIT}
@@ -49,7 +50,11 @@ export function bake_volumetrics_noise_tile({ command, atlas, slot, features, oc
     assert.lessThanOrEqual(octaves, VOLUMETRICS_NOISE_TILE_BAKE_OCTAVE_LIMIT, 'octaves');
     assert.lessThanOrEqual(features * 2 ** (octaves - 1), PSRDNOISE_PERIOD_CEILING, `the finest octave's period ${features * 2 ** (octaves - 1)} is past psrdnoise's ceiling of ${PSRDNOISE_PERIOD_CEILING}, where the field repeats inside the tile`);
 
-    const tile_size = atlas.tile_size;
+    const content_size = atlas.content_size;
+
+    assert.ok(content_size[0] === content_size[1] && content_size[1] === content_size[2], `the bake makes a cubic tile, the same periods along every edge; the atlas holds ${content_size[0]}×${content_size[1]}×${content_size[2]}`);
+
+    const tile_size = atlas.tile_size[0];
 
     const bytes_per_row = Math.ceil(tile_size / COPY_BYTES_PER_ROW_ALIGNMENT) * COPY_BYTES_PER_ROW_ALIGNMENT;
     const words_per_row = bytes_per_row / 4;
@@ -66,7 +71,7 @@ export function bake_volumetrics_noise_tile({ command, atlas, slot, features, oc
 
     command.writeValueBuffer(settings, 0, VOLUMETRICS_NOISE_TILE_BAKE_SETTINGS_STRUCT, {
         tile_size,
-        content_size: atlas.content_size,
+        content_size: content_size[0],
         border: atlas.border,
         words_per_row,
         features,

package/src/shade/renderer/volumetrics/noise/chunk_participating_media_noise.d.ts

@@ -2,7 +2,9 @@
  * A participating-media volume's noise multiplier at a world point: a [0, 1] factor on its density
  * from a tile of the noise atlas, which the importing shader binds as `tParticipatingMediaNoise`
  * (`texture_3d<f32>`) with `sParticipatingMediaNoise` (a filtering sampler, clamped) — the way
- * `scene_database` is a binding every reader of the volumes declares for itself.
+ * `scene_database` is a binding every reader of the volumes declares for itself — carried by the
+ * scene's wind, which it binds as `wind_field_add_resources` declares it (`wind_field`,
+ * `wind_field_atlas`, `wind_field_sampler`) and `GPUSceneWind.bind` fills.
  *
  * **One field, in world space.** The tile repeats every `1 / noise_inverse_scale` metres along
  * each world axis, so neighbouring volumes with the same settings share one continuous field and a
@@ -10,26 +12,56 @@
  * scroll, in tile units, already wrapped to [0, 1) by the host; `fract` folds the world position
  * onto the tile.
  *
- * **Two taps at most.** A warp tap reads the same tile at half frequency and its own scroll
+ * **Two taps for the shape.** A warp tap reads the same tile at half frequency and its own scroll
  * (`noise_warp_offset`), and displaces the base lookup along a fixed oblique direction by
  * `noise_warp` tile units times how far the warp value sits from its mean. As the two scrolls
  * slide against each other the base field changes shape in place, which is the evolution a static
- * texture otherwise lacks. `noise_warp == 0` is one tap; `noise_strength == 0` is none — callers
- * branch on it before calling, uniformly, since it is a property of the volume and not of the
- * thread.
+ * texture otherwise lacks. `noise_warp == 0` is no warp tap; `noise_strength == 0` is none at all —
+ * callers branch on it before calling, uniformly, since it is a property of the volume and not of
+ * the thread.
  *
- * **The slot's texels.** The atlas is tiles of `PARTICIPATING_MEDIA_NOISE_TILE_SIZE` texels — the
- * content and a one-texel skirt holding the content wrapped — in a grid the texture's own
- * dimensions describe, x fastest and z slowest. A tile coordinate in [0, 1) lands on the content;
- * the trilinear footprint at its edges reaches exactly one texel into the skirt, which is why the
- * skirt is there and why the sampler is clamped rather than repeating.
+ * **The wind: the far field on the host, the rest here, as a flow map.** The host folds the far
+ * field `v_far(t)` × `noise_wind_factor` (plus the volume's own motion) into `noise_offset`, exactly,
+ * as a running sum. Where the published wind `w(p)` departs from the far field, the departure
+ * `d = (w(p) − v_far(t)) · noise_wind_factor` carries the noise on top, flow-map style: there is no
+ * history at a point to integrate a phase in, and `t · d` would jump by `t · Δd` whenever the local
+ * wind changed. Two phases half a period apart, `φ₀ = fract(s)` and `φ₁ = fract(s + ½)` with
+ * `s = t / P` (`noise_flow_phase`, folded on the host), each move the base lookup by `−d · φₖ · P`
+ * (in tile units), and a triangle weight `1 − |2φ₀ − 1|` crossfades them, so each phase resets
+ * where its weight is zero. The warp tap is shared by both. Bounded by 1 still: a convex blend of
+ * taps of a [0, 1] tile.
+ *
+ * **Uniform air is one tap, the scroll alone.** Below a reach of
+ * `PARTICIPATING_MEDIA_NOISE_FLOW_THRESHOLD` tile units a period, the base takes one tap at the
+ * scrolled lookup, which is every point outside every cascade and every point whose air moves with
+ * the far field (`wind_field_sample` returns `v_far` exactly there). Above it the reach ramps in,
+ * from zero at the threshold to all of it at twice the threshold, so at the threshold both phases
+ * tap the one lookup and blend to it exactly: the branch is continuous.
+ *
+ * **By the field's shape** ({@link WIND_FIELD_UNIFORM}), the same functions either way:
+ * - as it is (`false`, the default): the flow map wherever the field departs from the far field
+ *   ({@link chunk_participating_media_noise_carried});
+ * - uniform (`true`), no cascades: the field departs from the far field nowhere, and the multiplier is
+ *   the one tap at the scrolled lookup and nothing else ({@link chunk_participating_media_noise_scrolled}),
+ *   which is what the flow map reads there, bit for bit. A pass whose field has no cascades links no
+ *   flow-map code: linked and never run, it cost the froxel build 1.3–1.9 µs a frame (RTX 4090,
+ *   1280×720, camera inside the fog), and the variant without it costs what the scroll alone did.
+ *
+ * The tap and the lookup both share are {@link chunk_participating_media_noise_tap}'s.
+ *
+ * **The entry points:**
+ * - `participating_media_noise_multiplier(volume, position)` samples the wind at `position` itself,
+ *   when the volume feels it;
+ * - `participating_media_noise_multiplier_in_wind(volume, position, wind)` takes the wind there
+ *   from the caller, for a pass that evaluates several volumes at one point and samples it once
+ *   (the froxel build). Pass `wind_field.far_velocity` for a volume that feels no wind.
  *
  * Bounded above by 1, which is what keeps `density` the path tracer's majorant.
  *
  * @see PARTICIPATING_MEDIA_NOISE the constants
  * @see shader_volumetrics_noise_tile_bake what the engine's default tile holds
- * @type {CodeChunk}
+ * @type {CodeChunkChoice}
  */
-export const chunk_participating_media_noise: CodeChunk;
-import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+export const chunk_participating_media_noise: CodeChunkChoice;
+import { CodeChunkChoice } from "../../shader/compiler/CodeChunkChoice.js";
 //# sourceMappingURL=chunk_participating_media_noise.d.ts.map

package/src/shade/renderer/volumetrics/noise/chunk_participating_media_noise.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_participating_media_noise.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/volumetrics/noise/chunk_participating_media_noise.js"],"names":[],"mappings":"AAYA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,8CAFU,SAAS,CAiDjB;0BA3FwB,oCAAoC"}
+{"version":3,"file":"chunk_participating_media_noise.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/volumetrics/noise/chunk_participating_media_noise.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+DG;AACH,8CAFU,eAAe,CAE+D;gCArExD,0CAA0C"}

package/src/shade/renderer/volumetrics/noise/chunk_participating_media_noise.js

@@ -1,20 +1,15 @@
-import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
-import { PARTICIPATING_MEDIA_VOLUME_STRUCT } from "../PARTICIPATING_MEDIA_VOLUME_STRUCT.js";
-import {
-    PARTICIPATING_MEDIA_NOISE_TILE_BORDER,
-    PARTICIPATING_MEDIA_NOISE_TILE_CONTENT_SIZE,
-    PARTICIPATING_MEDIA_NOISE_TILE_SIZE,
-    PARTICIPATING_MEDIA_NOISE_WARP_DIRECTION,
-    PARTICIPATING_MEDIA_NOISE_WARP_SCALE
-} from "./PARTICIPATING_MEDIA_NOISE.js";
-
-const [warp_x, warp_y, warp_z] = PARTICIPATING_MEDIA_NOISE_WARP_DIRECTION;
+import { CodeChunkChoice } from "../../shader/compiler/CodeChunkChoice.js";
+import { WIND_FIELD_UNIFORM } from "../../wind/WIND_FIELD_UNIFORM.js";
+import { chunk_participating_media_noise_carried } from "./chunk_participating_media_noise_carried.js";
+import { chunk_participating_media_noise_scrolled } from "./chunk_participating_media_noise_scrolled.js";
 
 /**
  * A participating-media volume's noise multiplier at a world point: a [0, 1] factor on its density
  * from a tile of the noise atlas, which the importing shader binds as `tParticipatingMediaNoise`
  * (`texture_3d<f32>`) with `sParticipatingMediaNoise` (a filtering sampler, clamped) — the way
- * `scene_database` is a binding every reader of the volumes declares for itself.
+ * `scene_database` is a binding every reader of the volumes declares for itself — carried by the
+ * scene's wind, which it binds as `wind_field_add_resources` declares it (`wind_field`,
+ * `wind_field_atlas`, `wind_field_sampler`) and `GPUSceneWind.bind` fills.
  *
  * **One field, in world space.** The tile repeats every `1 / noise_inverse_scale` metres along
  * each world axis, so neighbouring volumes with the same settings share one continuous field and a
@@ -22,71 +17,57 @@ const [warp_x, warp_y, warp_z] = PARTICIPATING_MEDIA_NOISE_WARP_DIRECTION;
  * scroll, in tile units, already wrapped to [0, 1) by the host; `fract` folds the world position
  * onto the tile.
  *
- * **Two taps at most.** A warp tap reads the same tile at half frequency and its own scroll
+ * **Two taps for the shape.** A warp tap reads the same tile at half frequency and its own scroll
  * (`noise_warp_offset`), and displaces the base lookup along a fixed oblique direction by
  * `noise_warp` tile units times how far the warp value sits from its mean. As the two scrolls
  * slide against each other the base field changes shape in place, which is the evolution a static
- * texture otherwise lacks. `noise_warp == 0` is one tap; `noise_strength == 0` is none — callers
- * branch on it before calling, uniformly, since it is a property of the volume and not of the
- * thread.
+ * texture otherwise lacks. `noise_warp == 0` is no warp tap; `noise_strength == 0` is none at all —
+ * callers branch on it before calling, uniformly, since it is a property of the volume and not of
+ * the thread.
+ *
+ * **The wind: the far field on the host, the rest here, as a flow map.** The host folds the far
+ * field `v_far(t)` × `noise_wind_factor` (plus the volume's own motion) into `noise_offset`, exactly,
+ * as a running sum. Where the published wind `w(p)` departs from the far field, the departure
+ * `d = (w(p) − v_far(t)) · noise_wind_factor` carries the noise on top, flow-map style: there is no
+ * history at a point to integrate a phase in, and `t · d` would jump by `t · Δd` whenever the local
+ * wind changed. Two phases half a period apart, `φ₀ = fract(s)` and `φ₁ = fract(s + ½)` with
+ * `s = t / P` (`noise_flow_phase`, folded on the host), each move the base lookup by `−d · φₖ · P`
+ * (in tile units), and a triangle weight `1 − |2φ₀ − 1|` crossfades them, so each phase resets
+ * where its weight is zero. The warp tap is shared by both. Bounded by 1 still: a convex blend of
+ * taps of a [0, 1] tile.
+ *
+ * **Uniform air is one tap, the scroll alone.** Below a reach of
+ * `PARTICIPATING_MEDIA_NOISE_FLOW_THRESHOLD` tile units a period, the base takes one tap at the
+ * scrolled lookup, which is every point outside every cascade and every point whose air moves with
+ * the far field (`wind_field_sample` returns `v_far` exactly there). Above it the reach ramps in,
+ * from zero at the threshold to all of it at twice the threshold, so at the threshold both phases
+ * tap the one lookup and blend to it exactly: the branch is continuous.
+ *
+ * **By the field's shape** ({@link WIND_FIELD_UNIFORM}), the same functions either way:
+ * - as it is (`false`, the default): the flow map wherever the field departs from the far field
+ *   ({@link chunk_participating_media_noise_carried});
+ * - uniform (`true`), no cascades: the field departs from the far field nowhere, and the multiplier is
+ *   the one tap at the scrolled lookup and nothing else ({@link chunk_participating_media_noise_scrolled}),
+ *   which is what the flow map reads there, bit for bit. A pass whose field has no cascades links no
+ *   flow-map code: linked and never run, it cost the froxel build 1.3–1.9 µs a frame (RTX 4090,
+ *   1280×720, camera inside the fog), and the variant without it costs what the scroll alone did.
  *
- * **The slot's texels.** The atlas is tiles of `PARTICIPATING_MEDIA_NOISE_TILE_SIZE` texels — the
- * content and a one-texel skirt holding the content wrapped — in a grid the texture's own
- * dimensions describe, x fastest and z slowest. A tile coordinate in [0, 1) lands on the content;
- * the trilinear footprint at its edges reaches exactly one texel into the skirt, which is why the
- * skirt is there and why the sampler is clamped rather than repeating.
+ * The tap and the lookup both share are {@link chunk_participating_media_noise_tap}'s.
+ *
+ * **The entry points:**
+ * - `participating_media_noise_multiplier(volume, position)` samples the wind at `position` itself,
+ *   when the volume feels it;
+ * - `participating_media_noise_multiplier_in_wind(volume, position, wind)` takes the wind there
+ *   from the caller, for a pass that evaluates several volumes at one point and samples it once
+ *   (the froxel build). Pass `wind_field.far_velocity` for a volume that feels no wind.
  *
  * Bounded above by 1, which is what keeps `density` the path tracer's majorant.
  *
  * @see PARTICIPATING_MEDIA_NOISE the constants
  * @see shader_volumetrics_noise_tile_bake what the engine's default tile holds
- * @type {CodeChunk}
+ * @type {CodeChunkChoice}
  */
-export const chunk_participating_media_noise = CodeChunk.from(
-    //language=WGSL
-    `
-const PARTICIPATING_MEDIA_NOISE_TILE_SIZE: u32 = ${PARTICIPATING_MEDIA_NOISE_TILE_SIZE}u;
-const PARTICIPATING_MEDIA_NOISE_TILE_CONTENT: f32 = ${PARTICIPATING_MEDIA_NOISE_TILE_CONTENT_SIZE}.0;
-const PARTICIPATING_MEDIA_NOISE_TILE_BORDER: f32 = ${PARTICIPATING_MEDIA_NOISE_TILE_BORDER}.0;
-const PARTICIPATING_MEDIA_NOISE_WARP_SCALE: f32 = ${PARTICIPATING_MEDIA_NOISE_WARP_SCALE};
-const PARTICIPATING_MEDIA_NOISE_WARP_DIRECTION: vec3<f32> = vec3<f32>(${warp_x}, ${warp_y}, ${warp_z});
-
-// one trilinear tap of a slot's tile at a tile coordinate, which may be anything: it is wrapped here
-fn participating_media_noise_tap(slot: u32, u: vec3<f32>) -> f32 {
-    let atlas = textureDimensions(tParticipatingMediaNoise);
-
-    let slots_x = atlas.x / PARTICIPATING_MEDIA_NOISE_TILE_SIZE;
-    let slots_y = atlas.y / PARTICIPATING_MEDIA_NOISE_TILE_SIZE;
-
-    let cell = vec3<u32>(
-        slot % slots_x,
-        (slot / slots_x) % slots_y,
-        slot / (slots_x * slots_y),
-    );
-
-    let origin = vec3<f32>(cell * PARTICIPATING_MEDIA_NOISE_TILE_SIZE);
-
-    // content texel c is centred at origin + border + c + 0.5, so a tile coordinate t in [0, 1) is
-    // the texel coordinate origin + border + t * content; no half-texel term
-    let texel = origin + PARTICIPATING_MEDIA_NOISE_TILE_BORDER + fract(u) * PARTICIPATING_MEDIA_NOISE_TILE_CONTENT;
-
-    return textureSampleLevel(tParticipatingMediaNoise, sParticipatingMediaNoise, texel / vec3<f32>(atlas), 0.0).r;
-}
-
-fn participating_media_noise_multiplier(volume: ${PARTICIPATING_MEDIA_VOLUME_STRUCT.wgsl_ref}, position: vec3<f32>) -> f32 {
-    let base = position * volume.noise_inverse_scale;
-
-    var u = base + volume.noise_offset;
-
-    if (volume.noise_warp > 0.0) {
-        let warp = participating_media_noise_tap(volume.noise_slot, base * PARTICIPATING_MEDIA_NOISE_WARP_SCALE + volume.noise_warp_offset);
-
-        u += (warp - 0.5) * volume.noise_warp * PARTICIPATING_MEDIA_NOISE_WARP_DIRECTION;
-    }
+export const chunk_participating_media_noise = CodeChunkChoice.from(WIND_FIELD_UNIFORM);
 
-    return mix(1.0, participating_media_noise_tap(volume.noise_slot, u), volume.noise_strength);
-}
-    `, [
-        PARTICIPATING_MEDIA_VOLUME_STRUCT.declaration_chunk,
-    ]
-);
+chunk_participating_media_noise.add(false, chunk_participating_media_noise_carried);
+chunk_participating_media_noise.add(true, chunk_participating_media_noise_scrolled);

package/src/shade/renderer/volumetrics/noise/chunk_participating_media_noise_carried.d.ts

@@ -0,0 +1,14 @@
+/**
+ * {@link chunk_participating_media_noise} in a wind field as it is ({@link WIND_FIELD_UNIFORM}
+ * `false`): the scroll, and on top of it the flow map of the field's departure from the far field,
+ * wherever the field departs. Samples the wind through `chunk_wind_field_sample`.
+ *
+ * Below a reach of {@link PARTICIPATING_MEDIA_NOISE_FLOW_THRESHOLD} tile units a period, the base is
+ * one tap at the scrolled lookup; above it the reach ramps in, from zero at the threshold to all of it
+ * at twice the threshold, so at the threshold both phases tap the one lookup and blend to it exactly.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_participating_media_noise_carried: CodeChunk;
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_participating_media_noise_carried.d.ts.map

package/src/shade/renderer/volumetrics/noise/chunk_participating_media_noise_carried.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_participating_media_noise_carried.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/volumetrics/noise/chunk_participating_media_noise_carried.js"],"names":[],"mappings":"AAOA;;;;;;;;;;GAUG;AACH,sDAFU,SAAS,CA2DjB;0BA3EwB,oCAAoC"}

package/src/shade/renderer/volumetrics/noise/chunk_participating_media_noise_carried.js

@@ -0,0 +1,76 @@
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { chunk_wind_field_sample } from "../../wind/chunk_wind_field_sample.js";
+import { WIND_FIELD_STRUCT } from "../../wind/WIND_FIELD_STRUCT.js";
+import { PARTICIPATING_MEDIA_VOLUME_STRUCT } from "../PARTICIPATING_MEDIA_VOLUME_STRUCT.js";
+import { chunk_participating_media_noise_tap } from "./chunk_participating_media_noise_tap.js";
+import { PARTICIPATING_MEDIA_NOISE_FLOW_PERIOD, PARTICIPATING_MEDIA_NOISE_FLOW_THRESHOLD } from "./PARTICIPATING_MEDIA_NOISE.js";
+
+/**
+ * {@link chunk_participating_media_noise} in a wind field as it is ({@link WIND_FIELD_UNIFORM}
+ * `false`): the scroll, and on top of it the flow map of the field's departure from the far field,
+ * wherever the field departs. Samples the wind through `chunk_wind_field_sample`.
+ *
+ * Below a reach of {@link PARTICIPATING_MEDIA_NOISE_FLOW_THRESHOLD} tile units a period, the base is
+ * one tap at the scrolled lookup; above it the reach ramps in, from zero at the threshold to all of it
+ * at twice the threshold, so at the threshold both phases tap the one lookup and blend to it exactly.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_participating_media_noise_carried = CodeChunk.from(
+    //language=WGSL
+    `
+const PARTICIPATING_MEDIA_NOISE_FLOW_PERIOD: f32 = ${PARTICIPATING_MEDIA_NOISE_FLOW_PERIOD};
+const PARTICIPATING_MEDIA_NOISE_FLOW_THRESHOLD: f32 = ${PARTICIPATING_MEDIA_NOISE_FLOW_THRESHOLD};
+
+fn participating_media_noise_multiplier_in_wind(
+    volume: ${PARTICIPATING_MEDIA_VOLUME_STRUCT.wgsl_ref},
+    position: vec3<f32>,
+    wind: vec3<f32>,
+) -> f32 {
+    let u = participating_media_noise_lookup(volume, position);
+
+    // the departure from the far field the host scrolled by, as tile units a flow period
+    let flow = (wind - wind_field.far_velocity) * (volume.noise_wind_factor * PARTICIPATING_MEDIA_NOISE_FLOW_PERIOD * volume.noise_inverse_scale);
+    let reach = length(flow);
+
+    var value: f32;
+
+    if (reach <= PARTICIPATING_MEDIA_NOISE_FLOW_THRESHOLD) {
+        value = participating_media_noise_tap(volume.noise_slot, u);
+    } else {
+        // 0 at the threshold, where both phases tap u and blend to it exactly, and 1 from twice it
+        let carried = flow * min(reach / PARTICIPATING_MEDIA_NOISE_FLOW_THRESHOLD - 1.0, 1.0);
+
+        let phase0 = fract(volume.noise_flow_phase);
+        let phase1 = fract(volume.noise_flow_phase + 0.5);
+
+        // phase 0's weight: zero where it resets, one half a period later, where phase 1 resets
+        let weight0 = 1.0 - abs(2.0 * phase0 - 1.0);
+
+        let tap0 = participating_media_noise_tap(volume.noise_slot, u - carried * phase0);
+        let tap1 = participating_media_noise_tap(volume.noise_slot, u - carried * phase1);
+
+        // mix's form, so that equal taps blend to themselves exactly
+        value = tap1 + (tap0 - tap1) * weight0;
+    }
+
+    return mix(1.0, value, volume.noise_strength);
+}
+
+fn participating_media_noise_multiplier(volume: ${PARTICIPATING_MEDIA_VOLUME_STRUCT.wgsl_ref}, position: vec3<f32>) -> f32 {
+    var wind = wind_field.far_velocity;
+
+    // a property of the volume, so every thread agrees
+    if (volume.noise_wind_factor != 0.0) {
+        wind = wind_field_sample(position);
+    }
+
+    return participating_media_noise_multiplier_in_wind(volume, position, wind);
+}
+    `, [
+        PARTICIPATING_MEDIA_VOLUME_STRUCT.declaration_chunk,
+        WIND_FIELD_STRUCT.declaration_chunk,
+        chunk_participating_media_noise_tap,
+        chunk_wind_field_sample,
+    ]
+);

package/src/shade/renderer/volumetrics/noise/chunk_participating_media_noise_scrolled.d.ts

@@ -0,0 +1,14 @@
+/**
+ * {@link chunk_participating_media_noise} in a uniform wind field ({@link WIND_FIELD_UNIFORM} `true`):
+ * the field has no cascades, so the wind is the far field everywhere and departs from it nowhere, and
+ * the noise is the host's scroll alone — one tap at the scrolled lookup, which is what the flow map
+ * takes at a departure of zero, exactly.
+ *
+ * The wind `participating_media_noise_multiplier_in_wind` is handed is the far field at the point,
+ * whoever sampled it, and is not read.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_participating_media_noise_scrolled: CodeChunk;
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_participating_media_noise_scrolled.d.ts.map

package/src/shade/renderer/volumetrics/noise/chunk_participating_media_noise_scrolled.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_participating_media_noise_scrolled.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/volumetrics/noise/chunk_participating_media_noise_scrolled.js"],"names":[],"mappings":"AAKA;;;;;;;;;;GAUG;AACH,uDAFU,SAAS,CAuBjB;0BArCwB,oCAAoC"}

package/src/shade/renderer/volumetrics/noise/chunk_participating_media_noise_scrolled.js

@@ -0,0 +1,38 @@
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { WIND_FIELD_STRUCT } from "../../wind/WIND_FIELD_STRUCT.js";
+import { PARTICIPATING_MEDIA_VOLUME_STRUCT } from "../PARTICIPATING_MEDIA_VOLUME_STRUCT.js";
+import { chunk_participating_media_noise_tap } from "./chunk_participating_media_noise_tap.js";
+
+/**
+ * {@link chunk_participating_media_noise} in a uniform wind field ({@link WIND_FIELD_UNIFORM} `true`):
+ * the field has no cascades, so the wind is the far field everywhere and departs from it nowhere, and
+ * the noise is the host's scroll alone — one tap at the scrolled lookup, which is what the flow map
+ * takes at a departure of zero, exactly.
+ *
+ * The wind `participating_media_noise_multiplier_in_wind` is handed is the far field at the point,
+ * whoever sampled it, and is not read.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_participating_media_noise_scrolled = CodeChunk.from(
+    //language=WGSL
+    `
+fn participating_media_noise_multiplier_in_wind(
+    volume: ${PARTICIPATING_MEDIA_VOLUME_STRUCT.wgsl_ref},
+    position: vec3<f32>,
+    wind: vec3<f32>,
+) -> f32 {
+    let value = participating_media_noise_tap(volume.noise_slot, participating_media_noise_lookup(volume, position));
+
+    return mix(1.0, value, volume.noise_strength);
+}
+
+fn participating_media_noise_multiplier(volume: ${PARTICIPATING_MEDIA_VOLUME_STRUCT.wgsl_ref}, position: vec3<f32>) -> f32 {
+    return participating_media_noise_multiplier_in_wind(volume, position, wind_field.far_velocity);
+}
+    `, [
+        PARTICIPATING_MEDIA_VOLUME_STRUCT.declaration_chunk,
+        WIND_FIELD_STRUCT.declaration_chunk,
+        chunk_participating_media_noise_tap,
+    ]
+);

package/src/shade/renderer/volumetrics/noise/chunk_participating_media_noise_tap.d.ts

@@ -0,0 +1,21 @@
+/**
+ * What both of {@link chunk_participating_media_noise}'s alternatives read the tile through:
+ * - `participating_media_noise_tap(slot, u)`: one trilinear tap of a slot's tile at a tile
+ *   coordinate, wrapped;
+ * - `participating_media_noise_lookup(volume, position)`: where a volume's base tap lands for a world
+ *   point before the wind's departure carries it, the scroll and the warp applied, in tile units.
+ *
+ * Reads `tParticipatingMediaNoise` with `sParticipatingMediaNoise`, as the importing shader binds them.
+ *
+ * **The slot's texels.** The atlas is tiles of `PARTICIPATING_MEDIA_NOISE_TILE_SIZE` texels — the
+ * content and a one-texel skirt holding the content wrapped — in a grid the texture's own
+ * dimensions describe, x fastest and z slowest, placed by `tile_atlas_slot_origin` as the atlas
+ * places it. A tile coordinate in [0, 1) lands on the content; the trilinear footprint at its edges
+ * reaches exactly one texel into the skirt, which is why the skirt is there and why the sampler is
+ * clamped rather than repeating.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_participating_media_noise_tap: CodeChunk;
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_participating_media_noise_tap.d.ts.map

package/src/shade/renderer/volumetrics/noise/chunk_participating_media_noise_tap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_participating_media_noise_tap.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/volumetrics/noise/chunk_participating_media_noise_tap.js"],"names":[],"mappings":"AAaA;;;;;;;;;;;;;;;;;GAiBG;AACH,kDAFU,SAAS,CA4CjB;0BAzEwB,oCAAoC"}

package/src/shade/renderer/volumetrics/noise/chunk_participating_media_noise_tap.js

@@ -0,0 +1,74 @@
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { chunk_tile_atlas_slot_origin } from "../../texture/atlas/chunk_tile_atlas_slot_origin.js";
+import { PARTICIPATING_MEDIA_VOLUME_STRUCT } from "../PARTICIPATING_MEDIA_VOLUME_STRUCT.js";
+import {
+    PARTICIPATING_MEDIA_NOISE_TILE_BORDER,
+    PARTICIPATING_MEDIA_NOISE_TILE_CONTENT_SIZE,
+    PARTICIPATING_MEDIA_NOISE_TILE_SIZE,
+    PARTICIPATING_MEDIA_NOISE_WARP_DIRECTION,
+    PARTICIPATING_MEDIA_NOISE_WARP_SCALE
+} from "./PARTICIPATING_MEDIA_NOISE.js";
+
+const [warp_x, warp_y, warp_z] = PARTICIPATING_MEDIA_NOISE_WARP_DIRECTION;
+
+/**
+ * What both of {@link chunk_participating_media_noise}'s alternatives read the tile through:
+ * - `participating_media_noise_tap(slot, u)`: one trilinear tap of a slot's tile at a tile
+ *   coordinate, wrapped;
+ * - `participating_media_noise_lookup(volume, position)`: where a volume's base tap lands for a world
+ *   point before the wind's departure carries it, the scroll and the warp applied, in tile units.
+ *
+ * Reads `tParticipatingMediaNoise` with `sParticipatingMediaNoise`, as the importing shader binds them.
+ *
+ * **The slot's texels.** The atlas is tiles of `PARTICIPATING_MEDIA_NOISE_TILE_SIZE` texels — the
+ * content and a one-texel skirt holding the content wrapped — in a grid the texture's own
+ * dimensions describe, x fastest and z slowest, placed by `tile_atlas_slot_origin` as the atlas
+ * places it. A tile coordinate in [0, 1) lands on the content; the trilinear footprint at its edges
+ * reaches exactly one texel into the skirt, which is why the skirt is there and why the sampler is
+ * clamped rather than repeating.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_participating_media_noise_tap = CodeChunk.from(
+    //language=WGSL
+    `
+const PARTICIPATING_MEDIA_NOISE_TILE_SIZE: u32 = ${PARTICIPATING_MEDIA_NOISE_TILE_SIZE}u;
+const PARTICIPATING_MEDIA_NOISE_TILE_CONTENT: f32 = ${PARTICIPATING_MEDIA_NOISE_TILE_CONTENT_SIZE}.0;
+const PARTICIPATING_MEDIA_NOISE_TILE_BORDER: f32 = ${PARTICIPATING_MEDIA_NOISE_TILE_BORDER}.0;
+const PARTICIPATING_MEDIA_NOISE_WARP_SCALE: f32 = ${PARTICIPATING_MEDIA_NOISE_WARP_SCALE};
+const PARTICIPATING_MEDIA_NOISE_WARP_DIRECTION: vec3<f32> = vec3<f32>(${warp_x}, ${warp_y}, ${warp_z});
+
+// one trilinear tap of a slot's tile at a tile coordinate, which may be anything: it is wrapped here
+fn participating_media_noise_tap(slot: u32, u: vec3<f32>) -> f32 {
+    let atlas = textureDimensions(tParticipatingMediaNoise);
+    let tile = vec3<u32>(PARTICIPATING_MEDIA_NOISE_TILE_SIZE);
+
+    // the footprint the bound texture was built with, read off the texture itself
+    let origin = vec3<f32>(tile_atlas_slot_origin(slot, atlas.xy / tile.xy, tile));
+
+    // content texel c is centred at origin + border + c + 0.5, so a tile coordinate t in [0, 1) is
+    // the texel coordinate origin + border + t * content; no half-texel term
+    let texel = origin + PARTICIPATING_MEDIA_NOISE_TILE_BORDER + fract(u) * PARTICIPATING_MEDIA_NOISE_TILE_CONTENT;
+
+    return textureSampleLevel(tParticipatingMediaNoise, sParticipatingMediaNoise, texel / vec3<f32>(atlas), 0.0).r;
+}
+
+// the base tap's tile coordinate for a world point: scrolled, and displaced by the warp tap
+fn participating_media_noise_lookup(volume: ${PARTICIPATING_MEDIA_VOLUME_STRUCT.wgsl_ref}, position: vec3<f32>) -> vec3<f32> {
+    let base = position * volume.noise_inverse_scale;
+
+    var u = base + volume.noise_offset;
+
+    if (volume.noise_warp > 0.0) {
+        let warp = participating_media_noise_tap(volume.noise_slot, base * PARTICIPATING_MEDIA_NOISE_WARP_SCALE + volume.noise_warp_offset);
+
+        u += (warp - 0.5) * volume.noise_warp * PARTICIPATING_MEDIA_NOISE_WARP_DIRECTION;
+    }
+
+    return u;
+}
+    `, [
+        PARTICIPATING_MEDIA_VOLUME_STRUCT.declaration_chunk,
+        chunk_tile_atlas_slot_origin,
+    ]
+);