@woosh/meep-engine 3.53.0 → 3.54.0

package/src/shade/renderer/volumetrics/irradiance_clipmap/shader_irradiance_clipmap_build.js

@@ -0,0 +1,191 @@
+import { CAMERA_UNIFORM_STRUCT } from "../../camera/CAMERA_UNIFORM_STRUCT.js";
+import { INDIRECT_LIGHT_INTENSITY } from "../../deferred/INDIRECT_LIGHT_INTENSITY.js";
+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 { chunk_light_cluster_counts } from "../../light/cluster/chunk_light_cluster_counts.js";
+import { LIGHT_CLUSTER_LOOKUP_STRUCT } from "../../light/cluster/shader_cluster_assign_lights.js";
+import { ENVIRONMENT_SH_TYPE } from "../../light/environment/shader_project_environment_sh.js";
+import { chunk_world_light_cluster_lookup } from "../../light/world_cluster/chunk_world_light_cluster_lookup.js";
+import { chunk_mat4_extract_position } from "../../shader/chunk/geometry/mat4/chunk_mat4_extract_position.js";
+import {
+    chunk_directional_lights_iteration_mask
+} from "../../shader/chunk/light/io/chunk_directional_lights_iteration_mask.js";
+import {
+    chunk_get_directional_light_info_by_index
+} from "../../shader/chunk/light/io/chunk_get_directional_light_info_by_index.js";
+import {
+    METRO_L1_IRRADIANCE_STRUCT
+} from "../../shader/chunk/spherical_harmonics/l1i/chunk_convert_to_irradiance_sh.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { ComputeShader } from "../../shader/ComputeShader.js";
+import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
+import { f32, i32, u32, vec3i, vec3u } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
+import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
+import { chunk_shadowmap_get_light_visibility } from "../../shadow/map/shader/chunk_shadowmap_get_light_visibility.js";
+import { SHADOWMAP_COMPARE_SAMPLER_DESCRIPTOR } from "../../shadow/map/SHADOWMAP_COMPARE_SAMPLER_DESCRIPTOR.js";
+import { chunk_volumetrics_irradiance_sh } from "../chunk_volumetrics_irradiance_sh.js";
+import { chunk_volumetrics_local_light_shadow } from "../chunk_volumetrics_local_light_shadow.js";
+import { chunk_irradiance_clipmap_gi_sample } from "./chunk_irradiance_clipmap_gi_sample.js";
+import { chunk_irradiance_clipmap_local_light } from "./chunk_irradiance_clipmap_local_light.js";
+import {
+    IRRADIANCE_CLIPMAP_LIGHT_BUDGET,
+    IRRADIANCE_CLIPMAP_TILE_FORMAT,
+} from "./IRRADIANCE_CLIPMAP.js";
+
+export const IRRADIANCE_CLIPMAP_BUILD_GROUP_SIZE = Object.freeze([4, 4, 4]);
+
+export const IRRADIANCE_CLIPMAP_BUILD_STRUCT = WebGPUStruct.from({
+    tile_origin: vec3u,
+    cascade_index: u32,
+    corner: vec3i,
+    cell_size: f32,
+    tile_size: vec3u,
+    border: i32,
+}, "IrradianceClipmapBuild");
+
+const resources = new ShaderResourceSetDescriptor();
+
+resources.createGroup()
+    .addUniform("build_settings", IRRADIANCE_CLIPMAP_BUILD_STRUCT)
+    .addUniform("camera", CAMERA_UNIFORM_STRUCT)
+    .addUniform("environment_sh", ENVIRONMENT_SH_TYPE)
+    .addStorageBuffer("brick4", BRICK4_DATA_STRUCT, false, true)
+    .addStorageBuffer("light_data", WebGPUArray.u32, false)
+    .addStorageBuffer("world_cluster_lookup", LIGHT_CLUSTER_LOOKUP_STRUCT, false)
+    .addStorageBuffer("world_cluster_data", WebGPUArray.u32, false)
+    .addTexture("shadowmapAtlas", "depth")
+    .addSampler("sCompareLinear", "comparison", SHADOWMAP_COMPARE_SAMPLER_DESCRIPTOR)
+    .addStorageTexture("atlas_y", IRRADIANCE_CLIPMAP_TILE_FORMAT, "3d", "write-only")
+    .addStorageTexture("atlas_cocg", IRRADIANCE_CLIPMAP_TILE_FORMAT, "3d", "write-only");
+
+resources.addGroup(LPV_SHADER_RESOURCE_GROUP_WITH_DEFAULTS);
+
+const body = CodeChunk.from(
+    //language=WGSL
+    `
+@compute @workgroup_size(${IRRADIANCE_CLIPMAP_BUILD_GROUP_SIZE.join(", ")})
+fn main(@builtin(global_invocation_id) local_texel: vec3<u32>) {
+    let tile_size = build_settings.tile_size;
+    if (any(local_texel >= tile_size)) {
+        return;
+    }
+
+    let local_cell = vec3<i32>(local_texel) - vec3<i32>(build_settings.border);
+    let world_cell = build_settings.corner + local_cell;
+    let position_ws = (vec3<f32>(world_cell) + vec3<f32>(0.5)) * build_settings.cell_size;
+
+    const INDIRECT_INTENSITY: f32 = ${INDIRECT_LIGHT_INTENSITY};
+    let gi_radiance = irradiance_clipmap_gi_sample(position_ws);
+    let scaled_gi = array<vec3<f32>, 4>(
+        gi_radiance[0] * INDIRECT_INTENSITY,
+        gi_radiance[1] * INDIRECT_INTENSITY,
+        gi_radiance[2] * INDIRECT_INTENSITY,
+        gi_radiance[3] * INDIRECT_INTENSITY,
+    );
+
+    var irradiance: ${METRO_L1_IRRADIANCE_STRUCT.wgsl_ref};
+    irradiance = volumetrics_irradiance_sh_add_radiance(irradiance, scaled_gi);
+
+    let to_camera = mat4_extract_position(camera.transform) - position_ws;
+    let to_camera_len = max(length(to_camera), 1e-5);
+    let toward_camera = to_camera / to_camera_len;
+
+    var directional_bits = directional_lights_iteration_mask(&light_data);
+    while (directional_bits != 0u) {
+        let directional_index = countTrailingZeros(directional_bits);
+        directional_bits &= ~(1u << directional_index);
+
+        let sun = get_directional_light_info_by_index(&light_data, directional_index);
+
+        let shadow_term = shadowmap_get_directional_light_visibility(
+            &light_data,
+            directional_index,
+            position_ws,
+            toward_camera,
+            sun.direction
+        );
+
+        irradiance = volumetrics_irradiance_sh_add(irradiance, shadow_term * sun.color, sun.direction);
+    }
+
+    let cluster_meta = world_light_cluster_metadata_by_texel(
+        build_settings.cascade_index,
+        local_texel,
+        tile_size
+    );
+
+    let cluster_offset = cluster_meta.offset;
+    let point_count = light_cluster_count_point(cluster_meta.counts);
+    let spot_count = light_cluster_count_spot(cluster_meta.counts);
+
+    for (var j = 0u; j < min(point_count, ${IRRADIANCE_CLIPMAP_LIGHT_BUDGET}u); j++) {
+        let light_index = world_cluster_data[cluster_offset + j];
+        let direct_light = irradiance_clipmap_get_point_light_info_by_index(
+            &light_data,
+            light_index,
+            position_ws,
+            build_settings.cell_size
+        );
+
+        if (all(direct_light.color == vec3<f32>(0.0))) {
+            continue;
+        }
+
+        let shadow_term = volumetrics_point_light_shadow(&light_data, light_index, position_ws);
+        irradiance = volumetrics_irradiance_sh_add(irradiance, shadow_term * direct_light.color, direct_light.direction);
+    }
+
+    for (var k = 0u; k < min(spot_count, ${IRRADIANCE_CLIPMAP_LIGHT_BUDGET}u); k++) {
+        let light_index = world_cluster_data[cluster_offset + point_count + k];
+        let direct_light = irradiance_clipmap_get_spot_light_info_by_index(
+            &light_data,
+            light_index,
+            position_ws,
+            build_settings.cell_size
+        );
+
+        if (all(direct_light.color == vec3<f32>(0.0))) {
+            continue;
+        }
+
+        let shadow_term = volumetrics_spot_light_shadow(&light_data, light_index, position_ws);
+        irradiance = volumetrics_irradiance_sh_add(irradiance, shadow_term * direct_light.color, direct_light.direction);
+    }
+
+    let stored = volumetrics_irradiance_sh_storable(irradiance);
+    let atlas_texel = build_settings.tile_origin + local_texel;
+
+    textureStore(atlas_y, atlas_texel, stored.Y);
+    textureStore(atlas_cocg, atlas_texel, vec4<f32>(stored.CoCg, 0.0, 0.0));
+}
+`, [
+        METRO_L1_IRRADIANCE_STRUCT.declaration_chunk,
+        chunk_mat4_extract_position,
+        chunk_irradiance_clipmap_gi_sample,
+        chunk_world_light_cluster_lookup,
+        chunk_light_cluster_counts,
+        chunk_directional_lights_iteration_mask,
+        chunk_get_directional_light_info_by_index,
+        chunk_irradiance_clipmap_local_light,
+        chunk_shadowmap_get_light_visibility,
+        chunk_volumetrics_local_light_shadow,
+        chunk_volumetrics_irradiance_sh,
+    ]
+);
+
+/**
+ * Populates one cascade's tile (including its 1-texel trilinear skirt) in the synchronized `Y` and
+ * `CoCg` 3D tile atlases of the world-space irradiance clipmap.
+ *
+ * Evaluates indirect lighting (`INDIRECT_LIGHTING`), directional lights (`SHADOW_DIRECTIONAL_TECHNIQUE`),
+ * and world-space clustered point and spot lights with shadow maps at deterministic world-space
+ * voxel centres.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_irradiance_clipmap_build = ComputeShader.from({
+    label: "Volumetrics / irradiance clipmap build",
+    resources,
+    body,
+});

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

@@ -0,0 +1,16 @@
+export const VOLUMETRICS_CLASSIFY_WORKGROUP_RESOLUTION: readonly number[];
+/**
+ * Classifies every froxel of the volumetric grid into one of the three lighting regimes (Decision 4.2)
+ * using subgroup-coalesced appends ({@link chunk_collection_u32_append}):
+ *
+ * 1. `list_clipmap` — froxels fully inside the world-space irradiance clipmap (`c < count - 1`, or
+ *    `c == count - 1` with `edge_weight == 0`).
+ * 2. `list_blended` — froxels in the outer transition band of the coarsest cascade (`c == count - 1`
+ *    with `edge_weight > 0`), where clipmap irradiance blends into the far-field lighting.
+ * 3. `list_far_field` — froxels outside all cascades (`CLIPMAP_LEVEL_NONE`).
+ *
+ * @type {ComputeShader}
+ */
+export const shader_volumetrics_classify_froxels: ComputeShader;
+import { ComputeShader } from "../shader/ComputeShader.js";
+//# sourceMappingURL=shader_volumetrics_classify_froxels.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"shader_volumetrics_classify_froxels.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/volumetrics/shader_volumetrics_classify_froxels.js"],"names":[],"mappings":"AAgBA,0EAAkF;AAyDlF;;;;;;;;;;;GAWG;AACH,kDAFU,aAAa,CAMpB;8BApF2B,4BAA4B"}

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

@@ -0,0 +1,23 @@
+/**
+ * Workgroup size (64 threads) used by each of the 3 volumetric lighting regime dispatches.
+ * @type {number}
+ */
+export const VOLUMETRICS_REGIME_WORKGROUP_SIZE: number;
+/**
+ * Evaluates far-field in-scattering at a froxel sample (`VolumetricsFroxelSample`) using the same
+ * full irradiance model as the world-space irradiance clipmap (environment GI + directional lights
+ * with atmospheric transmittance and multiple scattering, evaluated through
+ * `irradiance_clipmap_sh_multiscattering`).
+ *
+ * Shared as a first-class {@link CodeChunk} between `shader_volumetrics_lighting_blended` and
+ * `shader_volumetrics_lighting_far_field`.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_volumetrics_far_field_directional: CodeChunk;
+export const shader_volumetrics_lighting_clipmap: ComputeShader;
+export const shader_volumetrics_lighting_blended: ComputeShader;
+export const shader_volumetrics_lighting_far_field: ComputeShader;
+import { CodeChunk } from "../shader/compiler/CodeChunk.js";
+import { ComputeShader } from "../shader/ComputeShader.js";
+//# sourceMappingURL=shader_volumetrics_lighting_regimes.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"shader_volumetrics_lighting_regimes.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/volumetrics/shader_volumetrics_lighting_regimes.js"],"names":[],"mappings":"AA+CA;;;GAGG;AACH,gDAFU,MAAM,CAEoC;AAEpD;;;;;;;;;;GAUG;AACH,sDAFU,SAAS,CA6FjB;AAwFF,gEAIG;AAuFH,gEAIG;AA2DH,kEAIG;0BAhYuB,iCAAiC;8BAC7B,4BAA4B"}

package/src/shade/renderer/wind/GPUSceneWind.d.ts

@@ -42,7 +42,7 @@ export class GPUSceneWind {
      * @param {number} capacity
      * @returns {GPUTileAtlas3D}
      */
-    static "__#172@#make_atlas"(device: GPUDevice, content: ArrayLike<number>, capacity: number): GPUTileAtlas3D;
+    static "__#161@#make_atlas"(device: GPUDevice, content: ArrayLike<number>, capacity: number): GPUTileAtlas3D;
     /**
      * @param {GPUDevice} device
      */

package/src/shade/renderer/wind/GPUSceneWind.js

@@ -126,7 +126,7 @@ export class GPUSceneWind {
 
         return new GPUTileAtlas3D({
             device,
-            format: WIND_FIELD_TILE_FORMAT,
+            formats: [WIND_FIELD_TILE_FORMAT],
             // copied by the atlas; made only when the atlas is
             content_size: [content[0], content[1], content[2]],
             border: WIND_FIELD_TILE_BORDER,

package/src/engine/graphics3/decal/DecalAtlasFill.js

@@ -1,32 +0,0 @@
-/**
- * How a decal atlas fills the border around a patch.
- *
- * Two rules rather than one, because the correct fill depends on what the channel means and getting
- * it wrong shows up only once the mip chain is built.
- *
- * @enum {number}
- */
-export const DecalAtlasFill = {
-    /**
-     * Colour weighted by coverage, and a gutter of nothing.
-     *
-     * The patch is stored **premultiplied** and its border is zero. Averaging that pair down a mip
-     * chain gives premultiplied colour times coverage at every level, which is what a decal fading
-     * out at its edge should look like. The same arrangement in *straight* alpha is where dark
-     * halos come from — an edge texel averaged against transparent black keeps its alpha and loses
-     * its colour — and straight alpha beside a zeroed gutter is exactly what the atlas this
-     * replaces has today.
-     */
-    PremultipliedCoverage: 0,
-
-    /**
-     * The nearest content texel, repeated outward.
-     *
-     * For channels that carry no coverage of their own — a normal, a roughness, a metalness — there
-     * is nothing to fade toward, and a zeroed gutter would drag a partially covered mip texel toward
-     * a meaningless value (a zero normal, mirror-smooth roughness). Coverage for these comes from
-     * the albedo's alpha, so their border repeats the edge and lets the mip chain average content
-     * against more of the same.
-     */
-    EdgeExtend: 1,
-};

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

@@ -1,49 +0,0 @@
-import { chunk_cluster_depth_from_z_slice } from "../../light/cluster/chunk_cluster_depth_from_z_slice.js";
-import { chunk_camera_ray_from_uv } from "../../shader/chunk/geometry/ray/chunk_camera_ray_from_uv.js";
-import { RAY_STRUCT } from "../../shader/chunk/geometry/ray/RAY_STRUCT.js";
-import { chunk_texel_coordinate_to_uv } from "../../shader/chunk/texture/chunk_texel_coordinate_to_uv.js";
-import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
-import { chunk_camera_ray_planar_depth_scale } from "../chunk_camera_ray_planar_depth_scale.js";
-import { chunk_volumetrics_froxel_content_offset } from "../chunk_volumetrics_froxel_content_offset.js";
-import { CAMERA_RESOURCE } from "../../camera/CAMERA_RESOURCE.js";
-import { VOLUMETRICS_METADATA_RESOURCE } from "../VOLUMETRICS_RESOURCES.js";
-
-/**
- * `volumetrics_froxel_centre_ws(voxel, resolution)` — the world position a froxel's value stands for:
- * its column's centre, at the depth its slab's content sits at (`volumetrics_froxel_content_offset`),
- * which is where the lighting pass's jittered samples average to and where
- * `volumetrics_position_world_to_froxel_uvw` puts the froxel's texel centre. A froxel GI module
- * whose answer depends on position asks it there; GI is smooth enough across a froxel that one
- * sample is all of it.
- *
- * The enclosing shader binds `camera` and `volumetrics_metadata` under those names.
- *
- * @type {CodeChunk}
- */
-export const chunk_volumetrics_froxel_centre_ws = CodeChunk.from(
-    //language=WGSL
-    `
-fn volumetrics_froxel_centre_ws(voxel: vec3<u32>, resolution: vec3<u32>) -> vec3<f32> {
-    let curve = volumetrics_metadata.froxel_cluster_parameters;
-    let near_far = camera.clip_near_far;
-
-    let slice = f32(voxel.z) + volumetrics_froxel_content_offset(curve.z);
-    let view_depth = clamp(cluster_depth_from_z_slice(slice, curve, f32(resolution.z)), near_far.x, near_far.y);
-
-    let ray = camera_ray_from_uv(texel_coordinate_to_uv(vec2<f32>(voxel.xy), resolution.xy), camera);
-
-    // planar depth to a distance along the ray, as the lighting pass does
-    return ray.origin + ray.direction * (view_depth * camera_ray_planar_depth_scale(ray.direction, camera));
-}
-`, [
-        RAY_STRUCT.declaration_chunk,
-        chunk_volumetrics_froxel_content_offset,
-        chunk_cluster_depth_from_z_slice,
-        chunk_camera_ray_from_uv,
-        chunk_texel_coordinate_to_uv,
-        chunk_camera_ray_planar_depth_scale,
-    ]
-);
-
-chunk_volumetrics_froxel_centre_ws.requireResource(CAMERA_RESOURCE);
-chunk_volumetrics_froxel_centre_ws.requireResource(VOLUMETRICS_METADATA_RESOURCE);

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

@@ -1,50 +0,0 @@
-import {
-    METRO_L1_IRRADIANCE_STRUCT
-} from "../../shader/chunk/spherical_harmonics/l1i/chunk_convert_to_irradiance_sh.js";
-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";
-
-/**
- * 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_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.
- *
- * @type {CodeChunk}
- */
-export const chunk_volumetrics_gi = CodeChunk.from(
-    //language=WGSL
-    `
-fn volumetrics_gi_store(voxel: vec3<u32>, radiance: array<vec3<f32>, 4>) {
-    const INDIRECT_INTENSITY : f32 = ${INDIRECT_LIGHT_INTENSITY};
-
-    let scaled = array<vec3<f32>, 4>(
-        radiance[0] * INDIRECT_INTENSITY,
-        radiance[1] * INDIRECT_INTENSITY,
-        radiance[2] * INDIRECT_INTENSITY,
-        radiance[3] * INDIRECT_INTENSITY,
-    );
-
-    var sh: ${METRO_L1_IRRADIANCE_STRUCT.wgsl_ref};
-
-    let stored = volumetrics_irradiance_sh_storable(volumetrics_irradiance_sh_add_radiance(sh, scaled));
-
-    textureStore(tGIY, voxel, stored.Y);
-    textureStore(tGICoCg, voxel, vec4<f32>(stored.CoCg, 0.0, 0.0));
-}
-`, [
-        METRO_L1_IRRADIANCE_STRUCT.declaration_chunk,
-        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.js

@@ -1,105 +0,0 @@
-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.js

@@ -1,80 +0,0 @@
-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 { 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. 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 {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,
-                                          shader_switches = ShaderSwitchSet.EMPTY,
-                                          scene_ctx,
-                                          brick4,
-                                          lpv,
-                                          camera,
-                                          volumetrics_metadata,
-                                          resolution,
-                                      }) {
-    const volume = () => TextureResourceDescriptor.from({
-        resolution,
-        dimension: "3d",
-        format: "rgba16float",
-        usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING
-    });
-
-    const bindings = {
-        volumetrics_metadata,
-        camera: graph_import_buffer(graph, camera.buffer.buffer, "froxel gi camera"),
-        tGIY: volume(),
-        tGICoCg: volume(),
-        environment_sh: scene_ctx.lights.environment_sh,
-    };
-
-    // 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;
-    }
-
-    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_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]),
-            Math.ceil(resolution[2] / VOLUMETRICS_GI_WORKGROUP_RESOLUTION[2]),
-        ],
-        bindings,
-    });
-
-    return {
-        Y: outputs.tGIY,
-        CoCg: outputs.tGICoCg,
-    };
-}

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

@@ -1,51 +0,0 @@
-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,
-});