@woosh/meep-engine 3.42.0 → 3.43.0

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

@@ -2,10 +2,11 @@
  * The froxel irradiance volume: the light a transparent surface standing in a froxel receives, for
  * surfaces the lighting pass cannot see — the particles. The froxel GI stage (`gi/`) starts it with
  * whatever the renderer's indirect lighting mode says a point there receives — the environment,
- * Brick4, the light probe volume — and `shader_volumetrics_build_lighting` adds, in the same loop
- * that lights the fog, every directional, point and spot light, their shadows, and the fog's own
- * attenuation toward each light. idTech 8 builds the same thing in the same pass ("Froxels
- * Irradiance Volume", Sousa, SIGGRAPH 2025, p.29).
+ * Brick4, the light probe volume — and `shader_volumetrics_build_irradiance` adds every directional,
+ * point and spot light with its shadow. idTech 8 builds the same volume ("Froxels Irradiance Volume",
+ * Sousa, SIGGRAPH 2025, p.29), in the pass that lights its fog; here it has a pass of its own and no
+ * fog in it, so a particle is lit as the surfaces beside it are, and the volume costs the same with
+ * or without participating media.
  *
  * Stored in the Metro Exodus L1 encoding (`l1i/`): luma as SH2 — four coefficients — and chroma as
  * its constant band only. Two lights of different colours from opposite sides therefore light both

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

@@ -1 +1 @@
-{"version":3,"file":"chunk_volumetrics_irradiance_sh.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/volumetrics/chunk_volumetrics_irradiance_sh.js"],"names":[],"mappings":"AASA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,8CAFU,SAAS,CA+DjB;0BAnGwB,iCAAiC"}
+{"version":3,"file":"chunk_volumetrics_irradiance_sh.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/volumetrics/chunk_volumetrics_irradiance_sh.js"],"names":[],"mappings":"AASA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,8CAFU,SAAS,CA+DjB;0BApGwB,iCAAiC"}

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

@@ -11,10 +11,11 @@ import { CodeChunk } from "../shader/compiler/CodeChunk.js";
  * The froxel irradiance volume: the light a transparent surface standing in a froxel receives, for
  * surfaces the lighting pass cannot see — the particles. The froxel GI stage (`gi/`) starts it with
  * whatever the renderer's indirect lighting mode says a point there receives — the environment,
- * Brick4, the light probe volume — and `shader_volumetrics_build_lighting` adds, in the same loop
- * that lights the fog, every directional, point and spot light, their shadows, and the fog's own
- * attenuation toward each light. idTech 8 builds the same thing in the same pass ("Froxels
- * Irradiance Volume", Sousa, SIGGRAPH 2025, p.29).
+ * Brick4, the light probe volume — and `shader_volumetrics_build_irradiance` adds every directional,
+ * point and spot light with its shadow. idTech 8 builds the same volume ("Froxels Irradiance Volume",
+ * Sousa, SIGGRAPH 2025, p.29), in the pass that lights its fog; here it has a pass of its own and no
+ * fog in it, so a particle is lit as the surfaces beside it are, and the volume costs the same with
+ * or without participating media.
  *
  * Stored in the Metro Exodus L1 encoding (`l1i/`): luma as SH2 — four coefficients — and chroma as
  * its constant band only. Two lights of different colours from opposite sides therefore light both

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

@@ -2,7 +2,7 @@
  * 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_lighting` adds the lights to it.
+ * 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.
  *
  * `volumetrics_froxel_centre_ws` (`chunk_volumetrics_froxel_centre_ws`) says where a froxel is, for a

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

@@ -9,7 +9,7 @@ import { chunk_volumetrics_irradiance_sh } from "../chunk_volumetrics_irradiance
  * 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_lighting` adds the lights to it.
+ * 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.
  *
  * `volumetrics_froxel_centre_ws` (`chunk_volumetrics_froxel_centre_ws`) says where a froxel is, for a

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

@@ -1,6 +1,6 @@
 /**
  * The froxel GI stage: the renderer's indirect lighting at every froxel, as the froxel irradiance
- * volume encodes light, for `shader_volumetrics_build_lighting` to add the lights to. One module per
+ * 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.
  *

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

@@ -9,7 +9,7 @@ import { VOLUMETRICS_GI_WORKGROUP_RESOLUTION } from "./volumetrics_gi_resources.
 
 /**
  * The froxel GI stage: the renderer's indirect lighting at every froxel, as the froxel irradiance
- * volume encodes light, for `shader_volumetrics_build_lighting` to add the lights to. One module per
+ * 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.
  *

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

@@ -0,0 +1,41 @@
+/**
+ * The froxel irradiance volume (`chunk_volumetrics_irradiance_sh`), what lit particles are lit by: the
+ * froxel GI stage (`gi/graph_build_froxel_gi`), then every light with its shadow on top of it
+ * (`shader_volumetrics_build_irradiance`).
+ *
+ * Nothing here reads the fog. The volume is the same with or without participating media, and the
+ * two passes run only when something reads what they write — the frame graph culls them otherwise,
+ * which is the frame with no lit particle in it.
+ *
+ * @param {Object} options
+ * @param {import("../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph} options.graph
+ * @param {import("../camera/GPUCameraContext.js").GPUCameraContext} options.camera
+ * @param {import("../view/GPUViewContext.js").GPUViewContext} options.view
+ * @param {import("../light/GPULightCollection.js").GPULightCollection} options.lights
+ * @param {number} options.light_cluster_data
+ * @param {number} options.light_cluster_lookup
+ * @param {number} options.light_cluster_parameters
+ * @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
+ * @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, }: {
+    graph: import("../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph;
+    camera: import("../camera/GPUCameraContext.js").GPUCameraContext;
+    view: import("../view/GPUViewContext.js").GPUViewContext;
+    lights: import("../light/GPULightCollection.js").GPULightCollection;
+    light_cluster_data: number;
+    light_cluster_lookup: number;
+    light_cluster_parameters: number;
+    shadowmap_atlas: number;
+    volumetrics_metadata: number;
+    resolution: number[];
+    indirect_lighting_mode: import("../ShadeIndirectLightingMode.js").ShadeIndirectLightingMode;
+}): {
+    Y: number;
+    CoCg: number;
+};
+//# sourceMappingURL=graph_build_froxel_irradiance.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"graph_build_froxel_irradiance.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/volumetrics/graph_build_froxel_irradiance.js"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH;IAdmG,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;IAEjE;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAC,CAkFrC"}

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

@@ -0,0 +1,112 @@
+import { TextureResourceDescriptor } from "../../device/graph/TextureResourceDescriptor.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 { graph_build_froxel_gi } from "./gi/graph_build_froxel_gi.js";
+import { shader_volumetrics_build_irradiance } from "./shader_volumetrics_build_irradiance.js";
+
+/**
+ * The froxel irradiance volume (`chunk_volumetrics_irradiance_sh`), what lit particles are lit by: the
+ * froxel GI stage (`gi/graph_build_froxel_gi`), then every light with its shadow on top of it
+ * (`shader_volumetrics_build_irradiance`).
+ *
+ * Nothing here reads the fog. The volume is the same with or without participating media, and the
+ * two passes run only when something reads what they write — the frame graph culls them otherwise,
+ * which is the frame with no lit particle in it.
+ *
+ * @param {Object} options
+ * @param {import("../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph} options.graph
+ * @param {import("../camera/GPUCameraContext.js").GPUCameraContext} options.camera
+ * @param {import("../view/GPUViewContext.js").GPUViewContext} options.view
+ * @param {import("../light/GPULightCollection.js").GPULightCollection} options.lights
+ * @param {number} options.light_cluster_data
+ * @param {number} options.light_cluster_lookup
+ * @param {number} options.light_cluster_parameters
+ * @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
+ * @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,
+                                              }) {
+
+    const gi = graph_build_froxel_gi({
+        graph,
+        indirect_lighting_mode,
+        scene_ctx: view.scene,
+        camera,
+        volumetrics_metadata,
+        resolution,
+    });
+
+    const data = {};
+
+    const pass = graph.add(shader_volumetrics_build_irradiance.descriptor.label, data, (data, resources, context) => {
+        const output_Y = resources.get(data.irradiance_Y);
+        const output_CoCg = resources.get(data.irradiance_CoCg);
+
+        // The blue noise the sample is jittered by. Fetched here rather than when the pass is
+        // recorded: the engine's assets arrive at startup, and this is when the pass needs them.
+        const tSTBN_vec3 = context.graphics.textures.obtain(STATIC_GRAPHICS_ENGINE_ASSETS.stbn_vec3);
+
+        shader_volumetrics_build_irradiance.dispatchThreads({
+            encoder: context.encoder,
+            thread_count_x: output_Y.width,
+            thread_count_y: output_Y.height,
+            thread_count_z: output_Y.depth,
+            bindings: {
+                volumetrics_metadata: resources.get(data.volumetrics_metadata),
+                camera: camera.buffer.buffer,
+                view: view.uniform_buffer.buffer,
+                tSTBN_vec3: tSTBN_vec3.obtainView(),
+                tGIY: resources.get(data.gi_Y).obtainView(),
+                tGICoCg: resources.get(data.gi_CoCg).obtainView(),
+                tIrradianceY: output_Y.obtainView(DEFAULT_RENDER_TARGET_VIEW_DESCRIPTOR),
+                tIrradianceCoCg: output_CoCg.obtainView(DEFAULT_RENDER_TARGET_VIEW_DESCRIPTOR),
+
+                light_data: lights.buffer_data,
+                cluster_parameters: resources.get(data.light_cluster_parameters),
+                cluster_lookup: resources.get(data.light_cluster_lookup),
+                cluster_data: resources.get(data.light_cluster_data),
+                shadowmapAtlas: resources.get(data.shadowmap_atlas).obtainView(),
+                sCompareLinear: context.graphics.samplers.obtain(SHADOWMAP_COMPARE_SAMPLER_DESCRIPTOR),
+            },
+        });
+    });
+
+    data.volumetrics_metadata = pass.read(volumetrics_metadata);
+    data.gi_Y = pass.read(gi.Y);
+    data.gi_CoCg = pass.read(gi.CoCg);
+    data.light_cluster_data = pass.read(light_cluster_data);
+    data.light_cluster_lookup = pass.read(light_cluster_lookup);
+    data.light_cluster_parameters = pass.read(light_cluster_parameters);
+    data.shadowmap_atlas = pass.read(shadowmap_atlas);
+
+    const volume = (label) => pass.create(label, TextureResourceDescriptor.from({
+        resolution,
+        dimension: "3d",
+        format: "rgba16float",
+        usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING
+    }));
+
+    data.irradiance_Y = volume("Froxel Irradiance Y");
+    data.irradiance_CoCg = volume("Froxel Irradiance CoCg");
+
+    return {
+        Y: data.irradiance_Y,
+        CoCg: data.irradiance_CoCg,
+    };
+}

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

@@ -1,25 +1,17 @@
 /**
- * Transmittance LUT, then the multiple-scattering LUT that reads it. Exported for
- * `graph_integrate_sky.spec.js`, which pins the dispatch shape and the transient's usage
- * flags -- neither of which the WGSL validity gate can see.
- *
- * @param {Object} options
- * @param {FrameGraph} options.graph
- * @returns {{transmittance_lut: number, multiscatted_lut: number}} resource handles
- */
-export function graph_integrate_sky({ graph }: {
-    graph: FrameGraph;
-}): {
-    transmittance_lut: number;
-    multiscatted_lut: number;
-};
-/**
+ * The fog: participating media -> per-froxel lighting -> ray-marched integration into the aerial LUT
+ * every surface behind it is seen through. Particle lighting is not here — it needs no medium, and
+ * `graph_build_froxel_irradiance` builds it on its own.
  *
  * @param {Object} options
  * @param {FrameGraph} options.graph
  * @param {GPUCameraContext} options.camera
  * @param {GPULightCollection} options.lights
  * @param {GPUViewContext} options.view
+ * @param {GPUSky} options.sky the scene's sky, already {@link GPUSky#update updated}: its two
+ *   persistent LUTs are imported and read, not rebuilt. The sun's transmittance and the multiple
+ *   scattering depend on nothing but the atmosphere's constants, so building them again per frame
+ *   bought the same texels at a cost that was paid whether or not the scene had any fog.
  * @param {number} options.light_cluster_data
  * @param {number} options.light_cluster_lookup
  * @param {number} options.light_cluster_parameters
@@ -29,17 +21,16 @@ export function graph_integrate_sky({ graph }: {
  * `[1, 1, 1]` when the froxels are marching instead, which keeps the passes in the graph without
  * doing any work
  * @param {number} options.volumetrics_metadata
- * @param {import("../ShadeIndirectLightingMode.js").ShadeIndirectLightingMode} options.indirect_lighting_mode which froxel GI module starts the
- *   froxel irradiance volume (`gi/graph_build_froxel_gi`)
  * @param {number} [options.taa_history] imported previous-frame accumulated scattering volume
  * @param {number} [options.taa_output] imported destination for this frame's accumulated scattering volume
  * @param {GPUCameraContext} [options.camera_previous] previous-frame camera, for temporal reprojection
  */
-export function graph_build_volumetrics({ graph, camera, lights, view, light_cluster_data, light_cluster_lookup, light_cluster_parameters, shadowmap_atlas, volumetric_resolution, sun_shadow_resolution, volumetrics_metadata, indirect_lighting_mode, taa_history, taa_output, camera_previous, }: {
+export function graph_build_volumetrics({ graph, camera, lights, view, sky, light_cluster_data, light_cluster_lookup, light_cluster_parameters, shadowmap_atlas, volumetric_resolution, sun_shadow_resolution, volumetrics_metadata, taa_history, taa_output, camera_previous, }: {
     graph: FrameGraph;
     camera: GPUCameraContext;
     lights: GPULightCollection;
     view: GPUViewContext;
+    sky: GPUSky;
     light_cluster_data: number;
     light_cluster_lookup: number;
     light_cluster_parameters: number;
@@ -47,7 +38,6 @@ export function graph_build_volumetrics({ graph, camera, lights, view, light_clu
     volumetric_resolution: number[];
     sun_shadow_resolution: number[];
     volumetrics_metadata: number;
-    indirect_lighting_mode: import("../ShadeIndirectLightingMode.js").ShadeIndirectLightingMode;
     taa_history?: number;
     taa_output?: number;
     camera_previous?: GPUCameraContext;
@@ -55,10 +45,6 @@ export function graph_build_volumetrics({ graph, camera, lights, view, light_clu
     lut_transmittance: number;
     lut_multiple_scattering: number;
     lut_aerial: any;
-    irradiance: {
-        Y: number;
-        CoCg: number;
-    };
     volumetrics_metadata: number;
 };
 //# sourceMappingURL=graph_build_volumetrics.d.ts.map

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":"AA0BA;;;;;;;;GAQG;AACH;IAH+B,KAAK;IACvB;IAAC,iBAAiB,EAAE,MAAM,CAAC;IAAC,gBAAgB,EAAE,MAAM,CAAA;CAAC,CA8DjE;AAoVD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH;IAnB+B,KAAK;IACC,MAAM;IACJ,MAAM;IACV,IAAI;IACZ,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;IACuE,sBAAsB,EAAnG,OAAO,iCAAiC,EAAE,yBAAyB;IAElD,WAAW,GAA5B,MAAM;IACW,UAAU,GAA3B,MAAM;IACqB,eAAe;;;;;;WAjKH,MAAM;cAAQ,MAAM;;;EAyVrE"}
+{"version":3,"file":"graph_build_volumetrics.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/volumetrics/graph_build_volumetrics.js"],"names":[],"mappings":"AA2UA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH;IArB+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;;;;;;EA+KpD"}

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

@@ -1,10 +1,9 @@
 import { assert } from "../../../core/assert.js";
 import { SamplerDescriptor } from "../../descriptor/texture/SamplerDescriptor.js";
 import { TextureResourceDescriptor } from "../../device/graph/TextureResourceDescriptor.js";
-import { shader_multiscatter_lut } from "../atmosphere/shader_multiscatter_lut.js";
-import { shader_transmittance_lut } from "../atmosphere/shader_transmittance_lut.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 { 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";
@@ -17,85 +16,12 @@ import {
     shader_volumetrics_build_sun_shadow_volume_seeded
 } from "./shader_volumetrics_build_sun_shadow_volume.js";
 import { shader_volumetrics_taa } from "./taa/shader_volumetrics_taa.js";
-import { graph_build_froxel_gi } from "./gi/graph_build_froxel_gi.js";
 import {
     VOLUMETRICS_SUN_SHADOW_CASCADE_COUNT,
     VOLUMETRICS_SUN_SHADOW_WORKGROUP_RESOLUTION,
     volumetrics_sun_shadow_sub_steps
 } from "./VOLUMETRICS_SUN_SHADOW_RESOLUTION.js";
 
-/**
- * Transmittance LUT, then the multiple-scattering LUT that reads it. Exported for
- * `graph_integrate_sky.spec.js`, which pins the dispatch shape and the transient's usage
- * flags -- neither of which the WGSL validity gate can see.
- *
- * @param {Object} options
- * @param {FrameGraph} options.graph
- * @returns {{transmittance_lut: number, multiscatted_lut: number}} resource handles
- */
-export function graph_integrate_sky({ graph }) {
-
-    graph.push_scope("integrate sky");
-
-    const t_data = {};
-
-    const t_pass = graph.add("transmittance", t_data, (data, resources, context) => {
-
-        const output = resources.get(data.output);
-
-        const encoder = context.encoder;
-
-        const settings = {
-            steps: 40,
-            // taken off the target being drawn into, so the generator cannot be told a size
-            // the texture does not have
-            resolution: [output.width, output.height],
-        };
-
-        shader_transmittance_lut.draw({
-            encoder: encoder,
-            bindings: {
-                settings
-            },
-            colorAttachments: [{
-                view: output.obtainView(DEFAULT_RENDER_TARGET_VIEW_DESCRIPTOR),
-                loadOp: "clear",
-                storeOp: "store",
-            }]
-        })
-    });
-
-    t_data.output = t_pass.create("transmittance lut", TextureResourceDescriptor.from({
-        resolution: [256, 64],
-        format: "rgba16float",
-        usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.RENDER_ATTACHMENT
-    }));
-
-    // The transient does not exist yet at graph-build time, so the dispatch cannot be
-    // counted off it the way GPUSky does; one local value feeds both instead.
-    const multiscatter_resolution = [32, 32];
-
-    const multiscatter_outputs = graph_compute_pass({
-        graph,
-        shader: shader_multiscatter_lut,
-        // one workgroup per LUT texel, each thread integrating one direction
-        group_count: [multiscatter_resolution[0], multiscatter_resolution[1], 1],
-        bindings: {
-            tSkyLutTransmittance: t_data.output,
-            tSkyLutMultiscatterOut: TextureResourceDescriptor.from({
-                resolution: multiscatter_resolution,
-                format: "rgba16float",
-                usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.STORAGE_BINDING
-            })
-        }
-    });
-
-    graph.pop_scope();
-
-    return { transmittance_lut: t_data.output, multiscatted_lut: multiscatter_outputs.tSkyLutMultiscatterOut };
-}
-
-
 /**
  *
  * @param {Object} options
@@ -291,9 +217,7 @@ function graph_build_sun_shadow_volume({
  * @param view
  * @param camera
  * @param resolution
- * @param {{Y: number, CoCg: number}} gi the froxel GI stage's volume, which the irradiance starts from
- * @returns {{scattering: number, irradiance: {Y: number, CoCg: number}}} the lit scattering volume,
- *   and the froxel irradiance volume: the GI plus the same lights (chunk_volumetrics_irradiance_sh)
+ * @returns {number} the lit scattering volume
  */
 function graph_integrate_light_scattering({
                                               graph,
@@ -311,7 +235,6 @@ function graph_integrate_light_scattering({
                                               view,
                                               camera,
                                               resolution,
-                                              gi,
                                           }) {
 
     const data = {};
@@ -356,10 +279,6 @@ function graph_integrate_light_scattering({
             tParticipatingMedia0: participating_media0.obtainView(),
             tParticipatingMedia1: participating_media1.obtainView(),
             tLighting: output.obtainView(DEFAULT_RENDER_TARGET_VIEW_DESCRIPTOR),
-            tGIY: resources.get(data.gi_Y).obtainView(),
-            tGICoCg: resources.get(data.gi_CoCg).obtainView(),
-            tIrradianceY: resources.get(data.irradiance_Y).obtainView(DEFAULT_RENDER_TARGET_VIEW_DESCRIPTOR),
-            tIrradianceCoCg: resources.get(data.irradiance_CoCg).obtainView(DEFAULT_RENDER_TARGET_VIEW_DESCRIPTOR),
             //
             light_data: lights.buffer_data,
 
@@ -399,9 +318,6 @@ function graph_integrate_light_scattering({
     data.sun_multiple_scattering_lut = pass.read(sun_multiple_scattering_lut);
     data.sun_shadow_cascades = sun_shadow_cascades.map(handle => pass.read(handle));
 
-    data.gi_Y = pass.read(gi.Y);
-    data.gi_CoCg = pass.read(gi.CoCg);
-
     data.output = pass.create("Light Scattering LUT", TextureResourceDescriptor.from({
         resolution,
         dimension: "3d",
@@ -409,37 +325,24 @@ function graph_integrate_light_scattering({
         usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.RENDER_ATTACHMENT
     }));
 
-    data.irradiance_Y = pass.create("Froxel Irradiance Y", TextureResourceDescriptor.from({
-        resolution,
-        dimension: "3d",
-        format: "rgba16float",
-        usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING
-    }));
-
-    data.irradiance_CoCg = pass.create("Froxel Irradiance CoCg", TextureResourceDescriptor.from({
-        resolution,
-        dimension: "3d",
-        format: "rgba16float",
-        usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING
-    }));
-
-    return {
-        scattering: data.output,
-        irradiance: {
-            Y: data.irradiance_Y,
-            CoCg: data.irradiance_CoCg,
-        },
-    };
+    return data.output;
 
 }
 
 /**
+ * The fog: participating media -> per-froxel lighting -> ray-marched integration into the aerial LUT
+ * every surface behind it is seen through. Particle lighting is not here — it needs no medium, and
+ * `graph_build_froxel_irradiance` builds it on its own.
  *
  * @param {Object} options
  * @param {FrameGraph} options.graph
  * @param {GPUCameraContext} options.camera
  * @param {GPULightCollection} options.lights
  * @param {GPUViewContext} options.view
+ * @param {GPUSky} options.sky the scene's sky, already {@link GPUSky#update updated}: its two
+ *   persistent LUTs are imported and read, not rebuilt. The sun's transmittance and the multiple
+ *   scattering depend on nothing but the atmosphere's constants, so building them again per frame
+ *   bought the same texels at a cost that was paid whether or not the scene had any fog.
  * @param {number} options.light_cluster_data
  * @param {number} options.light_cluster_lookup
  * @param {number} options.light_cluster_parameters
@@ -449,8 +352,6 @@ function graph_integrate_light_scattering({
  * `[1, 1, 1]` when the froxels are marching instead, which keeps the passes in the graph without
  * doing any work
  * @param {number} options.volumetrics_metadata
- * @param {import("../ShadeIndirectLightingMode.js").ShadeIndirectLightingMode} options.indirect_lighting_mode which froxel GI module starts the
- *   froxel irradiance volume (`gi/graph_build_froxel_gi`)
  * @param {number} [options.taa_history] imported previous-frame accumulated scattering volume
  * @param {number} [options.taa_output] imported destination for this frame's accumulated scattering volume
  * @param {GPUCameraContext} [options.camera_previous] previous-frame camera, for temporal reprojection
@@ -460,6 +361,7 @@ export function graph_build_volumetrics({
                                             camera,
                                             lights,
                                             view,
+                                            sky,
                                             light_cluster_data,
                                             light_cluster_lookup,
                                             light_cluster_parameters,
@@ -467,19 +369,23 @@ export function graph_build_volumetrics({
                                             volumetric_resolution,
                                             sun_shadow_resolution,
                                             volumetrics_metadata,
-                                            indirect_lighting_mode,
                                             taa_history,
                                             taa_output,
                                             camera_previous,
                                         }) {
 
     assert.defined(view, 'view');
+    assert.defined(sky, 'sky');
+    assert.equal(sky.needs_update, false, 'sky has not been updated, its LUTs hold nothing yet');
     assert.defined(volumetric_resolution, 'volumetric_resolution');
     assert.defined(sun_shadow_resolution, 'sun_shadow_resolution');
 
     graph.push_scope("build volumetrics");
 
-    const { transmittance_lut, multiscatted_lut } = graph_integrate_sky({ graph: graph });
+    // Read-only here, so nothing in this graph orders against a write to either; the sky wrote
+    // them in commands of its own, submitted before this frame's.
+    const transmittance_lut = graph_import_texture(graph, sky.lut_transmittance);
+    const multiscatted_lut = graph_import_texture(graph, sky.lut_multiple_scattering);
 
     const {
         participating_media0,
@@ -501,20 +407,7 @@ export function graph_build_volumetrics({
         resolution: sun_shadow_resolution,
     });
 
-    const gi = graph_build_froxel_gi({
-        graph,
-        indirect_lighting_mode,
-        scene_ctx: view.scene,
-        camera,
-        volumetrics_metadata,
-        resolution: volumetric_resolution,
-    });
-
-    const {
-        scattering: light_scattering_lut,
-        irradiance,
-    } = graph_integrate_light_scattering({
-        gi,
+    const light_scattering_lut = graph_integrate_light_scattering({
         graph,
         resolution: volumetric_resolution,
         camera,
@@ -634,7 +527,6 @@ export function graph_build_volumetrics({
         lut_transmittance: transmittance_lut,
         lut_multiple_scattering: multiscatted_lut,
         lut_aerial: a_data.output,
-        irradiance,
         volumetrics_metadata,
     };
 }

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

@@ -0,0 +1,22 @@
+/**
+ * Workgroup shape of this pass, `[x, y, z]` in froxels, stated to the `@workgroup_size` below and
+ * read back out of it by the dispatch. Flat in z and 64 invocations, for the reasons the fog's
+ * lighting pass gives (`VOLUMETRICS_LIGHTING_WORKGROUP_RESOLUTION`): it walks the same light
+ * clusters, and those are farthest apart along depth.
+ *
+ * @type {number[]}
+ */
+export const VOLUMETRICS_IRRADIANCE_WORKGROUP_RESOLUTION: number[];
+/**
+ * The froxel irradiance volume (`chunk_volumetrics_irradiance_sh`): what a lit particle standing in a
+ * froxel is lit by. Starts from the froxel GI stage's volume and adds every directional, point and
+ * spot light with its shadow, at a point jittered through the froxel every frame.
+ *
+ * Its own pass, not a by-product of the fog's lighting pass: particle lighting needs no medium, so it
+ * runs whether or not the scene has any fog, and the frame graph culls it when nothing reads it.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_volumetrics_build_irradiance: ComputeShader;
+import { ComputeShader } from "../shader/ComputeShader.js";
+//# sourceMappingURL=shader_volumetrics_build_irradiance.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"shader_volumetrics_build_irradiance.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/volumetrics/shader_volumetrics_build_irradiance.js"],"names":[],"mappings":"AAqCA;;;;;;;GAOG;AACH,0DAFU,MAAM,EAAE,CAEmD;AAwKrE;;;;;;;;;GASG;AACH,kDAFU,aAAa,CAMpB;8BA3M2B,4BAA4B"}