@woosh/meep-engine 3.11.1 → 3.11.2

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

@@ -1,316 +1,481 @@
-import { GPUTypedBuffer } from "../buffer/GPUTypedBuffer.js";
-import { graph_compute_pass } from "../shader/graph/compute/graph_compute_pass.js";
-import { graph_import_buffer } from "../shader/graph/graph_import_buffer.js";
-import { graph_import_texture } from "../shader/graph/graph_import_texture.js";
-import { GPUTextureContext } from "../texture/GPUTextureContext.js";
-import { update_frustum_far_plane } from "../shadow/map/update_frustum_far_plane.js";
-import { slice_flat_array } from "../util/slice_flat_array.js";
-import { build_light_cluster_parameters } from "../light/cluster/build_light_cluster_parameters.js";
-import { graph_build_volumetrics } from "./graph_build_volumetrics.js";
-import { shader_volumetrics_taa } from "./taa/shader_volumetrics_taa.js";
-import { VOLUMETRICS_METADATA_STRUCT } from "./VOLUMETRICS_METADATA_STRUCT.js";
-import { VOLUMETRICS_RESOLUTION_Z } from "./VOLUMETRICS_RESOLUTION_Z.js";
-
-/**
- * resolution of a single froxel in XY, in pixels
- */
-const TILE_SIZE = 8;
-
-export class GPUViewVolumetrics {
-
-    /**
-     * @type {GPUViewContext}
-     */
-    #view
-
-    /**
-     * NOTE: Initialized in the constructor
-     * @type {GPUTextureContext[]}
-     */
-    #volumetrics_textures = [];
-
-    /**
-     * Should we perform temporal integration, or not?
-     * If set to true - the next update will discard history.
-     * Useful for significant scene transitions and screen resizing.
-     * @type {boolean}
-     */
-    #reset_history = true;
-
-    /**
-     * Whether to run the 3D temporal reprojection (volumetric TAA) over the per-froxel scattering
-     * volume. When disabled, the aerial pass integrates the raw (noisier) scattering LUT directly —
-     * a safe fallback if temporal artifacts appear.
-     * @type {boolean}
-     */
-    #taa_enabled = true;
-
-    /**
-     * @returns {boolean}
-     */
-    get taa_enabled() {
-        return this.#taa_enabled;
-    }
-
-    /**
-     * @param {boolean} v
-     */
-    set taa_enabled(v) {
-        if (v === this.#taa_enabled) {
-            return;
-        }
-        this.#taa_enabled = v;
-        // re-enabling must not blend against a stale / never-written history texture
-        this.#reset_history = true;
-    }
-
-    /**
-     * View-space distance at which the froxel grid ends and the aerial pass switches to a direct
-     * RDR2-style volume ray-march. Clamped to camera.far at upload, so the default (Infinity) means
-     * "grid covers the whole range" and the far march is a no-op.
-     * @type {number}
-     */
-    #froxel_far = Infinity;
-
-    /**
-     * @returns {number}
-     */
-    get froxel_far() {
-        return this.#froxel_far;
-    }
-
-    /**
-     * @param {number} v
-     */
-    set froxel_far(v) {
-        this.#froxel_far = v;
-    }
-
-    /**
-     * @type {GPUTypedBuffer}
-     */
-    #metadata;
-
-    /**
-     * @type {GPUDevice}
-     */
-    #device
-
-    /**
-     *
-     * @param {GPUViewContext} view
-     * @param {GPUDevice} device
-     */
-    constructor(view, device) {
-        this.#device = device;
-        this.#view = view;
-
-        // initialize textures
-        for (let i = 0; i < 2; i++) {
-            const texture = new GPUTextureContext(device);
-
-            texture.descriptor.format = "rgba16float";
-            texture.descriptor.dimension = "3d";
-            texture.descriptor.usage = GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING;
-
-            this.#volumetrics_textures[i] = texture;
-        }
-
-        this.#metadata = GPUTypedBuffer.create({
-            type: VOLUMETRICS_METADATA_STRUCT,
-            device,
-            usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST,
-        });
-
-    }
-
-    destroy() {
-
-        const textures = this.#volumetrics_textures;
-
-        for (let i = 0; i < 2; i++) {
-
-            textures[i].destroy();
-
-            textures[i] = null;
-        }
-
-    }
-
-    #update_resolution() {
-
-
-        const screen_resolution = this.#view.resolution;
-
-        const output_resolution_x = Math.ceil(screen_resolution[0] / TILE_SIZE);
-        const output_resolution_y = Math.ceil(screen_resolution[1] / TILE_SIZE);
-
-        const t_first = this.#volumetrics_textures[0];
-
-        if (t_first.width === output_resolution_x
-            && t_first.height === output_resolution_y
-        ) {
-            // already at the right resolution
-            return;
-        }
-
-        for (let i = 0; i < 2; i++) {
-
-            this.#volumetrics_textures[i].resize(
-                output_resolution_x,
-                output_resolution_y,
-                VOLUMETRICS_RESOLUTION_Z
-            );
-
-        }
-
-        // drop history
-        this.#reset_history = true;
-    }
-
-    #update_metadata() {
-        const view = this.#view;
-        const camera = view.camera;
-
-        const resolution = this.#volumetrics_textures[0].size;
-
-        const volumetrics_cluster_parameters = new Float32Array(3);
-
-        // The depth-curve `scale` must grow with the slice count. The hard-coded 4.06 was tuned for
-        // the light-cluster grid (24 slices); reusing it with 64 froxel slices collapses the log
-        // curve so ~half the slices bunch into the first fraction of a unit of depth, leaving almost
-        // none for the actual scene. Derive scale for a log-uniform distribution over
-        // [near + near_offset, far] instead (gives O ~= 0, i.e. depth ~ offset * (far/offset)^(s/(N-1))).
-        const NEAR_OFFSET = 0.1;
-        const depth_offset = camera.camera.near + NEAR_OFFSET;
-        const depth_scale = (VOLUMETRICS_RESOLUTION_Z - 1) / Math.log2(camera.camera.far / depth_offset);
-
-        build_light_cluster_parameters(
-            volumetrics_cluster_parameters,
-            0,
-            VOLUMETRICS_RESOLUTION_Z,
-            camera.camera.near,
-            camera.camera.far,
-            NEAR_OFFSET,
-            depth_scale
-        );
-
-        // Froxel-grid curve: same construction but ending at froxel_far (<= camera.far). The grid's
-        // slices pack into [near, froxel_far] for extra near detail; beyond froxel_far the aerial
-        // pass ray-marches the volumes. froxel_far == camera.far -> identical to the LUT curve (no-op).
-        const froxel_far = Math.min(this.#froxel_far, camera.camera.far);
-        const froxel_depth_scale = (VOLUMETRICS_RESOLUTION_Z - 1) / Math.log2(froxel_far / depth_offset);
-        const volumetrics_froxel_cluster_parameters = new Float32Array(3);
-        build_light_cluster_parameters(
-            volumetrics_froxel_cluster_parameters,
-            0,
-            VOLUMETRICS_RESOLUTION_Z,
-            camera.camera.near,
-            froxel_far,
-            NEAR_OFFSET,
-            froxel_depth_scale
-        );
-
-        // The projection is infinite-far reverse-Z, so the camera frustum's far plane is zeroed and
-        // can't be sliced into froxel slabs. Rebuild a finite far plane at the logical far for the
-        // participating-media coverage test — exactly as the light-cluster assignment does.
-        const clipped_frustum = new Float32Array(24);
-        clipped_frustum.set(camera.camera.frustum);
-        update_frustum_far_plane(clipped_frustum, camera.camera.view_matrix, camera.camera.far);
-
-        this.#metadata.upload({
-            cluster_parameters: volumetrics_cluster_parameters,
-            froxel_cluster_parameters: volumetrics_froxel_cluster_parameters,
-            resolution,
-            frustum: slice_flat_array(clipped_frustum, 0, 4, 6),
-            history_reset: this.#reset_history ? 1 : 0,
-            froxel_far,
-            // multiscatter knobs (GUI-tunable via globals); engine defaults 6 / 0.5
-            ms_octave_count: globalThis.__VOL_MS_OCTAVES ?? 6,
-            ms_extinction_decay: globalThis.__VOL_MS_EXT_DECAY ?? 0.5,
-        }, this.#device.queue);
-    }
-
-    /**
-     *
-     * @param {FrameGraph} graph
-     * @param {number} light_cluster_data
-     * @param {number} light_cluster_lookup
-     * @param {number} light_cluster_parameters
-     * @param {number} shadowmap_atlas
-     */
-    graph_update({
-                     graph,
-                     light_cluster_data,
-                     light_cluster_lookup,
-                     light_cluster_parameters,
-                     shadowmap_atlas,
-                 }) {
-
-        const view = this.#view;
-        const lights = view.scene.lights;
-        const camera = view.camera;
-
-        // Optional runtime A/B toggle (e.g. a GUI checkbox) without per-view plumbing. The setter
-        // forces a history reset on change, so flipping it back on never blends against stale data.
-        const taa_requested = globalThis.__VOL_TAA_ENABLED ?? true;
-        if (taa_requested !== this.#taa_enabled) {
-            this.taa_enabled = taa_requested;
-        }
-
-        // runtime froxel-grid far override (GUI); Infinity -> grid covers the whole range (no far march)
-        const froxel_far_requested = globalThis.__VOL_FROXEL_FAR ?? Infinity;
-        if (froxel_far_requested !== this.#froxel_far) {
-            this.#froxel_far = froxel_far_requested;
-            // the froxel grid's depth curve just changed; the TAA history is on the old curve, reset it
-            this.#reset_history = true;
-        }
-
-        this.#update_resolution();
-        this.#update_metadata();
-
-        const gr_metadata = graph_import_buffer(graph, this.#metadata.buffer, "volumetrics metadata");
-
-        const resolution = this.#volumetrics_textures[0].size;
-
-        // Ping-pong the two persistent froxel textures: this frame writes [parity] and reads the
-        // previous frame's accumulation from [parity ^ 1]. On the first frame / after a resize the
-        // history is invalid, which #update_metadata signals via history_reset (the TAA then emits
-        // the fresh sample). graph_build_volumetrics inserts the reprojection pass only when both
-        // history/output handles are supplied — so leaving them undefined disables it.
-        let taa_history;
-        let taa_output;
-
-        if (this.#taa_enabled) {
-            const parity = view.frame_index & 1;
-            taa_history = graph_import_texture(graph, this.#volumetrics_textures[parity ^ 1], "volumetrics taa history");
-            taa_output = graph_import_texture(graph, this.#volumetrics_textures[parity], "volumetrics taa output");
-        }
-
-        const { lut_aerial } = graph_build_volumetrics({
-            graph,
-            camera,
-            lights,
-            view,
-            light_cluster_data,
-            light_cluster_lookup,
-            light_cluster_parameters,
-            shadowmap_atlas,
-
-            volumetrics_metadata: gr_metadata,
-            volumetric_resolution: resolution,
-
-            taa_history,
-            taa_output,
-            camera_previous: view.gpu_previous_camera_state,
-        });
-
-        this.#reset_history = false;
-
-        return {
-            resolved: lut_aerial,
-            metadata: gr_metadata,
-        };
-    }
-
+import { GPUTypedBuffer } from "../buffer/GPUTypedBuffer.js";
+import { graph_compute_pass } from "../shader/graph/compute/graph_compute_pass.js";
+import { graph_import_buffer } from "../shader/graph/graph_import_buffer.js";
+import { graph_import_texture } from "../shader/graph/graph_import_texture.js";
+import { GPUTextureContext } from "../texture/GPUTextureContext.js";
+import { update_frustum_far_plane } from "../shadow/map/update_frustum_far_plane.js";
+import { slice_flat_array } from "../util/slice_flat_array.js";
+import { build_light_cluster_parameters } from "../light/cluster/build_light_cluster_parameters.js";
+import {
+    build_volumetrics_sun_shadow_transform,
+    volumetrics_sun_shadow_cascade_far
+} from "./build_volumetrics_sun_shadow_transform.js";
+import { graph_build_volumetrics } from "./graph_build_volumetrics.js";
+import {
+    VOLUMETRICS_SUN_SHADOW_CASCADE_COUNT,
+    VOLUMETRICS_SUN_SHADOW_CASCADE_RATIO,
+    VOLUMETRICS_SUN_SHADOW_LIGHT_NONE,
+    VOLUMETRICS_SUN_SHADOW_RESOLUTION
+} from "./VOLUMETRICS_SUN_SHADOW_RESOLUTION.js";
+import { shader_volumetrics_taa } from "./taa/shader_volumetrics_taa.js";
+import { VOLUMETRICS_METADATA_STRUCT } from "./VOLUMETRICS_METADATA_STRUCT.js";
+import { VOLUMETRICS_RESOLUTION_Z } from "./VOLUMETRICS_RESOLUTION_Z.js";
+
+/**
+ * resolution of a single froxel in XY, in pixels
+ */
+const TILE_SIZE = 8;
+
+export class GPUViewVolumetrics {
+
+    /**
+     * @type {GPUViewContext}
+     */
+    #view
+
+    /**
+     * NOTE: Initialized in the constructor
+     * @type {GPUTextureContext[]}
+     */
+    #volumetrics_textures = [];
+
+    /**
+     * Should we perform temporal integration, or not?
+     * If set to true - the next update will discard history.
+     * Useful for significant scene transitions and screen resizing.
+     * @type {boolean}
+     */
+    #reset_history = true;
+
+    /**
+     * Whether to run the 3D temporal reprojection (volumetric TAA) over the per-froxel scattering
+     * volume. When disabled, the aerial pass integrates the raw (noisier) scattering LUT directly —
+     * a safe fallback if temporal artifacts appear.
+     * @type {boolean}
+     */
+    #taa_enabled = true;
+
+    /**
+     * @returns {boolean}
+     */
+    get taa_enabled() {
+        return this.#taa_enabled;
+    }
+
+    /**
+     * @param {boolean} v
+     */
+    set taa_enabled(v) {
+        if (v === this.#taa_enabled) {
+            return;
+        }
+        this.#taa_enabled = v;
+        // re-enabling must not blend against a stale / never-written history texture
+        this.#reset_history = true;
+    }
+
+    /**
+     * View-space distance at which the froxel grid ends and the aerial pass switches to a direct
+     * RDR2-style volume ray-march. Clamped to camera.far at upload, so the default (Infinity) means
+     * "grid covers the whole range" and the far march is a no-op.
+     * @type {number}
+     */
+    #froxel_far = Infinity;
+
+    /**
+     * @returns {number}
+     */
+    get froxel_far() {
+        return this.#froxel_far;
+    }
+
+    /**
+     * @param {number} v
+     */
+    set froxel_far(v) {
+        this.#froxel_far = v;
+    }
+
+    /**
+     * Q-04. World -> volume and back for each cascade, innermost first, rebuilt every frame by
+     * {@link build_volumetrics_sun_shadow_transform} and uploaded in the metadata.
+     * @type {Float32Array[]}
+     */
+    #sun_shadow_ws_to_uvw = Array.from({ length: VOLUMETRICS_SUN_SHADOW_CASCADE_COUNT }, () => new Float32Array(16));
+
+    /**
+     * @type {Float32Array[]}
+     */
+    #sun_shadow_uvw_to_ws = Array.from({ length: VOLUMETRICS_SUN_SHADOW_CASCADE_COUNT }, () => new Float32Array(16));
+
+    /**
+     * Voxel counts one sun optical-depth cascade is dispatched at this frame. Collapses to
+     * `[1, 1, 1]` when the froxels are marching instead, so the passes stay in the frame graph and
+     * cost nothing — see `graph_build_sun_shadow_volume` for why they stay rather than going.
+     * @type {number[]}
+     */
+    #sun_shadow_resolution = [1, 1, 1];
+
+    /**
+     * World-space size of one voxel along the sun axis per cascade, i.e. each scan's step, packed
+     * for the `vec4f` the metadata carries.
+     * @type {Float32Array}
+     */
+    #sun_shadow_step_ws = new Float32Array(4);
+
+    /**
+     * Which directional light this frame's cascades were built for, or
+     * {@link VOLUMETRICS_SUN_SHADOW_LIGHT_NONE} when there was nothing to build for.
+     * @type {number}
+     */
+    #sun_shadow_light_index = VOLUMETRICS_SUN_SHADOW_LIGHT_NONE;
+
+    /**
+     * View depth each cascade covers out to, packed the same way. Trailing lanes repeat the
+     * outermost so a read past the end of the ladder still lands on a real cascade.
+     * @type {Float32Array}
+     */
+    #sun_shadow_cascade_far = new Float32Array(4);
+
+    /**
+     * @type {GPUTypedBuffer}
+     */
+    #metadata;
+
+    /**
+     * @type {GPUDevice}
+     */
+    #device
+
+    /**
+     *
+     * @param {GPUViewContext} view
+     * @param {GPUDevice} device
+     */
+    constructor(view, device) {
+        this.#device = device;
+        this.#view = view;
+
+        // initialize textures
+        for (let i = 0; i < 2; i++) {
+            const texture = new GPUTextureContext(device);
+
+            texture.descriptor.format = "rgba16float";
+            texture.descriptor.dimension = "3d";
+            texture.descriptor.usage = GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING;
+
+            this.#volumetrics_textures[i] = texture;
+        }
+
+        this.#metadata = GPUTypedBuffer.create({
+            type: VOLUMETRICS_METADATA_STRUCT,
+            device,
+            usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST,
+        });
+
+    }
+
+    destroy() {
+
+        const textures = this.#volumetrics_textures;
+
+        for (let i = 0; i < 2; i++) {
+
+            textures[i].destroy();
+
+            textures[i] = null;
+        }
+
+    }
+
+    #update_resolution() {
+
+
+        const screen_resolution = this.#view.resolution;
+
+        const output_resolution_x = Math.ceil(screen_resolution[0] / TILE_SIZE);
+        const output_resolution_y = Math.ceil(screen_resolution[1] / TILE_SIZE);
+
+        const t_first = this.#volumetrics_textures[0];
+
+        if (t_first.width === output_resolution_x
+            && t_first.height === output_resolution_y
+        ) {
+            // already at the right resolution
+            return;
+        }
+
+        for (let i = 0; i < 2; i++) {
+
+            this.#volumetrics_textures[i].resize(
+                output_resolution_x,
+                output_resolution_y,
+                VOLUMETRICS_RESOLUTION_Z
+            );
+
+        }
+
+        // drop history
+        this.#reset_history = true;
+    }
+
+    /**
+     * Place this frame's sun optical-depth cascades, and say which light they cover.
+     *
+     * This is how the sun's media self-shadowing is computed — there is no second path to select
+     * between. The march in `chunk_integrate_optical_depth` remains for the lights the cascades do
+     * not cover: every point and spot light, whose rays are short enough that there is little to
+     * amortize, and any directional light past the first, since there is one ladder of boxes and it
+     * is aligned to one direction. Two situations leave the cascades covering nothing at all, and
+     * `VOLUMETRICS_SUN_SHADOW_LIGHT_NONE` is how they say so.
+     *
+     * The light is the first entry of the `light_directional` table, which is the first
+     * `DirectionalLight` in scene order — `GPULightCollection.#build` packs them in that order, so
+     * walking the same list here recovers the same index. In practice a scene has one sun.
+     *
+     * Every cascade is placed by the same call with a different `far`, which is what makes the
+     * stability argument transfer: each box is sized from the bounding sphere of the sub-frustum it
+     * covers, that sphere is a function of the projection alone, and the origin is snapped to whole
+     * voxels — so each cascade's world-space lattice is the same set of points from frame to frame
+     * no matter how the camera moves.
+     *
+     * @returns {number} the light index the cascades cover, or the sentinel
+     */
+    #update_sun_shadow() {
+        const camera = this.#view.camera.camera;
+
+        // One voxel per cascade rather than no pass at all: the lighting pass binds these textures
+        // unconditionally and WebGPU has no optional bindings. Nothing samples them, because the
+        // sentinel below matches no light index.
+        this.#sun_shadow_resolution = [1, 1, 1];
+
+        // an orthographic view has no fov to derive a bounding sphere from, and no volumetrics
+        // camera path that reaches here today — bail rather than invent one
+        if (typeof camera.fov !== "number") {
+            return VOLUMETRICS_SUN_SHADOW_LIGHT_NONE;
+        }
+
+        const lights = this.#view.scene.lights.source.elements;
+
+        let sun = null;
+
+        for (let i = 0; i < lights.length; i++) {
+            if (lights[i].isDirectionalLight === true) {
+                sun = lights[i];
+                break;
+            }
+        }
+
+        if (sun === null) {
+            return VOLUMETRICS_SUN_SHADOW_LIGHT_NONE;
+        }
+
+        const resolution = VOLUMETRICS_SUN_SHADOW_RESOLUTION;
+
+        // `forward` is the direction light TRAVELS — the same vector light_record_directional
+        // writes into the table, which the shader then negates to point at the light.
+        const direction = sun.forward;
+
+        const view_matrix = camera.view_matrix;
+        const position = camera.transform.position;
+
+        // the medium lives in the froxel grid and the grid stops here, so there is nothing to
+        // integrate past it
+        const far = Math.min(this.#froxel_far, camera.far);
+
+        const cascade_count = VOLUMETRICS_SUN_SHADOW_CASCADE_COUNT;
+        const cascade_ratio = VOLUMETRICS_SUN_SHADOW_CASCADE_RATIO;
+
+        // the view matrix's z row, negated: view space looks down -Z, and the row is unit length
+        // because the linear part is a rotation
+        const camera_forward = [-view_matrix[2], -view_matrix[6], -view_matrix[10]];
+
+        for (let cascade = 0; cascade < cascade_count; cascade++) {
+
+            const cascade_far = volumetrics_sun_shadow_cascade_far(far, cascade, cascade_count, cascade_ratio);
+
+            this.#sun_shadow_step_ws[cascade] = build_volumetrics_sun_shadow_transform({
+                ws_to_uvw: this.#sun_shadow_ws_to_uvw[cascade],
+                uvw_to_ws: this.#sun_shadow_uvw_to_ws[cascade],
+                light_direction: [direction.x, direction.y, direction.z],
+                camera_position: [position.x, position.y, position.z],
+                camera_forward,
+                fov_y: camera.fov,
+                aspect: camera.aspect,
+                near: camera.near,
+                far: cascade_far,
+                resolution,
+            });
+
+            this.#sun_shadow_cascade_far[cascade] = cascade_far;
+        }
+
+        // Trailing lanes repeat the outermost cascade rather than holding zero: the read side walks
+        // the ladder comparing view depth against these, and a zero would read as a cascade that
+        // ends at the camera.
+        for (let lane = cascade_count; lane < 4; lane++) {
+            this.#sun_shadow_cascade_far[lane] = far;
+            this.#sun_shadow_step_ws[lane] = this.#sun_shadow_step_ws[cascade_count - 1];
+        }
+
+        this.#sun_shadow_resolution = resolution;
+
+        return 0;
+    }
+
+    #update_metadata() {
+        const view = this.#view;
+        const camera = view.camera;
+
+        const resolution = this.#volumetrics_textures[0].size;
+
+        this.#sun_shadow_light_index = this.#update_sun_shadow();
+
+        const volumetrics_cluster_parameters = new Float32Array(3);
+
+        // The depth-curve `scale` must grow with the slice count. The hard-coded 4.06 was tuned for
+        // the light-cluster grid (24 slices); reusing it with 64 froxel slices collapses the log
+        // curve so ~half the slices bunch into the first fraction of a unit of depth, leaving almost
+        // none for the actual scene. Derive scale for a log-uniform distribution over
+        // [near + near_offset, far] instead (gives O ~= 0, i.e. depth ~ offset * (far/offset)^(s/(N-1))).
+        const NEAR_OFFSET = 0.1;
+        const depth_offset = camera.camera.near + NEAR_OFFSET;
+        const depth_scale = (VOLUMETRICS_RESOLUTION_Z - 1) / Math.log2(camera.camera.far / depth_offset);
+
+        build_light_cluster_parameters(
+            volumetrics_cluster_parameters,
+            0,
+            VOLUMETRICS_RESOLUTION_Z,
+            camera.camera.near,
+            camera.camera.far,
+            NEAR_OFFSET,
+            depth_scale
+        );
+
+        // Froxel-grid curve: same construction but ending at froxel_far (<= camera.far). The grid's
+        // slices pack into [near, froxel_far] for extra near detail; beyond froxel_far the aerial
+        // pass ray-marches the volumes. froxel_far == camera.far -> identical to the LUT curve (no-op).
+        const froxel_far = Math.min(this.#froxel_far, camera.camera.far);
+        const froxel_depth_scale = (VOLUMETRICS_RESOLUTION_Z - 1) / Math.log2(froxel_far / depth_offset);
+        const volumetrics_froxel_cluster_parameters = new Float32Array(3);
+        build_light_cluster_parameters(
+            volumetrics_froxel_cluster_parameters,
+            0,
+            VOLUMETRICS_RESOLUTION_Z,
+            camera.camera.near,
+            froxel_far,
+            NEAR_OFFSET,
+            froxel_depth_scale
+        );
+
+        // The projection is infinite-far reverse-Z, so the camera frustum's far plane is zeroed and
+        // can't be sliced into froxel slabs. Rebuild a finite far plane at the logical far for the
+        // participating-media coverage test — exactly as the light-cluster assignment does.
+        const clipped_frustum = new Float32Array(24);
+        clipped_frustum.set(camera.camera.frustum);
+        update_frustum_far_plane(clipped_frustum, camera.camera.view_matrix, camera.camera.far);
+
+        this.#metadata.upload({
+            cluster_parameters: volumetrics_cluster_parameters,
+            froxel_cluster_parameters: volumetrics_froxel_cluster_parameters,
+            resolution,
+            frustum: slice_flat_array(clipped_frustum, 0, 4, 6),
+            history_reset: this.#reset_history ? 1 : 0,
+            froxel_far,
+            // multiscatter knobs (GUI-tunable via globals); engine defaults 6 / 0.5
+            ms_octave_count: globalThis.__VOL_MS_OCTAVES ?? 6,
+            ms_extinction_decay: globalThis.__VOL_MS_EXT_DECAY ?? 0.5,
+            // Q-04. The sun's media self-shadowing, out of a 16-step per-froxel march and into one
+            // fetch of the cascades built earlier this frame — see #update_sun_shadow.
+            sun_shadow_ws_to_uvw: this.#sun_shadow_ws_to_uvw,
+            sun_shadow_uvw_to_ws: this.#sun_shadow_uvw_to_ws,
+            sun_shadow_step_ws: this.#sun_shadow_step_ws,
+            sun_shadow_cascade_far: this.#sun_shadow_cascade_far,
+            sun_shadow_light_index: this.#sun_shadow_light_index,
+        }, this.#device.queue);
+    }
+
+    /**
+     *
+     * @param {FrameGraph} graph
+     * @param {number} light_cluster_data
+     * @param {number} light_cluster_lookup
+     * @param {number} light_cluster_parameters
+     * @param {number} shadowmap_atlas
+     */
+    graph_update({
+                     graph,
+                     light_cluster_data,
+                     light_cluster_lookup,
+                     light_cluster_parameters,
+                     shadowmap_atlas,
+                 }) {
+
+        const view = this.#view;
+        const lights = view.scene.lights;
+        const camera = view.camera;
+
+        // Optional runtime A/B toggle (e.g. a GUI checkbox) without per-view plumbing. The setter
+        // forces a history reset on change, so flipping it back on never blends against stale data.
+        const taa_requested = globalThis.__VOL_TAA_ENABLED ?? true;
+        if (taa_requested !== this.#taa_enabled) {
+            this.taa_enabled = taa_requested;
+        }
+
+        // runtime froxel-grid far override (GUI); Infinity -> grid covers the whole range (no far march)
+        const froxel_far_requested = globalThis.__VOL_FROXEL_FAR ?? Infinity;
+        if (froxel_far_requested !== this.#froxel_far) {
+            this.#froxel_far = froxel_far_requested;
+            // the froxel grid's depth curve just changed; the TAA history is on the old curve, reset it
+            this.#reset_history = true;
+        }
+
+        this.#update_resolution();
+        this.#update_metadata();
+
+        const gr_metadata = graph_import_buffer(graph, this.#metadata.buffer, "volumetrics metadata");
+
+        const resolution = this.#volumetrics_textures[0].size;
+
+        // Ping-pong the two persistent froxel textures: this frame writes [parity] and reads the
+        // previous frame's accumulation from [parity ^ 1]. On the first frame / after a resize the
+        // history is invalid, which #update_metadata signals via history_reset (the TAA then emits
+        // the fresh sample). graph_build_volumetrics inserts the reprojection pass only when both
+        // history/output handles are supplied — so leaving them undefined disables it.
+        let taa_history;
+        let taa_output;
+
+        if (this.#taa_enabled) {
+            const parity = view.frame_index & 1;
+            taa_history = graph_import_texture(graph, this.#volumetrics_textures[parity ^ 1], "volumetrics taa history");
+            taa_output = graph_import_texture(graph, this.#volumetrics_textures[parity], "volumetrics taa output");
+        }
+
+        const { lut_aerial } = graph_build_volumetrics({
+            graph,
+            camera,
+            lights,
+            view,
+            light_cluster_data,
+            light_cluster_lookup,
+            light_cluster_parameters,
+            shadowmap_atlas,
+
+            volumetrics_metadata: gr_metadata,
+            volumetric_resolution: resolution,
+            sun_shadow_resolution: this.#sun_shadow_resolution,
+
+            taa_history,
+            taa_output,
+            camera_previous: view.gpu_previous_camera_state,
+        });
+
+        this.#reset_history = false;
+
+        return {
+            resolved: lut_aerial,
+            metadata: gr_metadata,
+        };
+    }
+
 }