@woosh/meep-engine 3.49.0 → 3.50.0

package/src/shade/renderer/postprocess/ssr/resolve/chunk_ssr_add_hit_irradiance.js

@@ -0,0 +1,79 @@
+import { INDIRECT_LIGHTING } from "../../../INDIRECT_LIGHTING.js";
+import { ShadeIndirectLightingMode } from "../../../ShadeIndirectLightingMode.js";
+import { chunk_v3_matrix4_project } from "../../../shader/chunk/geometry/vec3/chunk_v3_matrix4_project.js";
+import { chunk_lpv_sample_irradiance } from "../../../shader/chunk/light/lpv/chunk_lpv_sample_irradiance.js";
+import { RECIPROCAL_PI_DECLARATION } from "../../../shader/chunk/math/RECIPROCAL_PI_DECLARATION.js";
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+import { CodeChunkChoice } from "../../../shader/compiler/CodeChunkChoice.js";
+import { CAMERA_RESOURCE } from "../../../camera/CAMERA_RESOURCE.js";
+import { GBUFFER_ALBEDO_AO_RESOURCE } from "../../../deferred/GBUFFER_RESOURCES.js";
+
+/**
+ * {@link chunk_ssr_add_hit_irradiance} for a mode that adds nothing: the call is empty.
+ * @type {CodeChunk}
+ */
+export const chunk_ssr_add_hit_irradiance_none = CodeChunk.from(
+    //language=WGSL
+    `
+fn ssr_add_hit_irradiance(
+    result: ptr<function, vec3f>,
+    confidence: f32,
+    position_ws: vec3f,
+    hit_position_vs: vec3f,
+    hit_normal_ws: vec3f,
+    hit_coord: vec2u,
+) {
+}
+    `, []);
+
+/**
+ * {@link chunk_ssr_add_hit_irradiance} from the light probe volume: the diffuse light the volume says
+ * the hit surface receives, reflected by its albedo. Reads the LPV's buffers and atlas, `tAlbedoAO`
+ * and `camera`.
+ * @type {CodeChunk}
+ */
+export const chunk_ssr_add_hit_irradiance_lpv = CodeChunk.from(
+    //language=WGSL
+    `
+fn ssr_add_hit_irradiance(
+    result: ptr<function, vec3f>,
+    confidence: f32,
+    position_ws: vec3f,
+    hit_position_vs: vec3f,
+    hit_normal_ws: vec3f,
+    hit_coord: vec2u,
+) {
+    if (confidence > 0.05) {
+        let hit_position_ws = v3_matrix4_project(hit_position_vs, camera.view_matrix_inverse);
+        let hit_direction_ws = normalize(hit_position_ws - position_ws);
+        let hit_irradiance = lpv_sample_irradiance(hit_position_ws, hit_normal_ws, hit_direction_ws);
+        let hit_albedo = textureLoad(tAlbedoAO, hit_coord, 0).rgb;
+        *result += hit_albedo * hit_irradiance * RECIPROCAL_PI;
+    }
+}
+    `, [
+        chunk_lpv_sample_irradiance,
+        chunk_v3_matrix4_project,
+        RECIPROCAL_PI_DECLARATION,
+    ]);
+
+chunk_ssr_add_hit_irradiance_lpv.requireResource(CAMERA_RESOURCE);
+chunk_ssr_add_hit_irradiance_lpv.requireResource(GBUFFER_ALBEDO_AO_RESOURCE);
+
+/**
+ * The indirect light SSR's resolve adds to an on-screen hit, by the renderer's indirect lighting mode
+ * ({@link INDIRECT_LIGHTING}): one diffuse bounce from the light probe volume under LPV, nothing under
+ * the others.
+ *
+ * ```wgsl
+ * fn ssr_add_hit_irradiance(result: ptr<function, vec3f>, confidence, position_ws, hit_position_vs,
+ *     hit_normal_ws, hit_coord: vec2u)
+ * ```
+ *
+ * @type {CodeChunkChoice}
+ */
+export const chunk_ssr_add_hit_irradiance = CodeChunkChoice.from(INDIRECT_LIGHTING);
+
+chunk_ssr_add_hit_irradiance.add(ShadeIndirectLightingMode.IBL, chunk_ssr_add_hit_irradiance_none);
+chunk_ssr_add_hit_irradiance.add(ShadeIndirectLightingMode.Brick4, chunk_ssr_add_hit_irradiance_none);
+chunk_ssr_add_hit_irradiance.add(ShadeIndirectLightingMode.LPV, chunk_ssr_add_hit_irradiance_lpv);

package/src/shade/renderer/postprocess/ssr/resolve/chunk_ssr_sample_radiance.d.ts

@@ -0,0 +1,30 @@
+/**
+ * {@link chunk_ssr_sample_radiance} from the environment map. Reads `tEnvironment`.
+ * @type {CodeChunk}
+ */
+export const chunk_ssr_sample_radiance_ibl: CodeChunk;
+/**
+ * {@link chunk_ssr_sample_radiance} from Brick4's probes, jittered per pixel and frame. Reads `brick4`,
+ * `tSTBN_vec2` and the resolve's `settings.frame_index`.
+ * @type {CodeChunk}
+ */
+export const chunk_ssr_sample_radiance_brick4: CodeChunk;
+/**
+ * {@link chunk_ssr_sample_radiance} from the light probe volume. Reads the LPV's buffers and its atlas.
+ * @type {CodeChunk}
+ */
+export const chunk_ssr_sample_radiance_lpv: CodeChunk;
+/**
+ * What SSR's resolve falls back to where the trace found nothing on screen, by the renderer's indirect
+ * lighting mode ({@link INDIRECT_LIGHTING}):
+ *
+ * ```wgsl
+ * fn ssr_sample_radiance(position_ws, normal_ws, view_direction_ws, roughness, coord: vec2u) -> vec3f
+ * ```
+ *
+ * @type {CodeChunkChoice}
+ */
+export const chunk_ssr_sample_radiance: CodeChunkChoice;
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+import { CodeChunkChoice } from "../../../shader/compiler/CodeChunkChoice.js";
+//# sourceMappingURL=chunk_ssr_sample_radiance.d.ts.map

package/src/shade/renderer/postprocess/ssr/resolve/chunk_ssr_sample_radiance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_ssr_sample_radiance.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/postprocess/ssr/resolve/chunk_ssr_sample_radiance.js"],"names":[],"mappings":"AAQA;;;GAGG;AACH,4CAFU,SAAS,CAUc;AAEjC;;;;GAIG;AACH,+CAFU,SAAS,CAUoB;AAEvC;;;GAGG;AACH,4CAFU,SAAS,CAUiB;AAEpC;;;;;;;;;GASG;AACH,wCAFU,eAAe,CAEwD;0BAxDvD,uCAAuC;gCACjC,6CAA6C"}

package/src/shade/renderer/postprocess/ssr/resolve/chunk_ssr_sample_radiance.js

@@ -0,0 +1,66 @@
+import { chunk_get_ibl_radiance } from "../../../deferred/indirect/chunk_get_ibl_radiance.js";
+import { chunk_brick4_sample_specular } from "../../../global_illumination/brick4/gpu/draw/chunk_brick4_sample_specular.js";
+import { INDIRECT_LIGHTING } from "../../../INDIRECT_LIGHTING.js";
+import { ShadeIndirectLightingMode } from "../../../ShadeIndirectLightingMode.js";
+import { chunk_lpv_sample_radiance } from "../../../shader/chunk/light/lpv/chunk_lpv_sample_radiance.js";
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+import { CodeChunkChoice } from "../../../shader/compiler/CodeChunkChoice.js";
+
+/**
+ * {@link chunk_ssr_sample_radiance} from the environment map. Reads `tEnvironment`.
+ * @type {CodeChunk}
+ */
+export const chunk_ssr_sample_radiance_ibl = CodeChunk.from(
+    //language=WGSL
+    `
+fn ssr_sample_radiance(
+    position_ws: vec3f, normal_ws: vec3f, view_direction_ws: vec3f, roughness: f32, coord: vec2u,
+) -> vec3f {
+    return get_ibl_radiance(view_direction_ws, normal_ws, roughness);
+}
+    `, [chunk_get_ibl_radiance]);
+
+/**
+ * {@link chunk_ssr_sample_radiance} from Brick4's probes, jittered per pixel and frame. Reads `brick4`,
+ * `tSTBN_vec2` and the resolve's `settings.frame_index`.
+ * @type {CodeChunk}
+ */
+export const chunk_ssr_sample_radiance_brick4 = CodeChunk.from(
+    //language=WGSL
+    `
+fn ssr_sample_radiance(
+    position_ws: vec3f, normal_ws: vec3f, view_direction_ws: vec3f, roughness: f32, coord: vec2u,
+) -> vec3f {
+    return brick4_sample_specular(position_ws, normal_ws, view_direction_ws, roughness, coord, settings.frame_index);
+}
+    `, [chunk_brick4_sample_specular]);
+
+/**
+ * {@link chunk_ssr_sample_radiance} from the light probe volume. Reads the LPV's buffers and its atlas.
+ * @type {CodeChunk}
+ */
+export const chunk_ssr_sample_radiance_lpv = CodeChunk.from(
+    //language=WGSL
+    `
+fn ssr_sample_radiance(
+    position_ws: vec3f, normal_ws: vec3f, view_direction_ws: vec3f, roughness: f32, coord: vec2u,
+) -> vec3f {
+    return lpv_sample_radiance(position_ws, normal_ws, view_direction_ws, roughness);
+}
+    `, [chunk_lpv_sample_radiance]);
+
+/**
+ * What SSR's resolve falls back to where the trace found nothing on screen, by the renderer's indirect
+ * lighting mode ({@link INDIRECT_LIGHTING}):
+ *
+ * ```wgsl
+ * fn ssr_sample_radiance(position_ws, normal_ws, view_direction_ws, roughness, coord: vec2u) -> vec3f
+ * ```
+ *
+ * @type {CodeChunkChoice}
+ */
+export const chunk_ssr_sample_radiance = CodeChunkChoice.from(INDIRECT_LIGHTING);
+
+chunk_ssr_sample_radiance.add(ShadeIndirectLightingMode.IBL, chunk_ssr_sample_radiance_ibl);
+chunk_ssr_sample_radiance.add(ShadeIndirectLightingMode.Brick4, chunk_ssr_sample_radiance_brick4);
+chunk_ssr_sample_radiance.add(ShadeIndirectLightingMode.LPV, chunk_ssr_sample_radiance_lpv);

package/src/shade/renderer/postprocess/ssr/resolve/ssr_resolve_shader.d.ts

@@ -0,0 +1,11 @@
+/**
+ * SSR's hit resolve: the traced hits of each pixel and its neighbours, weighed by the BRDF, over what
+ * the renderer's indirect lighting says where they found nothing. One shader for every indirect lighting
+ * mode, by a shader switch ({@link chunk_ssr_sample_radiance}, {@link chunk_ssr_add_hit_irradiance}),
+ * binding every mode's resources by name.
+ *
+ * @type {ImageShader}
+ */
+export const ssr_resolve_shader: ImageShader;
+import { ImageShader } from "../../../shader/ImageShader.js";
+//# sourceMappingURL=ssr_resolve_shader.d.ts.map

package/src/shade/renderer/postprocess/ssr/resolve/ssr_resolve_shader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ssr_resolve_shader.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/postprocess/ssr/resolve/ssr_resolve_shader.js"],"names":[],"mappings":"AA+VA;;;;;;;GAOG;AACH,iCAFU,WAAW,CAgBlB;4BAlWyB,gCAAgC"}

package/src/shade/renderer/postprocess/ssr/resolve/{build_ssr_resolve_shader.js → ssr_resolve_shader.js}

@@ -24,46 +24,54 @@ import { chunk_is_background } from "../../../shader/chunk/depth/chunk_is_backgr
 import { chunk_get_neighbour_weight } from "./chunk_get_neighbour_weight.js";
 import { chunk_get_ray_mip_level } from "./chunk_get_ray_mip_level.js";
 import { chunk_reconstruct_pdf } from "./chunk_reconstruct_pdf.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 { ShaderResourceSetDescriptor } from "../../../shader/resource/ShaderResourceSetDescriptor.js";
+import { BLACK_PIXEL_TEXTURE } from "../../../texture/util/BLACK_PIXEL_TEXTURE.js";
+import { ZERO_UINT_PIXEL_TEXTURE } from "../../../texture/util/ZERO_UINT_PIXEL_TEXTURE.js";
+import { chunk_ssr_add_hit_irradiance } from "./chunk_ssr_add_hit_irradiance.js";
+import { chunk_ssr_sample_radiance } from "./chunk_ssr_sample_radiance.js";
 
 const RESOLVE_UNIFORMS = WebGPUStruct.from({
     frame_index: u32,
 });
 
-/**
- * Compose the shared SSR hit resolve with a mode's GI sampling functions.
- * sample_radiance defines ssr_sample_radiance(position, normal, view_direction, roughness, coord).
- * Optional sample_hit_irradiance defines ssr_sample_hit_irradiance(position, normal, direction).
- *
- * @param {object} options
- * @param {string} options.label
- * @param {import("../../../shader/resource/ShaderResourceSetDescriptor.js").ShaderResourceSetDescriptor} options.resources GI resources
- * @param {CodeChunk} options.sample_radiance
- * @param {CodeChunk} [options.sample_hit_irradiance]
- * @returns {ImageShader}
- */
-export function build_ssr_resolve_shader({ label, resources, sample_radiance, sample_hit_irradiance }) {
-
-    // per-pass, four bytes, read-only: immediate data rather than a uniform buffer
-    resources.setImmediate("settings", RESOLVE_UNIFORMS);
-    resources.createGroup()
-        .addTexture("tTrace", "uint")
-        .addTexture("tDepth")
-        .addTexture("tPBR")
-        .addTexture("tNormal", "uint")
-        .addTexture("tColor", "float")
-        .addTexture("tAlbedoAO", "unfilterable-float")
-        .addSampler("sLinear", "filtering", SamplerDescriptor.from({
-            magFilter: "linear",
-            mipmapFilter: "linear",
-            addressModeU: "clamp-to-edge",
-            addressModeV: "clamp-to-edge",
-        }))
-        .addUniform("camera", CAMERA_UNIFORM_STRUCT)
-    ;
-
-    const body = CodeChunk.from(
-        //language=WGSL
-        `
+const resources = new ShaderResourceSetDescriptor();
+
+// What every indirect lighting mode samples where the trace found nothing, whichever the variant
+// reads (chunk_ssr_sample_radiance, chunk_ssr_add_hit_irradiance): the environment, Brick4's probes and
+// the noise that jitters them, and the light probe volume. The pass binds only the running mode's, and each
+// mode's source has a default for the others: black textures, transient buffers, a volume of no probes.
+resources.createGroup()
+    .addTexture("tEnvironment")
+    .addStorageBuffer("brick4", BRICK4_DATA_STRUCT, false, true)
+    .addTexture("tSTBN_vec2", "unfilterable-float", "3d")
+    .addTexture("lpv_atlas_radiance", "uint", "2d", false, ZERO_UINT_PIXEL_TEXTURE)
+    .addTexture("lpv_atlas_depth", "float", "2d", false, BLACK_PIXEL_TEXTURE);
+// the light probe volume
+resources.addGroup(LPV_SHADER_RESOURCE_GROUP_WITH_DEFAULTS);
+
+// per-pass, four bytes, read-only: immediate data rather than a uniform buffer
+resources.setImmediate("settings", RESOLVE_UNIFORMS);
+resources.createGroup()
+    .addTexture("tTrace", "uint")
+    .addTexture("tDepth")
+    .addTexture("tPBR")
+    .addTexture("tNormal", "uint")
+    .addTexture("tColor", "float")
+    .addTexture("tAlbedoAO", "unfilterable-float")
+    .addSampler("sLinear", "filtering", SamplerDescriptor.from({
+        magFilter: "linear",
+        mipmapFilter: "linear",
+        addressModeU: "clamp-to-edge",
+        addressModeV: "clamp-to-edge",
+    }))
+    .addUniform("camera", CAMERA_UNIFORM_STRUCT)
+;
+
+const body = CodeChunk.from(
+    //language=WGSL
+    `
 // optimized 7x7 neighbourhood offsets. Optimized for noise diffusion and TAA artifact avoidance
 const NEIGHBOR_OFFSETS = array<vec2<i32>, 48>(
     vec2<i32>(2, -3),
@@ -295,17 +303,10 @@ fn main(
     let this_position_ws = v3_matrix4_project( this_position_vs, camera.view_matrix_inverse );
 
 
-    ${sample_hit_irradiance === undefined ? '' : `
-    if (this_confidence > 0.05) {
-        let this_hit_position_ws = v3_matrix4_project(this_hit_position_vs, camera.view_matrix_inverse);
-        let this_hit_direction_ws = normalize(this_hit_position_ws - this_position_ws);
-        let hit_irradiance = ssr_sample_hit_irradiance(
-            this_hit_position_ws, this_hit_normal_ws, this_hit_direction_ws,
-        );
-        let this_hit_albedo = textureLoad(tAlbedoAO, this_hit.position, 0).rgb;
-        result += this_hit_albedo * hit_irradiance * RECIPROCAL_PI;
-    }
-    `}
+    // one bounce of indirect light at the hit, under a mode that has it
+    ssr_add_hit_irradiance(
+        &result, this_confidence, this_position_ws, this_hit_position_vs, this_hit_normal_ws, this_hit.position,
+    );
 
     let gi_radiance = ssr_sample_radiance(
         this_position_ws, this_normal_ws, view_direction_ws, this_roughness, vec2u(coord_i),
@@ -324,43 +325,50 @@ fn main(
     output.metadata = ssr_resolve_metadata(distance_moments, max_confidence);
     return output;
 }
-        `, [
-            chunk_ssr_metadata,
-            chunk_is_on_screen_i32,
-            chunk_decode_g_buffer_roughness,
-            chunk_direction_world_to_view,
-            chunk_screen_coordinate_to_view,
-            chunk_decode_g_buffer_normal,
-            chunk_rgb_to_YCoCg,
-            sample_radiance,
-            ...(sample_hit_irradiance === undefined ? [] : [sample_hit_irradiance]),
-            chunk_ssr_hit_unpack,
-            chunk_texel_coordinate_to_uv,
-            chunk_get_neighbour_weight,
-            chunk_is_background,
-            chunk_murmur3_vec3u,
-            chunk_reconstruct_pdf,
-            chunk_get_ray_mip_level,
-            chunk_project_view_position_from_depth,
-            chunk_v3_matrix4_project,
-            RECIPROCAL_PI_DECLARATION,
-            chunk_rgb_to_luminance,
-        ]
-    );
+    `, [
+        chunk_ssr_metadata,
+        chunk_is_on_screen_i32,
+        chunk_decode_g_buffer_roughness,
+        chunk_direction_world_to_view,
+        chunk_screen_coordinate_to_view,
+        chunk_decode_g_buffer_normal,
+        chunk_rgb_to_YCoCg,
+        chunk_ssr_sample_radiance,
+        chunk_ssr_add_hit_irradiance,
+        chunk_ssr_hit_unpack,
+        chunk_texel_coordinate_to_uv,
+        chunk_get_neighbour_weight,
+        chunk_is_background,
+        chunk_murmur3_vec3u,
+        chunk_reconstruct_pdf,
+        chunk_get_ray_mip_level,
+        chunk_project_view_position_from_depth,
+        chunk_v3_matrix4_project,
+        RECIPROCAL_PI_DECLARATION,
+        chunk_rgb_to_luminance,
+    ]
+);
 
-    return new ImageShader({
-        descriptor: ShaderDescriptor.from({
-            label,
-            resources,
-            body
-        }),
-        targets: [
-            // TODO output rgbe5559 color and f16 variance to reduce memory bandwidth
-            {
-                format: "rgba16float"
-            },
-            { format: "rg32float" }
-        ],
-        depthStencil: DEPTH_STENCIL_FOREGROUND_ONLY,
-    });
-}
+/**
+ * SSR's hit resolve: the traced hits of each pixel and its neighbours, weighed by the BRDF, over what
+ * the renderer's indirect lighting says where they found nothing. One shader for every indirect lighting
+ * mode, by a shader switch ({@link chunk_ssr_sample_radiance}, {@link chunk_ssr_add_hit_irradiance}),
+ * binding every mode's resources by name.
+ *
+ * @type {ImageShader}
+ */
+export const ssr_resolve_shader = new ImageShader({
+    descriptor: ShaderDescriptor.from({
+        label: "SSR resolve",
+        resources,
+        body
+    }),
+    targets: [
+        // TODO output rgbe5559 color and f16 variance to reduce memory bandwidth
+        {
+            format: "rgba16float"
+        },
+        { format: "rg32float" }
+    ],
+    depthStencil: DEPTH_STENCIL_FOREGROUND_ONLY,
+});

package/src/shade/renderer/rasterize/expand/GPUCollectionLimits.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUCollectionLimits.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/rasterize/expand/GPUCollectionLimits.js"],"names":[],"mappings":"AAsBA;;GAEG;AACH;IAyBI;;;OAGG;IACH,+BAqBC;IAtCD;;;OAGG;IACH,uCAEC;IAkCD;;;;OAIG;IACH,gBAHW,2BAA2B,GAC1B,MAAM,CAMjB;IAED;;;;;;;;;;;;;;;;;;OAkBG;IACH,YAHW,2BAA2B,SAC3B,MAAM,QAQhB;IAED;;;;OAIG;IACH,0BAHW,2BAA2B,GACzB,MAAM,CAyBlB;IA+BD,gBAEC;IAED;;;;;;;OAOG;IACH,gBAHW,sBAAsB,WACtB,kBAAkB,iBAkB5B;;CAEJ;qCAjMY,OAAO,2CAA2C,EAAE,sBAAsB;iCAC1E,OAAO,oCAAoC,EAAE,kBAAkB;0CANlC,yCAAyC;4CACvC,kCAAkC"}
+{"version":3,"file":"GPUCollectionLimits.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/rasterize/expand/GPUCollectionLimits.js"],"names":[],"mappings":"AAwBA;;GAEG;AACH;IAyBI;;;OAGG;IACH,+BAuBC;IAxCD;;;OAGG;IACH,uCAEC;IAoCD;;;;OAIG;IACH,gBAHW,2BAA2B,GAC1B,MAAM,CAMjB;IAED;;;;;;;;;;;;;;;;;;OAkBG;IACH,YAHW,2BAA2B,SAC3B,MAAM,QAQhB;IAED;;;;OAIG;IACH,0BAHW,2BAA2B,GACzB,MAAM,CAyBlB;IA+BD,gBAEC;IAED;;;;;;;OAOG;IACH,gBAHW,sBAAsB,WACtB,kBAAkB,iBAkB5B;;CAEJ;qCArMY,OAAO,2CAA2C,EAAE,sBAAsB;iCAC1E,OAAO,oCAAoC,EAAE,kBAAkB;0CANlC,yCAAyC;4CACvC,kCAAkC"}

package/src/shade/renderer/rasterize/expand/GPUCollectionLimits.js

@@ -18,6 +18,8 @@ const ELEMENT_SIZES = {
     [RasterizationCollectionType.Meshlets]: Uint32Array.BYTES_PER_ELEMENT * 2,
     // ObjectPropertyReference: { instance: u32, property: u32 } = 8 bytes
     [RasterizationCollectionType.ObjectPropertyReference]: Uint32Array.BYTES_PER_ELEMENT * 2,
+    // LightClusterEntries: one light id, u32
+    [RasterizationCollectionType.LightClusterEntries]: Uint32Array.BYTES_PER_ELEMENT,
 }
 
 /**
@@ -66,6 +68,8 @@ export class GPUCollectionLimits {
         this.#stats.setGlobalMax(RasterizationCollectionType.Meshes, 1e4);
         this.#stats.setGlobalMax(RasterizationCollectionType.Meshlets, 2e5);
         this.#stats.setGlobalMax(RasterizationCollectionType.ObjectPropertyReference, 1024);
+        // primed for each cluster grid by graph_assign_clsuters
+        this.#stats.setGlobalMax(RasterizationCollectionType.LightClusterEntries, 0);
 
         // initialize limits
         Object.values(RasterizationCollectionType).forEach(id => {

package/src/shade/renderer/rasterize/expand/RasterizationCollectionType.d.ts

@@ -8,5 +8,6 @@ export namespace RasterizationCollectionType {
     let Meshes: number;
     let Meshlets: number;
     let ObjectPropertyReference: number;
+    let LightClusterEntries: number;
 }
 //# sourceMappingURL=RasterizationCollectionType.d.ts.map

package/src/shade/renderer/rasterize/expand/RasterizationCollectionType.js

@@ -14,4 +14,9 @@ export const RasterizationCollectionType = {
      * {@link OBJECT_PROPERTY_REFERENCE_STRUCT}.
      */
     ObjectPropertyReference: 2,
+    /**
+     * Entries of the light clusters' `cluster_data`, sized from the frame's bound: the cells of every
+     * culled light's box of cells — see {@link CLUSTER_LIGHT_BOUND}.
+     */
+    LightClusterEntries: 3,
 };

package/src/shade/renderer/rasterize/forward/chunk_forward_sample_indirect.d.ts

@@ -0,0 +1,25 @@
+/**
+ * The indirect light arriving at a forward-shaded fragment, by the renderer's mode
+ * ({@link INDIRECT_LIGHTING}):
+ *
+ * ```wgsl
+ * fn forward_sample_indirect(position_ws, view_direction, normal, roughness,
+ *     radiance: ptr<function, vec3f>, irradiance: ptr<function, vec3f>)
+ * ```
+ *
+ * `radiance` is the specular light from the reflection direction at `roughness`, `irradiance` the
+ * diffuse light on a surface facing `normal`; `view_direction` points from the surface to the camera.
+ *
+ * - IBL: the environment map ({@link chunk_forward_sample_indirect_environment});
+ * - Brick4: the light map's probes ({@link chunk_forward_sample_indirect_brick4});
+ * - LPV: the environment map. The probe volume has no forward sampling; transparent surfaces under
+ *   LPV are lit as under IBL.
+ *
+ * A pipeline that links this binds what every mode reads, `tEnvironment`, `brick4` and `view`, and
+ * reads only its own mode's.
+ *
+ * @type {CodeChunkChoice}
+ */
+export const chunk_forward_sample_indirect: CodeChunkChoice;
+import { CodeChunkChoice } from "../../shader/compiler/CodeChunkChoice.js";
+//# sourceMappingURL=chunk_forward_sample_indirect.d.ts.map

package/src/shade/renderer/rasterize/forward/chunk_forward_sample_indirect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_forward_sample_indirect.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/rasterize/forward/chunk_forward_sample_indirect.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,4CAFU,eAAe,CAE4D;gCA1BrD,0CAA0C"}

package/src/shade/renderer/rasterize/forward/chunk_forward_sample_indirect.js

@@ -0,0 +1,33 @@
+import { INDIRECT_LIGHTING } from "../../INDIRECT_LIGHTING.js";
+import { ShadeIndirectLightingMode } from "../../ShadeIndirectLightingMode.js";
+import { CodeChunkChoice } from "../../shader/compiler/CodeChunkChoice.js";
+import { chunk_forward_sample_indirect_brick4 } from "./chunk_forward_sample_indirect_brick4.js";
+import { chunk_forward_sample_indirect_environment } from "./chunk_forward_sample_indirect_environment.js";
+
+/**
+ * The indirect light arriving at a forward-shaded fragment, by the renderer's mode
+ * ({@link INDIRECT_LIGHTING}):
+ *
+ * ```wgsl
+ * fn forward_sample_indirect(position_ws, view_direction, normal, roughness,
+ *     radiance: ptr<function, vec3f>, irradiance: ptr<function, vec3f>)
+ * ```
+ *
+ * `radiance` is the specular light from the reflection direction at `roughness`, `irradiance` the
+ * diffuse light on a surface facing `normal`; `view_direction` points from the surface to the camera.
+ *
+ * - IBL: the environment map ({@link chunk_forward_sample_indirect_environment});
+ * - Brick4: the light map's probes ({@link chunk_forward_sample_indirect_brick4});
+ * - LPV: the environment map. The probe volume has no forward sampling; transparent surfaces under
+ *   LPV are lit as under IBL.
+ *
+ * A pipeline that links this binds what every mode reads, `tEnvironment`, `brick4` and `view`, and
+ * reads only its own mode's.
+ *
+ * @type {CodeChunkChoice}
+ */
+export const chunk_forward_sample_indirect = CodeChunkChoice.from(INDIRECT_LIGHTING);
+
+chunk_forward_sample_indirect.add(ShadeIndirectLightingMode.IBL, chunk_forward_sample_indirect_environment);
+chunk_forward_sample_indirect.add(ShadeIndirectLightingMode.Brick4, chunk_forward_sample_indirect_brick4);
+chunk_forward_sample_indirect.add(ShadeIndirectLightingMode.LPV, chunk_forward_sample_indirect_environment);

package/src/shade/renderer/rasterize/forward/chunk_forward_sample_indirect_brick4.d.ts

@@ -0,0 +1,10 @@
+/**
+ * {@link chunk_forward_sample_indirect} from Brick4, the sparse volumetric light map: the probes around
+ * the position, with the shading normal standing in for a bent normal, which a forward fragment does
+ * not have. Reads `brick4` and `view`.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_forward_sample_indirect_brick4: CodeChunk;
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_forward_sample_indirect_brick4.d.ts.map

package/src/shade/renderer/rasterize/forward/chunk_forward_sample_indirect_brick4.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_forward_sample_indirect_brick4.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/rasterize/forward/chunk_forward_sample_indirect_brick4.js"],"names":[],"mappings":"AAKA;;;;;;GAMG;AACH,mDAFU,SAAS,CA2BjB;0BAlCwB,oCAAoC"}

package/src/shade/renderer/rasterize/forward/chunk_forward_sample_indirect_brick4.js

@@ -0,0 +1,38 @@
+import {
+    chunk_brick4_sample_forward_indirect
+} from "../../global_illumination/brick4/gpu/draw/chunk_brick4_sample_forward_indirect.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+
+/**
+ * {@link chunk_forward_sample_indirect} from Brick4, the sparse volumetric light map: the probes around
+ * the position, with the shading normal standing in for a bent normal, which a forward fragment does
+ * not have. Reads `brick4` and `view`.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_forward_sample_indirect_brick4 = CodeChunk.from(
+    //language=WGSL
+    `
+fn forward_sample_indirect(
+    position_ws: vec3f,
+    view_direction: vec3f,
+    normal: vec3f,
+    roughness: f32,
+
+    radiance: ptr<function, vec3f>,
+    irradiance: ptr<function, vec3f>,
+) {
+    brick4_sample_forward_indirect(
+        position_ws,
+        view_direction,
+        normal,
+        normal,
+        roughness,
+        radiance,
+        irradiance,
+    );
+}
+    `, [
+        chunk_brick4_sample_forward_indirect,
+    ]
+);

package/src/shade/renderer/rasterize/forward/chunk_forward_sample_indirect_environment.d.ts

@@ -0,0 +1,9 @@
+/**
+ * {@link chunk_forward_sample_indirect} from the environment map: the same light at every position,
+ * specular from its prefiltered levels and irradiance from its roughest. Reads `tEnvironment`.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_forward_sample_indirect_environment: CodeChunk;
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_forward_sample_indirect_environment.d.ts.map

package/src/shade/renderer/rasterize/forward/chunk_forward_sample_indirect_environment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_forward_sample_indirect_environment.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/rasterize/forward/chunk_forward_sample_indirect_environment.js"],"names":[],"mappings":"AAIA;;;;;GAKG;AACH,wDAFU,SAAS,CAqBjB;0BA3BwB,oCAAoC"}

package/src/shade/renderer/rasterize/forward/chunk_forward_sample_indirect_environment.js

@@ -0,0 +1,30 @@
+import { chunk_get_ibl_irradiance } from "../../deferred/indirect/chunk_get_ibl_irradiance.js";
+import { chunk_get_ibl_radiance } from "../../deferred/indirect/chunk_get_ibl_radiance.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+
+/**
+ * {@link chunk_forward_sample_indirect} from the environment map: the same light at every position,
+ * specular from its prefiltered levels and irradiance from its roughest. Reads `tEnvironment`.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_forward_sample_indirect_environment = CodeChunk.from(
+    //language=WGSL
+    `
+fn forward_sample_indirect(
+    position_ws: vec3f,
+    view_direction: vec3f,
+    normal: vec3f,
+    roughness: f32,
+
+    radiance: ptr<function, vec3f>,
+    irradiance: ptr<function, vec3f>,
+) {
+    *radiance = get_ibl_radiance(view_direction, normal, roughness);
+    *irradiance = get_ibl_irradiance(normal);
+}
+    `, [
+        chunk_get_ibl_radiance,
+        chunk_get_ibl_irradiance,
+    ]
+);

package/src/shade/renderer/rasterize/forward/chunk_forward_shade_standard_fragment.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Forward shading of a standard material: the clustered direct lights, then the indirect light the
+ * renderer's mode supplies through {@link chunk_forward_sample_indirect}. Linked by the transparent
+ * passes (the AVBOIT draw and the MBOIT resolve), which bind every mode's indirect resources and get
+ * one mode's sampling per pipeline. `point_budget` and `spot_budget` are the linking pass's light
+ * budgets, handed to {@link chunk_shade_standard_material_direct}.
+ */
+export const chunk_forward_shade_standard_fragment: CodeChunk;
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_forward_shade_standard_fragment.d.ts.map

package/src/shade/renderer/rasterize/forward/chunk_forward_shade_standard_fragment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_forward_shade_standard_fragment.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/rasterize/forward/chunk_forward_shade_standard_fragment.js"],"names":[],"mappings":"AAuCA;;;;;;GAMG;AACH,8DAiKC;0BAxLyB,oCAAoC"}