@woosh/meep-engine 3.49.0 → 3.50.0

package/src/shade/renderer/volumetrics/gi/chunk_volumetrics_gi.js

@@ -4,18 +4,17 @@ import {
 import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
 import { INDIRECT_LIGHT_INTENSITY } from "../../deferred/INDIRECT_LIGHT_INTENSITY.js";
 import { chunk_volumetrics_irradiance_sh } from "../chunk_volumetrics_irradiance_sh.js";
+import { VOLUMETRICS_GI_COCG_RESOURCE, VOLUMETRICS_GI_Y_RESOURCE } from "./volumetrics_gi_resources.js";
 
 /**
- * What every froxel GI module shares. A module is one concrete compute shader per indirect lighting
- * mode (`shader_volumetrics_gi_ibl`, `_brick4`, `_lpv`), one thread per froxel: it asks its mode what
- * radiance arrives at the froxel, as RGB SH2, and hands the answer to `volumetrics_gi_store`. That
- * starts the froxel irradiance volume, and `shader_volumetrics_build_irradiance` adds the lights to it.
- * A new mode is one more module: nothing downstream knows which mode wrote the volume.
+ * How the froxel GI stage (`shader_volumetrics_gi`) stores its answer. One thread per froxel asks the
+ * renderer's indirect lighting mode what radiance arrives at the froxel, as RGB SH2
+ * (`chunk_volumetrics_gi_sample`), and hands the answer to `volumetrics_gi_store`. That starts the
+ * froxel irradiance volume, and `shader_volumetrics_build_irradiance` adds the lights to it.
  *
- * `volumetrics_froxel_centre_ws` (`chunk_volumetrics_froxel_centre_ws`) says where a froxel is, for a
- * mode whose answer depends on position; `volumetrics_gi_store(voxel, radiance)` — scales the field by `INDIRECT_LIGHT_INTENSITY`, as the
- *   deferred and forward paths scale their indirect light, encodes it as the volume stores light
- *   (`volumetrics_irradiance_sh_add_radiance`) and writes it to `tGIY` / `tGICoCg`.
+ * `volumetrics_gi_store(voxel, radiance)` scales the field by `INDIRECT_LIGHT_INTENSITY`, as the
+ * deferred and forward paths scale their indirect light, encodes it as the volume stores light
+ * (`volumetrics_irradiance_sh_add_radiance`) and writes it to `tGIY` / `tGICoCg`.
  *
  * The enclosing shader binds `tGIY` and `tGICoCg` under those names.
  *
@@ -46,3 +45,6 @@ fn volumetrics_gi_store(voxel: vec3<u32>, radiance: array<vec3<f32>, 4>) {
         chunk_volumetrics_irradiance_sh,
     ]
 );
+
+chunk_volumetrics_gi.requireResource(VOLUMETRICS_GI_COCG_RESOURCE);
+chunk_volumetrics_gi.requireResource(VOLUMETRICS_GI_Y_RESOURCE);

package/src/shade/renderer/volumetrics/gi/chunk_volumetrics_gi_sample.d.ts

@@ -0,0 +1,35 @@
+/**
+ * {@link chunk_volumetrics_gi_sample} under IBL: the environment, as `GPULightCollection.environment_sh`
+ * holds it (`shader_project_environment_sh`). It is infinitely far, so every froxel receives the same
+ * field.
+ * @type {CodeChunk}
+ */
+export const chunk_volumetrics_gi_sample_ibl: CodeChunk;
+/**
+ * {@link chunk_volumetrics_gi_sample} under Brick4: the sparse volumetric light map's probes,
+ * interpolated at the froxel's centre and truncated from SH3 to SH2. Reads `brick4`.
+ * @type {CodeChunk}
+ */
+export const chunk_volumetrics_gi_sample_brick4: CodeChunk;
+/**
+ * {@link chunk_volumetrics_gi_sample} under LPV: the light probe volume's tetrahedral mesh, its probes
+ * (radiance SH2) interpolated barycentrically at the froxel's centre. Reads the LPV's buffers.
+ * @type {CodeChunk}
+ */
+export const chunk_volumetrics_gi_sample_lpv: CodeChunk;
+/**
+ * The radiance that arrives at a froxel, as RGB SH2, by the renderer's indirect lighting mode
+ * ({@link INDIRECT_LIGHTING}):
+ *
+ * ```wgsl
+ * fn volumetrics_gi_sample(voxel: vec3<u32>, resolution: vec3<u32>) -> array<vec3<f32>, 4>
+ * ```
+ *
+ * A new mode is one more alternative: nothing downstream knows which mode wrote the volume.
+ *
+ * @type {CodeChunkChoice}
+ */
+export const chunk_volumetrics_gi_sample: CodeChunkChoice;
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { CodeChunkChoice } from "../../shader/compiler/CodeChunkChoice.js";
+//# sourceMappingURL=chunk_volumetrics_gi_sample.d.ts.map

package/src/shade/renderer/volumetrics/gi/chunk_volumetrics_gi_sample.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_volumetrics_gi_sample.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/volumetrics/gi/chunk_volumetrics_gi_sample.js"],"names":[],"mappings":"AAWA;;;;;GAKG;AACH,8CAFU,SAAS,CAaZ;AAIP;;;;GAIG;AACH,iDAFU,SAAS,CAmBhB;AAEH;;;;GAIG;AACH,8CAFU,SAAS,CA2BhB;AAEH;;;;;;;;;;;GAWG;AACH,0CAFU,eAAe,CAE0D;0BA9FzD,oCAAoC;gCAC9B,0CAA0C"}

package/src/shade/renderer/volumetrics/gi/chunk_volumetrics_gi_sample.js

@@ -0,0 +1,105 @@
+import { chunk_brick4_sample_sh } from "../../global_illumination/brick4/gpu/draw/chunk_brick4_sample_sh.js";
+import { INDIRECT_LIGHTING } from "../../INDIRECT_LIGHTING.js";
+import { ShadeIndirectLightingMode } from "../../ShadeIndirectLightingMode.js";
+import { chunk_lpv_mesh_interpolation_probe_sh } from "../../shader/chunk/light/lpv/chunk_lpv_mesh_interpolation_probe_sh.js";
+import { chunk_lpv_mesh_lookup_nearest_cell } from "../../shader/chunk/light/lpv/chunk_lpv_mesh_lookup_nearest_cell.js";
+import { INVALID_TET_DECLARATION } from "../../shader/chunk/light/lpv/INVALID_TET_DECLARATION.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { CodeChunkChoice } from "../../shader/compiler/CodeChunkChoice.js";
+import { chunk_volumetrics_froxel_centre_ws } from "./chunk_volumetrics_froxel_centre_ws.js";
+import { ENVIRONMENT_SH_RESOURCE } from "../../light/environment/ENVIRONMENT_SH_RESOURCE.js";
+
+/**
+ * {@link chunk_volumetrics_gi_sample} under IBL: the environment, as `GPULightCollection.environment_sh`
+ * holds it (`shader_project_environment_sh`). It is infinitely far, so every froxel receives the same
+ * field.
+ * @type {CodeChunk}
+ */
+export const chunk_volumetrics_gi_sample_ibl = CodeChunk.from(
+    //language=WGSL
+    `
+fn volumetrics_gi_sample(voxel: vec3<u32>, resolution: vec3<u32>) -> array<vec3<f32>, 4> {
+    return array<vec3<f32>, 4>(
+        environment_sh[0].xyz,
+        environment_sh[1].xyz,
+        environment_sh[2].xyz,
+        environment_sh[3].xyz,
+    );
+}
+`, []);
+
+chunk_volumetrics_gi_sample_ibl.requireResource(ENVIRONMENT_SH_RESOURCE);
+
+/**
+ * {@link chunk_volumetrics_gi_sample} under Brick4: the sparse volumetric light map's probes,
+ * interpolated at the froxel's centre and truncated from SH3 to SH2. Reads `brick4`.
+ * @type {CodeChunk}
+ */
+export const chunk_volumetrics_gi_sample_brick4 = CodeChunk.from(
+    //language=WGSL
+    `
+fn volumetrics_gi_sample(voxel: vec3<u32>, resolution: vec3<u32>) -> array<vec3<f32>, 4> {
+    let position = volumetrics_froxel_centre_ws(voxel, resolution);
+
+    // A froxel has no surface. The normal only masks probes behind one, and a zero normal weighs
+    // every probe of the brick the same (brick4_probe_compute_weight_by_normal), which is the
+    // interpolation a point in open space wants.
+    let sh = brick4_sample_sh(position, vec3<f32>(0.0));
+
+    // SH3 to SH2: the first four coefficients are the same two bands, in the same order
+    return array<vec3<f32>, 4>(sh[0], sh[1], sh[2], sh[3]);
+}
+`, [
+    chunk_volumetrics_froxel_centre_ws,
+    chunk_brick4_sample_sh,
+]);
+
+/**
+ * {@link chunk_volumetrics_gi_sample} under LPV: the light probe volume's tetrahedral mesh, its probes
+ * (radiance SH2) interpolated barycentrically at the froxel's centre. Reads the LPV's buffers.
+ * @type {CodeChunk}
+ */
+export const chunk_volumetrics_gi_sample_lpv = CodeChunk.from(
+    //language=WGSL
+    `
+fn volumetrics_gi_sample(voxel: vec3<u32>, resolution: vec3<u32>) -> array<vec3<f32>, 4> {
+    let position = volumetrics_froxel_centre_ws(voxel, resolution);
+
+    var weights: vec4<f32>;
+    let tet = lpv_mesh_lookup_nearest_cell(position, &weights);
+
+    // Outside the probe mesh there is nothing to interpolate, and the deferred LPV pass gives such a
+    // point no indirect light either. No visibility mask: that needs a surface normal, and a froxel
+    // has none.
+    var radiance = array<vec3<f32>, 4>();
+
+    if (tet != INVALID_TET) {
+        radiance = lpv_mesh_interpolation_probe_sh(weights, tet);
+    }
+
+    return radiance;
+}
+`, [
+    chunk_volumetrics_froxel_centre_ws,
+    chunk_lpv_mesh_lookup_nearest_cell,
+    chunk_lpv_mesh_interpolation_probe_sh,
+    INVALID_TET_DECLARATION,
+]);
+
+/**
+ * The radiance that arrives at a froxel, as RGB SH2, by the renderer's indirect lighting mode
+ * ({@link INDIRECT_LIGHTING}):
+ *
+ * ```wgsl
+ * fn volumetrics_gi_sample(voxel: vec3<u32>, resolution: vec3<u32>) -> array<vec3<f32>, 4>
+ * ```
+ *
+ * A new mode is one more alternative: nothing downstream knows which mode wrote the volume.
+ *
+ * @type {CodeChunkChoice}
+ */
+export const chunk_volumetrics_gi_sample = CodeChunkChoice.from(INDIRECT_LIGHTING);
+
+chunk_volumetrics_gi_sample.add(ShadeIndirectLightingMode.IBL, chunk_volumetrics_gi_sample_ibl);
+chunk_volumetrics_gi_sample.add(ShadeIndirectLightingMode.Brick4, chunk_volumetrics_gi_sample_brick4);
+chunk_volumetrics_gi_sample.add(ShadeIndirectLightingMode.LPV, chunk_volumetrics_gi_sample_lpv);

package/src/shade/renderer/volumetrics/gi/graph_build_froxel_gi.d.ts

@@ -1,23 +1,29 @@
 /**
  * The froxel GI stage: the renderer's indirect lighting at every froxel, as the froxel irradiance
- * volume encodes light, for `shader_volumetrics_build_irradiance` to add the lights to. One module per
- * mode (see `chunk_volumetrics_gi`); this picks the one `indirect_lighting_mode` names and binds its
- * source from the scene.
+ * volume encodes light, for `shader_volumetrics_build_irradiance` to add the lights to. The shader is
+ * built for the renderer's switches, which pick the indirect lighting mode it samples
+ * (`chunk_volumetrics_gi_sample`); this binds the environment and the running mode's source.
  *
  * @param {object} options
  * @param {import("../../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph} options.graph
- * @param {ShadeIndirectLightingMode} options.indirect_lighting_mode
- * @param {import("../../scene/GPUSceneContext.js").GPUSceneContext} options.scene_ctx the GI sources:
- *   `lights.environment_sh`, `volumetric_light_map`, `light_probe_volume`
+ * @param {ShaderSwitchSet} [options.shader_switches] the renderer's
+ * @param {import("../../scene/GPUSceneContext.js").GPUSceneContext} options.scene_ctx for its environment,
+ *   `lights.environment_sh`
+ * @param {import("../../global_illumination/brick4/Brick4LightMap.js").Brick4LightMap} [options.brick4] the scene's,
+ *   while Brick4 runs
+ * @param {import("../../global_illumination/lpv/GPULightProbeVolume.js").GPULightProbeVolume} [options.lpv] the
+ *   scene's, while LPV runs. A source not given is the shader's default, for a variant that does not read it
  * @param {import("../../camera/GPUCameraContext.js").GPUCameraContext} options.camera
  * @param {number} options.volumetrics_metadata graph handle
  * @param {number[]} options.resolution the froxel grid
  * @returns {{Y: number, CoCg: number}} handles of the GI volume, in the froxel irradiance encoding
  */
-export function graph_build_froxel_gi({ graph, indirect_lighting_mode, scene_ctx, camera, volumetrics_metadata, resolution, }: {
+export function graph_build_froxel_gi({ graph, shader_switches, scene_ctx, brick4, lpv, camera, volumetrics_metadata, resolution, }: {
     graph: import("../../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph;
-    indirect_lighting_mode: ShadeIndirectLightingMode;
+    shader_switches?: ShaderSwitchSet;
     scene_ctx: import("../../scene/GPUSceneContext.js").GPUSceneContext;
+    brick4?: import("../../global_illumination/brick4/Brick4LightMap.js").Brick4LightMap;
+    lpv?: import("../../global_illumination/lpv/GPULightProbeVolume.js").GPULightProbeVolume;
     camera: import("../../camera/GPUCameraContext.js").GPUCameraContext;
     volumetrics_metadata: number;
     resolution: number[];
@@ -25,5 +31,5 @@ export function graph_build_froxel_gi({ graph, indirect_lighting_mode, scene_ctx
     Y: number;
     CoCg: number;
 };
-import { ShadeIndirectLightingMode } from "../../ShadeIndirectLightingMode.js";
+import { ShaderSwitchSet } from "../../shader/compiler/ShaderSwitchSet.js";
 //# sourceMappingURL=graph_build_froxel_gi.d.ts.map

package/src/shade/renderer/volumetrics/gi/graph_build_froxel_gi.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graph_build_froxel_gi.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/volumetrics/gi/graph_build_froxel_gi.js"],"names":[],"mappings":"AASA;;;;;;;;;;;;;;;GAeG;AACH;IATsG,KAAK,EAAhG,OAAO,8DAA8D,EAAE,UAAU;IAC9C,sBAAsB,EAAzD,yBAAyB;IACyC,SAAS,EAA3E,OAAO,gCAAgC,EAAE,eAAe;IAEa,MAAM,EAA3E,OAAO,kCAAkC,EAAE,gBAAgB;IAC3C,oBAAoB,EAApC,MAAM;IACY,UAAU,EAA5B,MAAM,EAAE;IACN;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAC,CAkErC;0CAtFyC,oCAAoC"}
+{"version":3,"file":"graph_build_froxel_gi.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/volumetrics/gi/graph_build_froxel_gi.js"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;;;;;;GAmBG;AACH;IAbsG,KAAK,EAAhG,OAAO,8DAA8D,EAAE,UAAU;IACvD,eAAe,GAAzC,eAAe;IACmD,SAAS,EAA3E,OAAO,gCAAgC,EAAE,eAAe;IAE8B,MAAM,GAA5F,OAAO,oDAAoD,EAAE,cAAc;IAEkB,GAAG,GAAhG,OAAO,sDAAsD,EAAE,mBAAmB;IAEb,MAAM,EAA3E,OAAO,kCAAkC,EAAE,gBAAgB;IAC3C,oBAAoB,EAApC,MAAM;IACY,UAAU,EAA5B,MAAM,EAAE;IACN;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAC,CAsDrC;gCA5E+B,0CAA0C"}

package/src/shade/renderer/volumetrics/gi/graph_build_froxel_gi.js

@@ -1,23 +1,25 @@
 import { TextureResourceDescriptor } from "../../../device/graph/TextureResourceDescriptor.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 { ShadeIndirectLightingMode } from "../../ShadeIndirectLightingMode.js";
-import { shader_volumetrics_gi_brick4 } from "./shader_volumetrics_gi_brick4.js";
-import { shader_volumetrics_gi_ibl } from "./shader_volumetrics_gi_ibl.js";
-import { shader_volumetrics_gi_lpv } from "./shader_volumetrics_gi_lpv.js";
+import { ShaderSwitchSet } from "../../shader/compiler/ShaderSwitchSet.js";
+import { shader_volumetrics_gi } from "./shader_volumetrics_gi.js";
 import { VOLUMETRICS_GI_WORKGROUP_RESOLUTION } from "./volumetrics_gi_resources.js";
 
 /**
  * The froxel GI stage: the renderer's indirect lighting at every froxel, as the froxel irradiance
- * volume encodes light, for `shader_volumetrics_build_irradiance` to add the lights to. One module per
- * mode (see `chunk_volumetrics_gi`); this picks the one `indirect_lighting_mode` names and binds its
- * source from the scene.
+ * volume encodes light, for `shader_volumetrics_build_irradiance` to add the lights to. The shader is
+ * built for the renderer's switches, which pick the indirect lighting mode it samples
+ * (`chunk_volumetrics_gi_sample`); this binds the environment and the running mode's source.
  *
  * @param {object} options
  * @param {import("../../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph} options.graph
- * @param {ShadeIndirectLightingMode} options.indirect_lighting_mode
- * @param {import("../../scene/GPUSceneContext.js").GPUSceneContext} options.scene_ctx the GI sources:
- *   `lights.environment_sh`, `volumetric_light_map`, `light_probe_volume`
+ * @param {ShaderSwitchSet} [options.shader_switches] the renderer's
+ * @param {import("../../scene/GPUSceneContext.js").GPUSceneContext} options.scene_ctx for its environment,
+ *   `lights.environment_sh`
+ * @param {import("../../global_illumination/brick4/Brick4LightMap.js").Brick4LightMap} [options.brick4] the scene's,
+ *   while Brick4 runs
+ * @param {import("../../global_illumination/lpv/GPULightProbeVolume.js").GPULightProbeVolume} [options.lpv] the
+ *   scene's, while LPV runs. A source not given is the shader's default, for a variant that does not read it
  * @param {import("../../camera/GPUCameraContext.js").GPUCameraContext} options.camera
  * @param {number} options.volumetrics_metadata graph handle
  * @param {number[]} options.resolution the froxel grid
@@ -25,8 +27,10 @@ import { VOLUMETRICS_GI_WORKGROUP_RESOLUTION } from "./volumetrics_gi_resources.
  */
 export function graph_build_froxel_gi({
                                           graph,
-                                          indirect_lighting_mode,
+                                          shader_switches = ShaderSwitchSet.EMPTY,
                                           scene_ctx,
+                                          brick4,
+                                          lpv,
                                           camera,
                                           volumetrics_metadata,
                                           resolution,
@@ -43,38 +47,24 @@ export function graph_build_froxel_gi({
         camera: graph_import_buffer(graph, camera.buffer.buffer, "froxel gi camera"),
         tGIY: volume(),
         tGICoCg: volume(),
+        environment_sh: scene_ctx.lights.environment_sh,
     };
 
-    let shader;
-
-    switch (indirect_lighting_mode) {
-        case ShadeIndirectLightingMode.IBL:
-            shader = shader_volumetrics_gi_ibl;
-            bindings.environment_sh = scene_ctx.lights.environment_sh;
-            break;
-
-        case ShadeIndirectLightingMode.Brick4:
-            shader = shader_volumetrics_gi_brick4;
-            bindings.brick4 = scene_ctx.volumetric_light_map.buffer;
-            break;
-
-        case ShadeIndirectLightingMode.LPV: {
-            shader = shader_volumetrics_gi_lpv;
-            const lpv = scene_ctx.light_probe_volume;
-            bindings.lpv_lookup = lpv.buffer_mesh_bvh;
-            bindings.lpv_metadata = lpv.buffer_metadata;
-            bindings.lpv_mesh = lpv.buffer_mesh;
-            bindings.lpv_probes = lpv.buffer_probes;
-            break;
-        }
+    // the running mode's source; the others are the shader's defaults, which its variant does not read
+    if (brick4 !== undefined) {
+        bindings.brick4 = brick4.buffer;
+    }
 
-        default:
-            throw new Error(`Unsupported indirect lighting mode: ${indirect_lighting_mode}`);
+    if (lpv !== undefined) {
+        bindings.lpv_lookup = lpv.buffer_mesh_bvh;
+        bindings.lpv_metadata = lpv.buffer_metadata;
+        bindings.lpv_mesh = lpv.buffer_mesh;
+        bindings.lpv_probes = lpv.buffer_probes;
     }
 
     const outputs = graph_compute_pass({
         graph,
-        shader,
+        shader: shader_volumetrics_gi.variant(shader_switches),
         group_count: [
             Math.ceil(resolution[0] / VOLUMETRICS_GI_WORKGROUP_RESOLUTION[0]),
             Math.ceil(resolution[1] / VOLUMETRICS_GI_WORKGROUP_RESOLUTION[1]),

package/src/shade/renderer/volumetrics/gi/shader_volumetrics_gi.d.ts

@@ -0,0 +1,10 @@
+/**
+ * The froxel GI stage: the renderer's indirect lighting at every froxel, one thread per froxel. Which
+ * mode's light it asks for is a shader switch ({@link chunk_volumetrics_gi_sample}); the bindings are
+ * the same for every mode. See `chunk_volumetrics_gi` for what it does with the answer.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_volumetrics_gi: ComputeShader;
+import { ComputeShader } from "../../shader/ComputeShader.js";
+//# sourceMappingURL=shader_volumetrics_gi.d.ts.map

package/src/shade/renderer/volumetrics/gi/shader_volumetrics_gi.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shader_volumetrics_gi.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/volumetrics/gi/shader_volumetrics_gi.js"],"names":[],"mappings":"AAuCA;;;;;;GAMG;AACH,oCAFU,aAAa,CAMpB;8BA9C2B,+BAA+B"}

package/src/shade/renderer/volumetrics/gi/shader_volumetrics_gi.js

@@ -0,0 +1,51 @@
+import { BRICK4_DATA_STRUCT } from "../../global_illumination/brick4/gpu/BRICK4_DATA_STRUCT.js";
+import { LPV_SHADER_RESOURCE_GROUP_WITH_DEFAULTS } from "../../global_illumination/probe/octahedral/LPV_SHADER_RESOURCE_GROUP.js";
+import { ENVIRONMENT_SH_TYPE } from "../../light/environment/shader_project_environment_sh.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { ComputeShader } from "../../shader/ComputeShader.js";
+import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
+import { chunk_volumetrics_gi } from "./chunk_volumetrics_gi.js";
+import { chunk_volumetrics_gi_sample } from "./chunk_volumetrics_gi_sample.js";
+import { VOLUMETRICS_GI_WORKGROUP_RESOLUTION, volumetrics_gi_resource_group } from "./volumetrics_gi_resources.js";
+
+const resources = new ShaderResourceSetDescriptor();
+
+// every indirect lighting mode's source, whichever the variant reads (chunk_volumetrics_gi_sample). The pass
+// binds the environment and the running mode's source; the others have defaults the variant does not read.
+resources.addGroup(
+    volumetrics_gi_resource_group()
+        .addUniform("environment_sh", ENVIRONMENT_SH_TYPE)
+        .addStorageBuffer("brick4", BRICK4_DATA_STRUCT, false, true)
+);
+resources.addGroup(LPV_SHADER_RESOURCE_GROUP_WITH_DEFAULTS);
+
+const body = CodeChunk.from(
+    //language=WGSL
+    `
+@compute @workgroup_size(${VOLUMETRICS_GI_WORKGROUP_RESOLUTION.join(", ")})
+fn main(@builtin(global_invocation_id) voxel: vec3<u32>) {
+    let resolution = textureDimensions(tGIY);
+
+    if (any(voxel >= resolution)) {
+        return;
+    }
+
+    volumetrics_gi_store(voxel, volumetrics_gi_sample(voxel, resolution));
+}
+`, [
+    chunk_volumetrics_gi,
+    chunk_volumetrics_gi_sample,
+]);
+
+/**
+ * The froxel GI stage: the renderer's indirect lighting at every froxel, one thread per froxel. Which
+ * mode's light it asks for is a shader switch ({@link chunk_volumetrics_gi_sample}); the bindings are
+ * the same for every mode. See `chunk_volumetrics_gi` for what it does with the answer.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_volumetrics_gi = ComputeShader.from({
+    label: "Volumetrics / GI",
+    resources,
+    body,
+});

package/src/shade/renderer/volumetrics/gi/volumetrics_gi_resources.d.ts

@@ -6,6 +6,16 @@
  * @returns {ShaderResourceGroupDescriptor}
  */
 export function volumetrics_gi_resource_group(): ShaderResourceGroupDescriptor;
+/**
+ * The froxel GI's luma volume, as its modules write it (`chunk_volumetrics_gi`).
+ * @type {ShaderResourceDescriptor}
+ */
+export const VOLUMETRICS_GI_Y_RESOURCE: ShaderResourceDescriptor;
+/**
+ * The froxel GI's chroma volume, as its modules write it (`chunk_volumetrics_gi`).
+ * @type {ShaderResourceDescriptor}
+ */
+export const VOLUMETRICS_GI_COCG_RESOURCE: ShaderResourceDescriptor;
 /**
  * Workgroup shape of every froxel GI module, `[x, y, z]` in froxels: flat in z like the lighting
  * pass, and 64 invocations.
@@ -14,4 +24,5 @@ export function volumetrics_gi_resource_group(): ShaderResourceGroupDescriptor;
  */
 export const VOLUMETRICS_GI_WORKGROUP_RESOLUTION: number[];
 import { ShaderResourceGroupDescriptor } from "../../shader/resource/ShaderResourceGroupDescriptor.js";
+import { ShaderResourceDescriptor } from "../../shader/resource/ShaderResourceDescriptor.js";
 //# sourceMappingURL=volumetrics_gi_resources.d.ts.map

package/src/shade/renderer/volumetrics/gi/volumetrics_gi_resources.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"volumetrics_gi_resources.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/volumetrics/gi/volumetrics_gi_resources.js"],"names":[],"mappings":"AAIA;;;;;;GAMG;AACH,iDAFa,6BAA6B,CAQzC;AAED;;;;;GAKG;AACH,kDAFU,MAAM,EAAE,CAE2C;8CAxBf,wDAAwD"}
+{"version":3,"file":"volumetrics_gi_resources.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/volumetrics/gi/volumetrics_gi_resources.js"],"names":[],"mappings":"AAiBA;;;;;;GAMG;AACH,iDAFa,6BAA6B,CAQzC;AAzBD;;;GAGG;AACH,wCAFU,wBAAwB,CAE0F;AAE5H;;;GAGG;AACH,2CAFU,wBAAwB,CAEgG;AAiBlI;;;;;GAKG;AACH,kDAFU,MAAM,EAAE,CAE2C;8CApCf,wDAAwD;yCAD7D,mDAAmD"}

package/src/shade/renderer/volumetrics/gi/volumetrics_gi_resources.js

@@ -1,6 +1,19 @@
-import { CAMERA_UNIFORM_STRUCT } from "../../camera/CAMERA_UNIFORM_STRUCT.js";
+import { CAMERA_RESOURCE } from "../../camera/CAMERA_RESOURCE.js";
+import { ShaderResourceDescriptor } from "../../shader/resource/ShaderResourceDescriptor.js";
 import { ShaderResourceGroupDescriptor } from "../../shader/resource/ShaderResourceGroupDescriptor.js";
-import { VOLUMETRICS_METADATA_STRUCT } from "../VOLUMETRICS_METADATA_STRUCT.js";
+import { VOLUMETRICS_METADATA_RESOURCE } from "../VOLUMETRICS_RESOURCES.js";
+
+/**
+ * The froxel GI's luma volume, as its modules write it (`chunk_volumetrics_gi`).
+ * @type {ShaderResourceDescriptor}
+ */
+export const VOLUMETRICS_GI_Y_RESOURCE = ShaderResourceDescriptor.storageTexture("tGIY", "rgba16float", "3d", "write-only");
+
+/**
+ * The froxel GI's chroma volume, as its modules write it (`chunk_volumetrics_gi`).
+ * @type {ShaderResourceDescriptor}
+ */
+export const VOLUMETRICS_GI_COCG_RESOURCE = ShaderResourceDescriptor.storageTexture("tGICoCg", "rgba16float", "3d", "write-only");
 
 /**
  * The bindings every froxel GI module has, whatever its mode reads: where the froxels are, and the
@@ -11,10 +24,10 @@ import { VOLUMETRICS_METADATA_STRUCT } from "../VOLUMETRICS_METADATA_STRUCT.js";
  */
 export function volumetrics_gi_resource_group() {
     return new ShaderResourceGroupDescriptor()
-        .addUniform("volumetrics_metadata", VOLUMETRICS_METADATA_STRUCT)
-        .addUniform("camera", CAMERA_UNIFORM_STRUCT)
-        .addStorageTexture("tGIY", "rgba16float", "3d", "write-only")
-        .addStorageTexture("tGICoCg", "rgba16float", "3d", "write-only");
+        .add(VOLUMETRICS_METADATA_RESOURCE)
+        .add(CAMERA_RESOURCE)
+        .add(VOLUMETRICS_GI_Y_RESOURCE)
+        .add(VOLUMETRICS_GI_COCG_RESOURCE);
 }
 
 /**

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

@@ -18,12 +18,15 @@
  * @param {number} options.shadowmap_atlas
  * @param {number} options.volumetrics_metadata where the froxels are
  * @param {number[]} options.resolution the froxel grid
- * @param {import("../ShadeIndirectLightingMode.js").ShadeIndirectLightingMode} options.indirect_lighting_mode which froxel GI
- *   module starts the volume
- * @param {ShaderSwitchSet} [options.shader_switches] the renderer's; the lights' pass is built for them
+ * @param {ShaderSwitchSet} [options.shader_switches] the renderer's; the GI that starts the volume and the
+ *   lights' pass are built for them
+ * @param {import("../global_illumination/brick4/Brick4LightMap.js").Brick4LightMap} [options.brick4] the scene's,
+ *   while Brick4 runs
+ * @param {import("../global_illumination/lpv/GPULightProbeVolume.js").GPULightProbeVolume} [options.lpv] the
+ *   scene's, while LPV runs
  * @returns {{Y: number, CoCg: number}} handles of the volume: luma SH2, and chroma in `.rg`
  */
-export function graph_build_froxel_irradiance({ graph, camera, view, lights, light_cluster_data, light_cluster_lookup, light_cluster_parameters, shadowmap_atlas, volumetrics_metadata, resolution, indirect_lighting_mode, shader_switches, }: {
+export function graph_build_froxel_irradiance({ graph, camera, view, lights, light_cluster_data, light_cluster_lookup, light_cluster_parameters, shadowmap_atlas, volumetrics_metadata, resolution, shader_switches, brick4, lpv, }: {
     graph: import("../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph;
     camera: import("../camera/GPUCameraContext.js").GPUCameraContext;
     view: import("../view/GPUViewContext.js").GPUViewContext;
@@ -34,8 +37,9 @@ export function graph_build_froxel_irradiance({ graph, camera, view, lights, lig
     shadowmap_atlas: number;
     volumetrics_metadata: number;
     resolution: number[];
-    indirect_lighting_mode: import("../ShadeIndirectLightingMode.js").ShadeIndirectLightingMode;
     shader_switches?: ShaderSwitchSet;
+    brick4?: import("../global_illumination/brick4/Brick4LightMap.js").Brick4LightMap;
+    lpv?: import("../global_illumination/lpv/GPULightProbeVolume.js").GPULightProbeVolume;
 }): {
     Y: number;
     CoCg: number;

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

@@ -1 +1 @@
-{"version":3,"file":"graph_build_froxel_irradiance.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/volumetrics/graph_build_froxel_irradiance.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH;IAfmG,KAAK,EAA7F,OAAO,2DAA2D,EAAE,UAAU;IACZ,MAAM,EAAxE,OAAO,+BAA+B,EAAE,gBAAgB;IACI,IAAI,EAAhE,OAAO,2BAA2B,EAAE,cAAc;IACmB,MAAM,EAA3E,OAAO,gCAAgC,EAAE,kBAAkB;IAC3C,kBAAkB,EAAlC,MAAM;IACU,oBAAoB,EAApC,MAAM;IACU,wBAAwB,EAAxC,MAAM;IACU,eAAe,EAA/B,MAAM;IACU,oBAAoB,EAApC,MAAM;IACY,UAAU,EAA5B,MAAM,EAAE;IACqE,sBAAsB,EAAnG,OAAO,iCAAiC,EAAE,yBAAyB;IAEzC,eAAe,GAAzC,eAAe;IACb;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAC,CAmFrC;gCAjH+B,uCAAuC"}
+{"version":3,"file":"graph_build_froxel_irradiance.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/volumetrics/graph_build_froxel_irradiance.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH;IAlBmG,KAAK,EAA7F,OAAO,2DAA2D,EAAE,UAAU;IACZ,MAAM,EAAxE,OAAO,+BAA+B,EAAE,gBAAgB;IACI,IAAI,EAAhE,OAAO,2BAA2B,EAAE,cAAc;IACmB,MAAM,EAA3E,OAAO,gCAAgC,EAAE,kBAAkB;IAC3C,kBAAkB,EAAlC,MAAM;IACU,oBAAoB,EAApC,MAAM;IACU,wBAAwB,EAAxC,MAAM;IACU,eAAe,EAA/B,MAAM;IACU,oBAAoB,EAApC,MAAM;IACY,UAAU,EAA5B,MAAM,EAAE;IACkB,eAAe,GAAzC,eAAe;IAEoE,MAAM,GAAzF,OAAO,iDAAiD,EAAE,cAAc;IAEkB,GAAG,GAA7F,OAAO,mDAAmD,EAAE,mBAAmB;IAE7E;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAC,CAsFrC;gCAvH+B,uCAAuC"}

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

@@ -26,9 +26,12 @@ import { shader_volumetrics_build_irradiance } from "./shader_volumetrics_build_
  * @param {number} options.shadowmap_atlas
  * @param {number} options.volumetrics_metadata where the froxels are
  * @param {number[]} options.resolution the froxel grid
- * @param {import("../ShadeIndirectLightingMode.js").ShadeIndirectLightingMode} options.indirect_lighting_mode which froxel GI
- *   module starts the volume
- * @param {ShaderSwitchSet} [options.shader_switches] the renderer's; the lights' pass is built for them
+ * @param {ShaderSwitchSet} [options.shader_switches] the renderer's; the GI that starts the volume and the
+ *   lights' pass are built for them
+ * @param {import("../global_illumination/brick4/Brick4LightMap.js").Brick4LightMap} [options.brick4] the scene's,
+ *   while Brick4 runs
+ * @param {import("../global_illumination/lpv/GPULightProbeVolume.js").GPULightProbeVolume} [options.lpv] the
+ *   scene's, while LPV runs
  * @returns {{Y: number, CoCg: number}} handles of the volume: luma SH2, and chroma in `.rg`
  */
 export function graph_build_froxel_irradiance({
@@ -42,13 +45,16 @@ export function graph_build_froxel_irradiance({
                                                   shadowmap_atlas,
                                                   volumetrics_metadata,
                                                   resolution,
-                                                  indirect_lighting_mode,
                                                   shader_switches = ShaderSwitchSet.EMPTY,
+                                                  brick4,
+                                                  lpv,
                                               }) {
 
     const gi = graph_build_froxel_gi({
         graph,
-        indirect_lighting_mode,
+        shader_switches,
+        brick4,
+        lpv,
         scene_ctx: view.scene,
         camera,
         volumetrics_metadata,

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

@@ -1 +1 @@
-{"version":3,"file":"graph_build_volumetrics.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/volumetrics/graph_build_volumetrics.js"],"names":[],"mappings":"AA4VA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH;IAtB+B,KAAK;IACC,MAAM;IACJ,MAAM;IACV,IAAI;IACZ,GAAG;IAIH,kBAAkB,EAAlC,MAAM;IACU,oBAAoB,EAApC,MAAM;IACU,wBAAwB,EAAxC,MAAM;IACU,eAAe,EAA/B,MAAM;IACY,qBAAqB,EAAvC,MAAM,EAAE;IACU,qBAAqB,EAAvC,MAAM,EAAE;IAGQ,oBAAoB,EAApC,MAAM;IACW,WAAW,GAA5B,MAAM;IACW,UAAU,GAA3B,MAAM;IACqB,eAAe;IAChB,eAAe,GAAzC,eAAe;;;;;;EAiLzB;gCApiB+B,uCAAuC"}
+{"version":3,"file":"graph_build_volumetrics.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/volumetrics/graph_build_volumetrics.js"],"names":[],"mappings":"AAwWA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH;IAtB+B,KAAK;IACC,MAAM;IACJ,MAAM;IACV,IAAI;IACZ,GAAG;IAIH,kBAAkB,EAAlC,MAAM;IACU,oBAAoB,EAApC,MAAM;IACU,wBAAwB,EAAxC,MAAM;IACU,eAAe,EAA/B,MAAM;IACY,qBAAqB,EAAvC,MAAM,EAAE;IACU,qBAAqB,EAAvC,MAAM,EAAE;IAGQ,oBAAoB,EAApC,MAAM;IACW,WAAW,GAA5B,MAAM;IACW,UAAU,GAA3B,MAAM;IACqB,eAAe;IAChB,eAAe,GAAzC,eAAe;;;;;;EAkLzB;gCAjjB+B,uCAAuC"}

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

@@ -8,6 +8,7 @@ import { graph_import_texture } from "../shader/graph/graph_import_texture.js";
 import { SHADOWMAP_COMPARE_SAMPLER_DESCRIPTOR } from "../shadow/map/SHADOWMAP_COMPARE_SAMPLER_DESCRIPTOR.js";
 import { STATIC_GRAPHICS_ENGINE_ASSETS } from "../STATIC_GRAPHICS_ENGINE_ASSETS.js";
 import { DEFAULT_RENDER_TARGET_VIEW_DESCRIPTOR } from "../texture/DEFAULT_RENDER_TARGET_VIEW_DESCRIPTOR.js";
+import { WIND_FIELD_UNIFORM } from "../wind/WIND_FIELD_UNIFORM.js";
 import { volumetrics_sun_shadow_texture_name } from "./chunk_volumetrics_sun_optical_depth.js";
 import { PARTICIPATING_MEDIA_NOISE_SAMPLER_DESCRIPTOR } from "./noise/PARTICIPATING_MEDIA_NOISE.js";
 import { shader_volumetrics_build_lighting } from "./shader_volumetrics_build_lighting.js";
@@ -33,6 +34,7 @@ import {
  * @param {GPUViewContext} options.view
  * @param {number} options.volumetrics_metadata
  * @param {number[]} options.resolution output resolution
+ * @param {ShaderSwitchSet} options.shader_switches the renderer's; the build adds the wind field's shape
  */
 function graph_integrate_participating_media({
                                                  graph,
@@ -41,6 +43,7 @@ function graph_integrate_participating_media({
                                                  view,
                                                  volumetrics_metadata,
                                                  resolution,
+                                                 shader_switches,
                                              }) {
 
     const data = {};
@@ -79,22 +82,31 @@ function graph_integrate_participating_media({
             // the per-froxel point the noise is read at moves by this volume every frame
             const tSTBN_vec3 = context.graphics.textures.obtain(STATIC_GRAPHICS_ENGINE_ASSETS.stbn_vec3);
 
-            shader_volumetrics_build_participating_media.dispatchThreads({
+            const bindings = {
+                camera: camera.buffer.buffer,
+                view: view.uniform_buffer.buffer,
+                volumetrics_metadata,
+                scene_database: scene.scene_database_buffer,
+                tSTBN_vec3: tSTBN_vec3.obtainView(),
+                tParticipatingMediaNoise: noise_atlas.obtainView(),
+                sParticipatingMediaNoise: context.graphics.samplers.obtain(PARTICIPATING_MEDIA_NOISE_SAMPLER_DESCRIPTOR),
+                tOutput0: output0.obtainView(DEFAULT_RENDER_TARGET_VIEW_DESCRIPTOR),
+                tOutput1: output1.obtainView(DEFAULT_RENDER_TARGET_VIEW_DESCRIPTOR),
+            };
+
+            // taken this frame rather than held: a producer that grows the field replaces its atlas
+            scene.wind.bind(bindings);
+
+            // and read in the shape it has this frame: with no cascades the wind is the far field
+            // everywhere, and that variant links neither the cascades' read nor the noise's flow map
+            const switches = shader_switches.with(WIND_FIELD_UNIFORM, scene.wind.cascade_count === 0);
+
+            shader_volumetrics_build_participating_media.variant(switches).dispatchThreads({
                 encoder,
                 thread_count_x: output0.width,
                 thread_count_y: output0.height,
                 thread_count_z: output0.depth,
-                bindings: {
-                    camera: camera.buffer.buffer,
-                    view: view.uniform_buffer.buffer,
-                    volumetrics_metadata,
-                    scene_database: scene.scene_database_buffer,
-                    tSTBN_vec3: tSTBN_vec3.obtainView(),
-                    tParticipatingMediaNoise: noise_atlas.obtainView(),
-                    sParticipatingMediaNoise: context.graphics.samplers.obtain(PARTICIPATING_MEDIA_NOISE_SAMPLER_DESCRIPTOR),
-                    tOutput0: output0.obtainView(DEFAULT_RENDER_TARGET_VIEW_DESCRIPTOR),
-                    tOutput1: output1.obtainView(DEFAULT_RENDER_TARGET_VIEW_DESCRIPTOR),
-                }
+                bindings,
             });
 
 
@@ -416,6 +428,7 @@ export function graph_build_volumetrics({
         resolution: volumetric_resolution,
         volumetrics_metadata,
         camera,
+        shader_switches,
     });
 
     const sun_shadow_cascades = graph_build_sun_shadow_volume({