@woosh/meep-engine 3.46.0 → 3.49.0

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

@@ -0,0 +1,24 @@
+import { f32, u32 } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
+
+/**
+ * What one bake of a noise tile is told: the tile's geometry, the row stride of the block it writes,
+ * and the field to bake.
+ *
+ * @see shader_volumetrics_noise_tile_bake
+ */
+export const VOLUMETRICS_NOISE_TILE_BAKE_SETTINGS_STRUCT = WebGPUStruct.from({
+    // texels along each axis of the whole tile, skirt included
+    tile_size: u32,
+    // texels of content along each axis
+    content_size: u32,
+    // texels of skirt on each side; the skirt is the content wrapped
+    border: u32,
+    // u32 words per row of the output block: the row stride, padded to the copy alignment
+    words_per_row: u32,
+    // base features along each edge of the content — the base octave's period in lattice units, an
+    // integer so the octave tiles exactly
+    features: f32,
+    // octaves summed, lacunarity 2, gain 0.5; at most VOLUMETRICS_NOISE_TILE_BAKE_OCTAVE_LIMIT
+    octaves: u32,
+}, "VolumetricsNoiseTileBakeSettings");

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

@@ -0,0 +1,27 @@
+/**
+ * Offer the pipeline {@link bake_volumetrics_noise_tile} dispatches — see {@link PipelineEnquiry}.
+ *
+ * @param {PipelineEnquiry} enquiry
+ */
+export function enquire_bake_volumetrics_noise_tile_pipelines(enquiry: PipelineEnquiry): void;
+/**
+ * Bake a noise tile on the device into a slot of an atlas: a compute dispatch into a transient
+ * block, then a copy of the block into the slot, both in the given command stream. Nothing is
+ * read back and nothing persists but the tile.
+ *
+ * @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 {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}
+ */
+export function bake_volumetrics_noise_tile({ command, atlas, slot, features, octaves }: {
+    command: import("../../../device/ShadeGPUCommandContext.js").ShadeGPUCommandContext;
+    atlas: import("../../texture/atlas/GPUTileAtlas3D.js").GPUTileAtlas3D;
+    slot: number;
+    features: number;
+    octaves: number;
+}): void;
+export type PipelineEnquiry = import("../../../device/pipeline/PipelineEnquiry.js").PipelineEnquiry;
+//# sourceMappingURL=bake_volumetrics_noise_tile.d.ts.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,91 @@
+import { assert } from "../../../../core/assert.js";
+import { COPY_BYTES_PER_ROW_ALIGNMENT } from "../../../device/COPY_BYTES_PER_ROW_ALIGNMENT.js";
+import {
+    shader_volumetrics_noise_tile_bake,
+    VOLUMETRICS_NOISE_TILE_BAKE_OCTAVE_LIMIT
+} from "./shader_volumetrics_noise_tile_bake.js";
+import { VOLUMETRICS_NOISE_TILE_BAKE_SETTINGS_STRUCT } from "./VOLUMETRICS_NOISE_TILE_BAKE_SETTINGS_STRUCT.js";
+
+/**
+ * @typedef {import("../../../device/pipeline/PipelineEnquiry.js").PipelineEnquiry} PipelineEnquiry
+ */
+
+/**
+ * psrdnoise's hash modulus, the longest period an octave can have before it repeats inside itself.
+ * @type {number}
+ */
+const PSRDNOISE_PERIOD_CEILING = 289;
+
+/**
+ * Offer the pipeline {@link bake_volumetrics_noise_tile} dispatches — see {@link PipelineEnquiry}.
+ *
+ * @param {PipelineEnquiry} enquiry
+ */
+export function enquire_bake_volumetrics_noise_tile_pipelines(enquiry) {
+    enquiry.compute.push(shader_volumetrics_noise_tile_bake.pipeline);
+}
+
+/**
+ * Bake a noise tile on the device into a slot of an atlas: a compute dispatch into a transient
+ * block, then a copy of the block into the slot, both in the given command stream. Nothing is
+ * read back and nothing persists but the tile.
+ *
+ * @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 {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}
+ */
+export function bake_volumetrics_noise_tile({ command, atlas, slot, features, octaves }) {
+    assert.defined(command, 'command');
+    assert.defined(atlas, 'atlas');
+    assert.equal(atlas.bytes_per_texel, 1, 'the bake packs one byte a texel');
+    assert.ok(atlas.is_live(slot), `slot ${slot} is not allocated`);
+    assert.isNonNegativeInteger(features, 'features');
+    assert.greaterThan(features, 0, 'features');
+    assert.isNonNegativeInteger(octaves, 'octaves');
+    assert.greaterThan(octaves, 0, 'octaves');
+    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 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;
+
+    const buffer = command.allocateTransientBuffer(
+        GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC,
+        bytes_per_row * tile_size * tile_size,
+    );
+
+    const settings = command.allocateTransientBuffer(
+        GPUBufferUsage.UNIFORM,
+        VOLUMETRICS_NOISE_TILE_BAKE_SETTINGS_STRUCT.aligned_size,
+    );
+
+    command.writeValueBuffer(settings, 0, VOLUMETRICS_NOISE_TILE_BAKE_SETTINGS_STRUCT, {
+        tile_size,
+        content_size: atlas.content_size,
+        border: atlas.border,
+        words_per_row,
+        features,
+        octaves,
+    });
+
+    // one thread a word, a word four texels along x
+    const words_across = Math.ceil(tile_size / 4);
+
+    shader_volumetrics_noise_tile_bake.dispatch({
+        encoder: command,
+        bindings: {
+            settings,
+            output: buffer,
+        },
+        group_count_x: Math.ceil(words_across / 8),
+        group_count_y: Math.ceil(tile_size / 8),
+        group_count_z: tile_size,
+    });
+
+    atlas.copy_from_buffer(command.gpu_encoder, slot, buffer, 0, bytes_per_row);
+}

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

@@ -0,0 +1,35 @@
+/**
+ * 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.
+ *
+ * **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
+ * volume carried by a moving entity has the world's fog flow through it. `noise_offset` is the
+ * 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
+ * (`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.
+ *
+ * **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.
+ *
+ * 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}
+ */
+export const chunk_participating_media_noise: CodeChunk;
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_participating_media_noise.d.ts.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,92 @@
+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;
+
+/**
+ * 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.
+ *
+ * **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
+ * volume carried by a moving entity has the world's fog flow through it. `noise_offset` is the
+ * 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
+ * (`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.
+ *
+ * **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.
+ *
+ * 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}
+ */
+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;
+    }
+
+    return mix(1.0, participating_media_noise_tap(volume.noise_slot, u), volume.noise_strength);
+}
+    `, [
+        PARTICIPATING_MEDIA_VOLUME_STRUCT.declaration_chunk,
+    ]
+);

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

@@ -0,0 +1,10 @@
+/**
+ * The most octaves one bake sums. A per-thread budget in the sense of the engine's loop rule: at
+ * 8 the finest octave of a 128³ tile is already below one texel a wavelength, so nothing past it
+ * can land in the texture.
+ * @type {number}
+ */
+export const VOLUMETRICS_NOISE_TILE_BAKE_OCTAVE_LIMIT: number;
+export const shader_volumetrics_noise_tile_bake: ComputeShader;
+import { ComputeShader } from "../../shader/ComputeShader.js";
+//# sourceMappingURL=shader_volumetrics_noise_tile_bake.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"shader_volumetrics_noise_tile_bake.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/volumetrics/noise/shader_volumetrics_noise_tile_bake.js"],"names":[],"mappings":"AAOA;;;;;GAKG;AACH,uDAFU,MAAM,CAE0C;AAuG1D,+DAIG;8BAtH2B,+BAA+B"}

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

@@ -0,0 +1,121 @@
+import { chunk_psrdnoise3 } from "../../shader/chunk/noise/psrdnoise/chunk_psrdnoise3.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { ComputeShader } from "../../shader/ComputeShader.js";
+import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
+import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
+import { VOLUMETRICS_NOISE_TILE_BAKE_SETTINGS_STRUCT } from "./VOLUMETRICS_NOISE_TILE_BAKE_SETTINGS_STRUCT.js";
+
+/**
+ * The most octaves one bake sums. A per-thread budget in the sense of the engine's loop rule: at
+ * 8 the finest octave of a 128³ tile is already below one texel a wavelength, so nothing past it
+ * can land in the texture.
+ * @type {number}
+ */
+export const VOLUMETRICS_NOISE_TILE_BAKE_OCTAVE_LIMIT = 8;
+
+const resources = new ShaderResourceSetDescriptor();
+
+resources.createGroup()
+    .addUniform("settings", VOLUMETRICS_NOISE_TILE_BAKE_SETTINGS_STRUCT)
+    .addStorageBuffer("output", WebGPUArray.u32, true);
+
+/**
+ * Bakes one noise tile — content and skirt — into a byte block, four texels a word.
+ *
+ * **The field.** Three octaves (by default) of `psrdnoise3`, lacunarity 2, gain 0.5, each octave
+ * at an integer period in lattice units across the content so that each one tiles exactly: the
+ * base at `features` periods per edge, the next at twice that, and so on. Every octave is
+ * offset by a constant times its index so the doubled lattices do not sit on the base one's
+ * corners. The sum is normalised by the amplitudes and remapped with `smoothstep(-0.6, 0.6)` —
+ * psrdnoise's fBm sits in about ±0.7 — into the [0, 1] multiplier the volumes apply to density. The
+ * remap is baked rather than applied at sample time so that a user tile is a multiplier too, with
+ * nothing more to say about it.
+ *
+ * **The skirt is the content wrapped**, computed here by wrapping the texel index rather than
+ * copied afterwards — the same rule `tile_atlas_bordered_block` applies on the host, so a tile
+ * baked here and one written there are the same shape.
+ *
+ * **The block.** Rows of `words_per_row` u32s, four `r8unorm` texels a word, `tile_size` rows an
+ * image, `tile_size` images: the layout `copyBufferToTexture` reads when the row stride is padded
+ * to the copy alignment. One thread writes one word; a lane past the tile's edge writes nothing
+ * into it, so the padding words stay zero.
+ *
+ * Runs once per tile at start-up (the engine's default) and never per frame. Deterministic: the
+ * same settings give the same bytes on every device the hash agrees on, which is what lets the
+ * emulator bake a small one in a spec.
+ *
+ * @see bake_volumetrics_noise_tile the driver
+ * @see chunk_participating_media_noise the reader
+ */
+const body = CodeChunk.from(
+    //language=WGSL
+    `
+const VOLUMETRICS_NOISE_TILE_BAKE_OCTAVE_LIMIT: u32 = ${VOLUMETRICS_NOISE_TILE_BAKE_OCTAVE_LIMIT}u;
+
+// keeps each octave's lattice off the corners of the one below it
+const VOLUMETRICS_NOISE_TILE_OCTAVE_OFFSET: vec3<f32> = vec3<f32>(17.0, 31.0, 47.0);
+
+// the multiplier a texel holds, from where it sits in the tile: the skirt reads the content wrapped
+fn volumetrics_noise_tile_texel(texel: vec3<u32>) -> f32 {
+    let n = settings.content_size;
+
+    // (texel - border) mod n, kept in u32: border <= n, so one extra period is enough
+    let c = (texel + vec3<u32>(n - settings.border)) % vec3<u32>(n);
+
+    // texel centres, across the content as [0, 1)
+    let p = (vec3<f32>(c) + 0.5) / f32(n);
+
+    let octaves = min(settings.octaves, VOLUMETRICS_NOISE_TILE_BAKE_OCTAVE_LIMIT);
+
+    var sum = 0.0;
+    var amplitude = 1.0;
+    var norm = 0.0;
+
+    for (var k = 0u; k < octaves; k++) {
+        // an integer period per octave, so each one tiles the content exactly
+        let period = settings.features * f32(1u << k);
+        let offset = VOLUMETRICS_NOISE_TILE_OCTAVE_OFFSET * f32(k);
+
+        sum += psrdnoise3(p * period + offset, vec3<f32>(period), 0.0).x * amplitude;
+        norm += amplitude;
+        amplitude *= 0.5;
+    }
+
+    return smoothstep(-0.6, 0.6, sum / norm);
+}
+
+@compute @workgroup_size(8, 8, 1)
+fn main(
+    @builtin(global_invocation_id) gid: vec3<u32>
+) {
+    let tile = settings.tile_size;
+    let x0 = gid.x * 4u;
+
+    if (x0 >= tile || gid.y >= tile || gid.z >= tile) {
+        return;
+    }
+
+    var word = 0u;
+
+    for (var lane = 0u; lane < 4u; lane++) {
+        let x = x0 + lane;
+
+        if (x < tile) {
+            let value = volumetrics_noise_tile_texel(vec3<u32>(x, gid.y, gid.z));
+
+            word |= u32(clamp(value, 0.0, 1.0) * 255.0 + 0.5) << (lane * 8u);
+        }
+    }
+
+    output[(gid.z * tile + gid.y) * settings.words_per_row + gid.x] = word;
+}
+    `, [
+        chunk_psrdnoise3,
+    ]
+);
+
+export const shader_volumetrics_noise_tile_bake = ComputeShader.from({
+    label: "Volumetrics / bake noise tile",
+    resources,
+    body,
+});

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

@@ -1 +1 @@
-{"version":3,"file":"shader_volumetrics_build_participating_media.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/volumetrics/shader_volumetrics_build_participating_media.js"],"names":[],"mappings":"AAqMA,yEAIE;8BApL4B,4BAA4B"}
+{"version":3,"file":"shader_volumetrics_build_participating_media.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/volumetrics/shader_volumetrics_build_participating_media.js"],"names":[],"mappings":"AAwOA,yEAIE;8BArN4B,4BAA4B"}

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

@@ -11,11 +11,13 @@ import {
 import { chunk_rgb_to_luminance } from "../shader/chunk/color/chunk_rgb_to_luminance.js";
 import { AABB3_STRUCT } from "../shader/chunk/geometry/aabb3/AABB3_STRUCT.js";
 import { chunk_aabb3_intersects_frustum } from "../shader/chunk/geometry/aabb3/chunk_aabb3_intersects_frustum.js";
+import { chunk_frustum_sample_point } from "../shader/chunk/geometry/frustum/chunk_frustum_sample_point.js";
 import { chunk_frustum_slice } from "../shader/chunk/geometry/frustum/chunk_frustum_slice.js";
 import {
     chunk_frustum_transform_plane_matrix
 } from "../shader/chunk/geometry/frustum/chunk_frustum_transform_plane_matrix.js";
 import { chunk_mat4_extract_scale } from "../shader/chunk/geometry/mat4/chunk_mat4_extract_scale.js";
+import { chunk_stbn_sample_vec3 } from "../shader/chunk/noise/chunk_stbn_sample_vec3.js";
 import { chunk_random } from "../shader/chunk/random/chunk_random.js";
 import { chunk_random_initialize } from "../shader/chunk/random/chunk_random_initialize.js";
 import { CodeChunk } from "../shader/compiler/CodeChunk.js";
@@ -27,6 +29,8 @@ import { chunk_compute_volume_fade_factor } from "./chunk_compute_volume_fade_fa
 import { chunk_frustum_unit_box_coverage_multisample } from "./chunk_frustum_unit_box_coverage_multisample.js";
 import { chunk_volumetrics_column_jitter } from "./chunk_volumetrics_column_jitter.js";
 import { chunk_participating_media_volumes_iterate } from "./chunk_participating_media_volumes_iterate.js";
+import { chunk_participating_media_noise } from "./noise/chunk_participating_media_noise.js";
+import { PARTICIPATING_MEDIA_NOISE_SAMPLER_DESCRIPTOR } from "./noise/PARTICIPATING_MEDIA_NOISE.js";
 import { VOLUMETRICS_METADATA_STRUCT } from "./VOLUMETRICS_METADATA_STRUCT.js";
 
 const resources = new ShaderResourceSetDescriptor();
@@ -36,6 +40,9 @@ resources.createGroup()
     .addUniform("view", VIEW_UNIFORM_STRUCT)
     .addUniform("volumetrics_metadata", VOLUMETRICS_METADATA_STRUCT)
     .addStorageBuffer("scene_database", WebGPUArray.u32)
+    .addTexture("tSTBN_vec3", "unfilterable-float", "3d")
+    .addTexture("tParticipatingMediaNoise", "float", "3d")
+    .addSampler("sParticipatingMediaNoise", "filtering", PARTICIPATING_MEDIA_NOISE_SAMPLER_DESCRIPTOR)
     .addStorageTexture("tOutput0", "rgba16float", "3d", "write-only")
     .addStorageTexture("tOutput1", "rgba16float", "3d", "write-only")
 
@@ -95,7 +102,22 @@ fn main(
         vec3(vec2f(voxel_coord.xy + 0u) / vec2f(resolution.xy), z0_norm),
         vec3(vec2f(voxel_coord.xy + 1u) / vec2f(resolution.xy), z1_norm),
     );
-        
+
+    // Where this froxel reads a volume's noise: one point inside the slab, moved every frame on all
+    // three axes so the volumetric TAA integrates the field over the froxel — a fixed point would
+    // put the texels on a lattice that a large particle reading them shows as seams. Spatiotemporal
+    // blue noise at a THIRD decorrelation offset: the aerial pass reads this volume at zero offset
+    // and the lighting pass at (37, 71), and two passes drawing the same number lock their nuisance
+    // variables together, which biases the estimate and no TAA window recovers it.
+    const NOISE_STBN_DECORRELATION_OFFSET = vec2<u32>(53u, 97u);
+
+    let noise_jitter = stbn_sample_vec3(vec3(
+        voxel_coord.xy + NOISE_STBN_DECORRELATION_OFFSET,
+        view.frame_index + voxel_coord.z
+    ));
+
+    let noise_position_ws = frustum_sample_point(froxel_frustum, noise_jitter);
+
     var scattering = vec3<f32>(0.0);
     var extinction = vec3<f32>(0.0);
     var particle_diameter = 0.0;
@@ -149,8 +171,18 @@ fn main(
             volume.fade_distance
         );
 
-        let weight = volume.density * volume_coverage * edge_fade_factor;
-        
+        // The noise is a property of the volume, so the branch is uniform across the dispatch: a
+        // uniform volume costs what it always did, and a noisy one pays its taps once per froxel it
+        // overlaps. The field is bounded by 1, so the slab average it scales stays bounded by the
+        // density, as the fade and the coverage leave it.
+        var noise = 1.0;
+
+        if (volume.noise_strength > 0.0) {
+            noise = participating_media_noise_multiplier(volume, noise_position_ws);
+        }
+
+        let weight = volume.density * volume_coverage * edge_fade_factor * noise;
+
         let volume_scattering = volume.particle_spec.scattering * weight;
         let volume_extinction = volume.particle_spec.extinction * weight;
         
@@ -192,6 +224,9 @@ fn main(
         chunk_mat4_extract_scale,
         chunk_volumetrics_column_jitter,
         chunk_participating_media_volumes_iterate,
+        chunk_frustum_sample_point,
+        chunk_stbn_sample_vec3,
+        chunk_participating_media_noise,
     ]
 )
 

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

@@ -1 +1 @@
-{"version":3,"file":"shader_volumetrics_build_sun_shadow_volume.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/volumetrics/shader_volumetrics_build_sun_shadow_volume.js"],"names":[],"mappings":"AAYA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH;;;;;;;;;;;;GAYG;AACH,oDAFU,YAAY,CAKkB;AAaxC;;;;;GAKG;AACH,mEAFU,aAAa,CA8FpB;AAcH;;;;;GAKG;AACH,gEAFU,aAAa,CAwGpB;6BA3R0B,gCAAgC;8BAH/B,4BAA4B"}
+{"version":3,"file":"shader_volumetrics_build_sun_shadow_volume.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/volumetrics/shader_volumetrics_build_sun_shadow_volume.js"],"names":[],"mappings":"AAYA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH;;;;;;;;;;;;GAYG;AACH,oDAFU,YAAY,CAKkB;AAaxC;;;;;GAKG;AACH,mEAFU,aAAa,CAiHpB;AAcH;;;;;GAKG;AACH,gEAFU,aAAa,CA0GpB;6BAhT0B,gCAAgC;8BAH/B,4BAA4B"}