@woosh/meep-engine 3.49.0 → 3.51.0

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,
+    ]
+);

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

@@ -0,0 +1,26 @@
+/**
+ * Lanes of a bin workgroup. Small on purpose: a lane tests one volume at a time, so at a handful of
+ * volumes most lanes of any group idle, and the fewer there are the less the bin launches for
+ * nothing.
+ * @type {number}
+ */
+export const VOLUMETRICS_MEDIA_BIN_LANES: number;
+/**
+ * Pre-culls the scene's participating-media volumes for each workgroup of the participating-media
+ * build: one workgroup per build group, which tests every volume of the near field (see
+ * {@link shader_volumetrics_split_participating_media}) against the group's slab of froxels and
+ * sets the bit of each one it keeps in that group's list (see {@link chunk_volumetrics_media_group_list}).
+ * The lists start zeroed; the graph clears them.
+ *
+ * The slab is the union of every froxel of the group as the build slices it, widened so that
+ * rounding can never make the group stricter than a froxel. In xy that is a quarter of a froxel
+ * past the group's columns and rows. In z it is the column jitter, which moves a froxel's slab by
+ * up to half a slice either way, and a quarter of a slice beyond that. A volume a froxel would
+ * cover therefore never misses its group's list, and the build reads, through the list, exactly
+ * what it read walking every volume.
+ *
+ * Budget: a lane tests ⌈near-field volumes / 64⌉ volumes. Nothing is past it.
+ */
+export const shader_volumetrics_bin_participating_media: ComputeShader;
+import { ComputeShader } from "../shader/ComputeShader.js";
+//# sourceMappingURL=shader_volumetrics_bin_participating_media.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"shader_volumetrics_bin_participating_media.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/volumetrics/shader_volumetrics_bin_participating_media.js"],"names":[],"mappings":"AAWA;;;;;GAKG;AACH,0CAFU,MAAM,CAE8B;AAY9C;;;;;;;;;;;;;;;GAeG;AACH,uEAgEG;8BA3G2B,4BAA4B"}