@woosh/meep-engine 3.61.1 → 3.61.3

package/src/shade/renderer/global_illumination/brick4/gpu/encoding/v2/chunk_brick4_sh3_color_decode.d.ts

@@ -1,3 +1,15 @@
+/**
+ * The RGB SH3 that {@link chunk_brick4_sh3_color_pack} packed, times `scale`, and its band 0 alone, which is the
+ * first word. Every coefficient decodes as a multiple of band 0, so the scale is applied to band 0 alone.
+ *
+ * ```wgsl
+ * fn brick4_sh3_color_unpack(words: array<u32, 7>, scale: f32) -> array<vec3<f32>, 9>
+ * fn brick4_sh3_color_unpack_dc(words: array<u32, 7>) -> vec3<f32>
+ * ```
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_brick4_sh3_color_unpack: CodeChunk;
 export const chunk_brick4_sh3_color_decode: CodeChunk;
 import { CodeChunk } from "../../../../../shader/compiler/CodeChunk.js";
 //# sourceMappingURL=chunk_brick4_sh3_color_decode.d.ts.map

package/src/shade/renderer/global_illumination/brick4/gpu/encoding/v2/chunk_brick4_sh3_color_decode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_brick4_sh3_color_decode.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/shade/renderer/global_illumination/brick4/gpu/encoding/v2/chunk_brick4_sh3_color_decode.js"],"names":[],"mappings":"AAOA,sDAyCC;0BA5CyB,6CAA6C"}
+{"version":3,"file":"chunk_brick4_sh3_color_decode.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/shade/renderer/global_illumination/brick4/gpu/encoding/v2/chunk_brick4_sh3_color_decode.js"],"names":[],"mappings":"AAQA;;;;;;;;;;GAUG;AACH,4CAFU,SAAS,CAiCjB;AAEF,sDAqBC;0BArEyB,6CAA6C"}

package/src/shade/renderer/global_illumination/brick4/gpu/encoding/v2/chunk_brick4_sh3_color_decode.js

@@ -3,42 +3,44 @@ import {
     chunk_sh3_color_combine_channels
 } from "../../../../../shader/chunk/spherical_harmonics/chunk_sh3_color_combine_channels.js";
 import { CodeChunk } from "../../../../../shader/compiler/CodeChunk.js";
+import { BRICK4_PROBE_ENCODED_SIZE } from "../../../BRICK4_PROBE_ENCODED_SIZE.js";
 import { chunk_sh3_uncompress } from "./chunk_sh3_uncompress.js";
 
-export const chunk_brick4_sh3_color_decode = CodeChunk.from(
+/**
+ * The RGB SH3 that {@link chunk_brick4_sh3_color_pack} packed, times `scale`, and its band 0 alone, which is the
+ * first word. Every coefficient decodes as a multiple of band 0, so the scale is applied to band 0 alone.
+ *
+ * ```wgsl
+ * fn brick4_sh3_color_unpack(words: array<u32, 7>, scale: f32) -> array<vec3<f32>, 9>
+ * fn brick4_sh3_color_unpack_dc(words: array<u32, 7>) -> vec3<f32>
+ * ```
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_brick4_sh3_color_unpack = CodeChunk.from(
     //language=WGSL
     `
-fn brick4_sh3_color_decode(
-    storage_buf: ptr<storage, array<u32>, read>, 
-    offset: u32
-) -> array< vec3<f32>, 9 > {
+fn brick4_sh3_color_unpack_dc(words: array<u32, ${BRICK4_PROBE_ENCODED_SIZE}>) -> vec3<f32> {
+    return rgbe9995_decode(words[0]);
+}
 
-   let rgb_L0 = rgbe9995_decode((*storage_buf)[offset + 0u]); 
+fn brick4_sh3_color_unpack(words: array<u32, ${BRICK4_PROBE_ENCODED_SIZE}>, scale: f32) -> array< vec3<f32>, 9 > {
+
+    let rgb_L0 = brick4_sh3_color_unpack_dc(words) * scale;
+
+    let compressed_r = vec2<u32>(words[1], words[2]);
+    let compressed_g = vec2<u32>(words[3], words[4]);
+    let compressed_b = vec2<u32>(words[5], words[6]);
 
-    let compressed_r = vec2<u32>(
-        (*storage_buf)[offset + 1u],
-        (*storage_buf)[offset + 2u]
-    );
-    
-    let compressed_g = vec2<u32>(
-        (*storage_buf)[offset + 3u],
-        (*storage_buf)[offset + 4u]
-    );
-    
-    let compressed_b = vec2<u32>(
-        (*storage_buf)[offset + 5u],
-        (*storage_buf)[offset + 6u]
-    );
-    
     const nonZbound = 1.9365;
     const bits = 8;
     const sq = true;
     const isIrrad = false;
-    
+
     let sh_r = sh3_uncompress(compressed_r, rgb_L0.x, bits, nonZbound, sq, isIrrad);
     let sh_g = sh3_uncompress(compressed_g, rgb_L0.y, bits, nonZbound, sq, isIrrad);
     let sh_b = sh3_uncompress(compressed_b, rgb_L0.z, bits, nonZbound, sq, isIrrad);
-    
+
     return sh3_color_combine_channels(sh_r, sh_g, sh_b);
 }
     `, [
@@ -46,4 +48,27 @@ fn brick4_sh3_color_decode(
         chunk_sh3_color_combine_channels,
         chunk_sh3_uncompress,
     ]
-)
+);
+
+export const chunk_brick4_sh3_color_decode = CodeChunk.from(
+    //language=WGSL
+    `
+fn brick4_sh3_color_decode(
+    storage_buf: ptr<storage, array<u32>, read>,
+    offset: u32
+) -> array< vec3<f32>, 9 > {
+
+    return brick4_sh3_color_unpack(array<u32, ${BRICK4_PROBE_ENCODED_SIZE}>(
+        (*storage_buf)[offset + 0u],
+        (*storage_buf)[offset + 1u],
+        (*storage_buf)[offset + 2u],
+        (*storage_buf)[offset + 3u],
+        (*storage_buf)[offset + 4u],
+        (*storage_buf)[offset + 5u],
+        (*storage_buf)[offset + 6u],
+    ), 1.0);
+}
+    `, [
+        chunk_brick4_sh3_color_unpack,
+    ]
+)

package/src/shade/renderer/global_illumination/brick4/gpu/encoding/v2/chunk_brick4_sh3_color_encode.d.ts

@@ -1,3 +1,15 @@
+/**
+ * An RGB SH3 of a non-negative function as {@link BRICK4_PROBE_ENCODED_SIZE} words: band 0 as RGB9E5 in the
+ * first, then each channel's bands 1 and 2 in two words, eight bits a coefficient over the band 0 the decoder
+ * reads back (`sh3_compress`).
+ *
+ * ```wgsl
+ * fn brick4_sh3_color_pack(sh: array<vec3<f32>, 9>) -> array<u32, 7>
+ * ```
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_brick4_sh3_color_pack: CodeChunk;
 export const chunk_brick4_sh3_color_encode: CodeChunk;
 import { CodeChunk } from "../../../../../shader/compiler/CodeChunk.js";
 //# sourceMappingURL=chunk_brick4_sh3_color_encode.d.ts.map

package/src/shade/renderer/global_illumination/brick4/gpu/encoding/v2/chunk_brick4_sh3_color_encode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_brick4_sh3_color_encode.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/shade/renderer/global_illumination/brick4/gpu/encoding/v2/chunk_brick4_sh3_color_encode.js"],"names":[],"mappings":"AAQA,sDAgDC;0BAnDyB,6CAA6C"}
+{"version":3,"file":"chunk_brick4_sh3_color_encode.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/shade/renderer/global_illumination/brick4/gpu/encoding/v2/chunk_brick4_sh3_color_encode.js"],"names":[],"mappings":"AASA;;;;;;;;;;GAUG;AACH,0CAFU,SAAS,CA8CjB;AAEF,sDAqBC;0BAlFyB,6CAA6C"}

package/src/shade/renderer/global_illumination/brick4/gpu/encoding/v2/chunk_brick4_sh3_color_encode.js

@@ -4,18 +4,25 @@ import {
     chunk_sh3_color_split_channels
 } from "../../../../../shader/chunk/spherical_harmonics/chunk_sh3_color_split_channels.js";
 import { CodeChunk } from "../../../../../shader/compiler/CodeChunk.js";
+import { BRICK4_PROBE_ENCODED_SIZE } from "../../../BRICK4_PROBE_ENCODED_SIZE.js";
 import { chunk_sh3_compress } from "./chunk_sh3_compress.js";
 
-export const chunk_brick4_sh3_color_encode = CodeChunk.from(
+/**
+ * An RGB SH3 of a non-negative function as {@link BRICK4_PROBE_ENCODED_SIZE} words: band 0 as RGB9E5 in the
+ * first, then each channel's bands 1 and 2 in two words, eight bits a coefficient over the band 0 the decoder
+ * reads back (`sh3_compress`).
+ *
+ * ```wgsl
+ * fn brick4_sh3_color_pack(sh: array<vec3<f32>, 9>) -> array<u32, 7>
+ * ```
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_brick4_sh3_color_pack = CodeChunk.from(
     //language=WGSL
     `
-fn brick4_sh3_color_encode(
-    out:ptr<storage, array<u32>,read_write>,
-    out_offset: u32,
-    sh: array<vec3<f32>,9>
-) {
+fn brick4_sh3_color_pack(sh: array<vec3<f32>,9>) -> array<u32, ${BRICK4_PROBE_ENCODED_SIZE}> {
     let encoded_dc = rgbe9995_encode(sh[0]);
-    (*out)[out_offset + 0u] = encoded_dc;
 
     // Normalize L1/L2 against the DC the DECODER will see — the rgbe9995 round-trip quantizes the
     // DC (shared 5-bit exponent, so a dim channel next to a bright one moves a lot), and
@@ -28,7 +35,7 @@ fn brick4_sh3_color_encode(
     rgb_sh[0][0] = quantized_dc.x;
     rgb_sh[1][0] = quantized_dc.y;
     rgb_sh[2][0] = quantized_dc.z;
-    
+
     // sqrt(15)/2
     const nonZbound = 1.9365;
     const bits = 8;
@@ -38,20 +45,44 @@ fn brick4_sh3_color_encode(
     let compressed_r = sh3_compress(rgb_sh[0], bits, nonZbound, sq, isIrrad);
     let compressed_g = sh3_compress(rgb_sh[1], bits, nonZbound, sq, isIrrad);
     let compressed_b = sh3_compress(rgb_sh[2], bits, nonZbound, sq, isIrrad);
-    
-    (*out)[out_offset + 1u] = compressed_r.x;
-    (*out)[out_offset + 2u] = compressed_r.y;
-    
-    (*out)[out_offset + 3u] = compressed_g.x;
-    (*out)[out_offset + 4u] = compressed_g.y;
-    
-    (*out)[out_offset + 5u] = compressed_b.x;
-    (*out)[out_offset + 6u] = compressed_b.y;
+
+    return array<u32, ${BRICK4_PROBE_ENCODED_SIZE}>(
+        encoded_dc,
+        compressed_r.x,
+        compressed_r.y,
+        compressed_g.x,
+        compressed_g.y,
+        compressed_b.x,
+        compressed_b.y,
+    );
 }
-    `,[
+    `, [
         chunk_sh3_compress,
         chunk_rgbe9995_encode,
         chunk_rgbe9995_decode,
         chunk_sh3_color_split_channels,
     ]
-)
+);
+
+export const chunk_brick4_sh3_color_encode = CodeChunk.from(
+    //language=WGSL
+    `
+fn brick4_sh3_color_encode(
+    out:ptr<storage, array<u32>,read_write>,
+    out_offset: u32,
+    sh: array<vec3<f32>,9>
+) {
+    let words = brick4_sh3_color_pack(sh);
+
+    (*out)[out_offset + 0u] = words[0];
+    (*out)[out_offset + 1u] = words[1];
+    (*out)[out_offset + 2u] = words[2];
+    (*out)[out_offset + 3u] = words[3];
+    (*out)[out_offset + 4u] = words[4];
+    (*out)[out_offset + 5u] = words[5];
+    (*out)[out_offset + 6u] = words[6];
+}
+    `,[
+        chunk_brick4_sh3_color_pack,
+    ]
+)

package/src/shade/renderer/global_illumination/brick4/gpu/encoding/v2/chunk_sh3_compress.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_sh3_compress.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/shade/renderer/global_illumination/brick4/gpu/encoding/v2/chunk_sh3_compress.js"],"names":[],"mappings":"AAGA;;;;;GAKG;AACH,iCAFU,SAAS,CAsDlB;0BA7DyB,6CAA6C"}
+{"version":3,"file":"chunk_sh3_compress.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/shade/renderer/global_illumination/brick4/gpu/encoding/v2/chunk_sh3_compress.js"],"names":[],"mappings":"AAGA;;;;;GAKG;AACH,iCAFU,SAAS,CA0DlB;0BAjEyB,6CAA6C"}

package/src/shade/renderer/global_illumination/brick4/gpu/encoding/v2/chunk_sh3_compress.js

@@ -38,10 +38,14 @@ fn sh3_compress(
     let nz_factor = select(1.0, 0.25, isIrrad); // Same factor as qz for irradiance
     let nz = 1.0 / (safe_DC * nz_denom * nz_factor);
 
+    // The bounds hold over the DC the function was projected with. Over a DC the caller quantized down
+    // (an RGB9E5 band 0) a coefficient can pass its bound, and pack4's byte would overflow into the
+    // next coefficient's: held to the bound instead.
+
     // Pack the first set: sh[1]..sh[4] (Linear + 1st Quad) [cite: 130-132]
     // Scaled by their respective bounds: lc, lc, lc, nz
     let packed0 = pack4(
-        vec4<f32>(sh[1], sh[2], sh[3], sh[4]) * vec4<f32>(lc, lc, lc, nz),
+        clamp(vec4<f32>(sh[1], sh[2], sh[3], sh[4]) * vec4<f32>(lc, lc, lc, nz), vec4<f32>(-1.0), vec4<f32>(1.0)),
         bv,
         sq
     );
@@ -49,7 +53,7 @@ fn sh3_compress(
     // Pack the second set: sh[5]..sh[8] (Remaining Quads) [cite: 135-137]
     // Scaled by bounds: nz, qz, nz, nz
     let packed1 = pack4(
-        vec4<f32>(sh[5], sh[6], sh[7], sh[8]) * vec4<f32>(nz, qz, nz, nz),
+        clamp(vec4<f32>(sh[5], sh[6], sh[7], sh[8]) * vec4<f32>(nz, qz, nz, nz), vec4<f32>(-1.0), vec4<f32>(1.0)),
         bv,
         sq
     );

package/src/shade/renderer/global_illumination/probe_clipmap/GPUProbeClipmapGI.d.ts

@@ -20,10 +20,11 @@
  * readers bind while there are no probes ({@link write_sampling_bindings}): seven objects of a few bytes,
  * made on the first ask and kept until {@link destroy}.
  *
- * Each frame it holds the geometry caches and card sets its scene's SDF world draws
- * ({@link ProbeClipmapSceneHolds}), trims the caches nothing holds, and records their bake and the
- * cards' capture (§6). Leaving the mode lets go of the holds and trims nothing, so the caches are
- * there when the mode comes back (D28); the card sets go, and are captured again.
+ * Each frame it holds the geometry caches and the Model Surface Caches its scene's SDF world draws
+ * ({@link ProbeClipmapSceneHolds}), trims the geometry caches nothing holds, and records their bakes
+ * (§6). The bricks' material is gathered from the surface caches as each brick is built
+ * ({@link GPUBrickMaterial}). Leaving the mode lets go of the holds and trims nothing, so the geometry
+ * caches are there when the mode comes back (D28); the surface caches go, and are baked again.
  *
  * Until its probes are traced (§13, S4) the mode lights as IBL.
  */
@@ -33,7 +34,7 @@ export class GPUProbeClipmapGI {
      * @param {ProbeClipmapSettings} settings
      * @returns {boolean} whether it is what the settings' world cache describes, in their frustum's windows
      */
-    static "__#208@#world_cache_built_for"(world_cache: GPUProbeClipmap, settings: ProbeClipmapSettings): boolean;
+    static "__#210@#world_cache_built_for"(world_cache: GPUProbeClipmap, settings: ProbeClipmapSettings): boolean;
     /**
      * @param {GraphicsContext} graphics
      */
@@ -68,8 +69,11 @@ export class GPUProbeClipmapGI {
      * @param {*} options.stbn the 2-channel spatio-temporal blue noise, `STATIC_GRAPHICS_ENGINE_ASSETS.stbn_vec2`
      * @param {number} [options.movers] the graph handle of the scene's mover list for the frame,
      *   which the world's bricks are built again over
+     * @param {number} options.exposure the graph handle of the factor the display multiplies radiance by ahead of its
+     *   tone curve, as the last frame was shown (`GPUCameraExposureManager#multiplier`): what the probes'
+     *   estimators state their thresholds in
      */
-    graph_update({ graph, view, settings, depth, normal, stbn, movers }: {
+    graph_update({ graph, view, settings, depth, normal, stbn, movers, exposure }: {
         graph: FrameGraph;
         view: GPUViewContext;
         settings: ProbeClipmapSettings;
@@ -77,6 +81,7 @@ export class GPUProbeClipmapGI {
         normal: number;
         stbn: any;
         movers?: number;
+        exposure: number;
     }): void;
     /**
      * Whether the probes are there to read: the mode has run a frame and not been left since.
@@ -98,18 +103,25 @@ export class GPUProbeClipmapGI {
      * The debug view the settings ask for, in place of the frame's colour. Record it after
      * {@link graph_update} in the same frame.
      *
+     * The indirect views draw the fused indirect pass (`shader_probe_clipmap_indirect_lighting`) with one lobe
+     * alone, from `indirect`, the inputs the frame's own fused pass takes, to which they add the probes' sampling
+     * bindings ({@link write_sampling_bindings}).
+     *
      * @param {Object} options
      * @param {FrameGraph} options.graph
      * @param {GPUViewContext} options.view
      * @param {ProbeClipmapSettings} options.settings
      * @param {number[]} options.resolution
-     * @returns {number} graph handle of an `rgba8unorm` image
+     * @param {Object} options.indirect the fused indirect pass's inputs this frame, without the probes' bindings
+     * @returns {number} graph handle of the image: `rgba8unorm` for the geometry views, `rgba16float` for the
+     * indirect ones
      */
-    graph_debug_view({ graph, view, settings, resolution }: {
+    graph_debug_view({ graph, view, settings, resolution, indirect }: {
         graph: FrameGraph;
         view: GPUViewContext;
         settings: ProbeClipmapSettings;
         resolution: number[];
+        indirect: any;
     }): number;
     /**
      * Have a plugin write the world's bricks too, after the mesh provider and every provider added

package/src/shade/renderer/global_illumination/probe_clipmap/GPUProbeClipmapGI.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUProbeClipmapGI.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/global_illumination/probe_clipmap/GPUProbeClipmapGI.js"],"names":[],"mappings":"AAuBA;;;;;;GAMG;AAEH;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH;IAoSI;;;;OAIG;IACH,oDAJW,eAAe,YACf,oBAAoB,GAClB,OAAO,CAUnB;IArOD;;OAEG;IACH,sBAFW,eAAe,EAMzB;IAED;;OAEG;IACH,qCAEC;IAED;;OAEG;IACH,qCAEC;IAED;;OAEG;IACH,mCAEC;IAED;;OAEG;IACH,oCAEC;IAED;;;;;;;;;;;;;;OAcG;IACH;QAT+B,KAAK,EAAzB,UAAU;QACc,IAAI,EAA5B,cAAc;QACgB,QAAQ,EAAtC,oBAAoB;QACJ,KAAK,EAArB,MAAM;QACU,MAAM,EAAtB,MAAM;QACK,IAAI;QACE,MAAM,GAAvB,MAAM;aAiIhB;IAqDD;;;OAGG;IACH,0BAEC;IAED;;;;;;;;;OASG;IACH,4CAUC;IAwDD;;;;;;;;;;OAUG;IACH;QAN+B,KAAK,EAAzB,UAAU;QACc,IAAI,EAA5B,cAAc;QACgB,QAAQ,EAAtC,oBAAoB;QACF,UAAU,EAA5B,MAAM,EAAE;QACN,MAAM,CAmBlB;IAED;;;;;OAKG;IACH,uBAFW,aAAa,QASvB;IAED;;;OAGG;IACH,0BAHW,aAAa,GACX,OAAO,CAanB;IAgED;;;OAGG;IACH,gBAuBC;IAED,gBAcC;;CACJ;yBA5kBY,OAAO,8DAA8D,EAAE,UAAU;8BACjF,OAAO,0BAA0B,EAAE,eAAe;6BAClD,OAAO,8BAA8B,EAAE,cAAc;mCACrD,OAAO,2BAA2B,EAAE,oBAAoB;4BACxD,OAAO,4BAA4B,EAAE,aAAa;gCAnB/B,4BAA4B;gCAQ5B,4BAA4B;uCAIrB,6BAA6B"}
+{"version":3,"file":"GPUProbeClipmapGI.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/global_illumination/probe_clipmap/GPUProbeClipmapGI.js"],"names":[],"mappings":"AA8BA;;;;;;GAMG;AAEH;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH;IAwTI;;;;OAIG;IACH,oDAJW,eAAe,YACf,oBAAoB,GAClB,OAAO,CAUnB;IA5OD;;OAEG;IACH,sBAFW,eAAe,EAMzB;IAED;;OAEG;IACH,qCAEC;IAED;;OAEG;IACH,qCAEC;IAED;;OAEG;IACH,mCAEC;IAED;;OAEG;IACH,oCAEC;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH;QAZ+B,KAAK,EAAzB,UAAU;QACc,IAAI,EAA5B,cAAc;QACgB,QAAQ,EAAtC,oBAAoB;QACJ,KAAK,EAArB,MAAM;QACU,MAAM,EAAtB,MAAM;QACK,IAAI;QACE,MAAM,GAAvB,MAAM;QAEU,QAAQ,EAAxB,MAAM;aAsIhB;IAqDD;;;OAGG;IACH,0BAEC;IAED;;;;;;;;;OASG;IACH,4CAUC;IAwDD;;;;;;;;;;;;;;;;OAgBG;IACH;QAR+B,KAAK,EAAzB,UAAU;QACc,IAAI,EAA5B,cAAc;QACgB,QAAQ,EAAtC,oBAAoB;QACF,UAAU,EAA5B,MAAM,EAAE;QACQ,QAAQ;QACtB,MAAM,CA8ClB;IAED;;;;;OAKG;IACH,uBAFW,aAAa,QASvB;IAED;;;OAGG;IACH,0BAHW,aAAa,GACX,OAAO,CAanB;IAqED;;;OAGG;IACH,gBA2BC;IAED,gBAcC;;CACJ;yBA1oBY,OAAO,8DAA8D,EAAE,UAAU;8BACjF,OAAO,0BAA0B,EAAE,eAAe;6BAClD,OAAO,8BAA8B,EAAE,cAAc;mCACrD,OAAO,2BAA2B,EAAE,oBAAoB;4BACxD,OAAO,4BAA4B,EAAE,aAAa;gCA1B/B,4BAA4B;gCAa5B,4BAA4B;uCAKrB,6BAA6B"}

package/src/shade/renderer/global_illumination/probe_clipmap/GPUProbeClipmapGI.js

@@ -10,16 +10,23 @@ import { graph_import_buffer } from "../../shader/graph/graph_import_buffer.js";
 import { GPUBrickClipmap } from "./brick/GPUBrickClipmap.js";
 import { MeshSDFBrickProvider } from "./brick/mesh/MeshSDFBrickProvider.js";
 import { graph_probe_clipmap_debug_brick_clipmap } from "./debug/graph_probe_clipmap_debug_brick_clipmap.js";
-import { graph_probe_clipmap_debug_mesh_cards } from "./debug/graph_probe_clipmap_debug_mesh_cards.js";
+import { graph_probe_clipmap_debug_indirect } from "./debug/graph_probe_clipmap_debug_indirect.js";
+import {
+    graph_probe_clipmap_debug_brick_material,
+    ProbeClipmapDebugBrickMaterialChannel
+} from "./debug/graph_probe_clipmap_debug_brick_material.js";
 import { graph_probe_clipmap_debug_mesh_sdf } from "./debug/graph_probe_clipmap_debug_mesh_sdf.js";
+import { graph_probe_clipmap_debug_mesh_surfaces } from "./debug/graph_probe_clipmap_debug_mesh_surfaces.js";
 import { ProbeClipmapDebugView } from "./debug/ProbeClipmapDebugView.js";
 import { PROBE_RECORD_STRUCT } from "./probe/chunk_probe_clipmap.js";
 import { PROBE_SAMPLING_STRUCT } from "./probe/chunk_probe_clipmap_pick.js";
 import { GPUProbeClipmap } from "./probe/GPUProbeClipmap.js";
 import { PROBE_DEPTH_TEXEL_RAYS, PROBE_RAY_CASCADE_MASK, PROBE_TEXEL_RAYS } from "./probe/PROBE_CLIPMAP.js";
 import { ProbeClipmapHitWants } from "./probe/ProbeClipmapHitWants.js";
+import { ProbeClipmapIndirectLobe } from "./probe/ProbeClipmapIndirectLobe.js";
 import { ProbeClipmapScreenWants } from "./probe/ProbeClipmapScreenWants.js";
 import { ProbeClipmapSceneHolds } from "./ProbeClipmapSceneHolds.js";
+import { GPUBrickMaterial } from "./material/GPUBrickMaterial.js";
 
 /**
  * @typedef {import("../../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph} FrameGraph
@@ -44,10 +51,11 @@ import { ProbeClipmapSceneHolds } from "./ProbeClipmapSceneHolds.js";
  * readers bind while there are no probes ({@link write_sampling_bindings}): seven objects of a few bytes,
  * made on the first ask and kept until {@link destroy}.
  *
- * Each frame it holds the geometry caches and card sets its scene's SDF world draws
- * ({@link ProbeClipmapSceneHolds}), trims the caches nothing holds, and records their bake and the
- * cards' capture (§6). Leaving the mode lets go of the holds and trims nothing, so the caches are
- * there when the mode comes back (D28); the card sets go, and are captured again.
+ * Each frame it holds the geometry caches and the Model Surface Caches its scene's SDF world draws
+ * ({@link ProbeClipmapSceneHolds}), trims the geometry caches nothing holds, and records their bakes
+ * (§6). The bricks' material is gathered from the surface caches as each brick is built
+ * ({@link GPUBrickMaterial}). Leaving the mode lets go of the holds and trims nothing, so the geometry
+ * caches are there when the mode comes back (D28); the surface caches go, and are baked again.
  *
  * Until its probes are traced (§13, S4) the mode lights as IBL.
  */
@@ -127,6 +135,19 @@ export class GPUProbeClipmapGI {
      */
     #placeholders = undefined;
 
+    /**
+     * The bricks' surface material, which the probes' hits read: made with the clipmaps and given back
+     * with them.
+     * @type {GPUBrickMaterial|undefined}
+     */
+    #material = undefined;
+
+    /**
+     * What the frame's build writes after its store: the material.
+     * @type {GPUBrickMaterial[]}
+     */
+    #material_writers = [];
+
     /**
      * @param {GraphicsContext} graphics
      */
@@ -178,13 +199,17 @@ export class GPUProbeClipmapGI {
      * @param {*} options.stbn the 2-channel spatio-temporal blue noise, `STATIC_GRAPHICS_ENGINE_ASSETS.stbn_vec2`
      * @param {number} [options.movers] the graph handle of the scene's mover list for the frame,
      *   which the world's bricks are built again over
+     * @param {number} options.exposure the graph handle of the factor the display multiplies radiance by ahead of its
+     *   tone curve, as the last frame was shown (`GPUCameraExposureManager#multiplier`): what the probes'
+     *   estimators state their thresholds in
      */
-    graph_update({ graph, view, settings, depth, normal, stbn, movers = -1 }) {
+    graph_update({ graph, view, settings, depth, normal, stbn, movers = -1, exposure }) {
         assert.defined(graph, 'graph');
         assert.defined(view, 'view');
         assert.defined(settings, 'settings');
         assert.isNonNegativeInteger(depth, 'depth');
         assert.isNonNegativeInteger(normal, 'normal');
+        assert.isNonNegativeInteger(exposure, 'exposure');
         assert.notOk(this.#destroyed, 'destroyed');
 
         // the relations between fields, checked here because each setter sees only its own field
@@ -222,18 +247,18 @@ export class GPUProbeClipmapGI {
         const sdf = scene.geometries.sdf;
         sdf.configure(settings.mesh_sdf_voxel_size, settings.mesh_sdf_max_bricks);
         sdf.trim();
-        sdf.cards.capture_mode = settings.card_capture_mode;
         sdf.graph_bake({
             graph,
             budget: settings.mesh_sdf_bake_budget,
-            capture_budget: settings.card_capture_budget,
+            surface_budget: settings.surface_bake_budget,
             materials: this.#graphics.materials_resident,
-            material_contexts: this.#graphics.materials,
         });
 
-        // the card sets the capture made resident, for this frame's readers
+        // the surface caches the bake made resident, for this frame's readers
         this.#holds.flush();
 
+        this.#material.surface_rows = this.#holds.surface_rows_buffer;
+
         // the world's bricks around the view, every provider merged in order, built again where the
         // movers went and where a row's field turned resident or its SDF membership changed
         this.#brick_clipmap.invalidate_rows(this.#holds.invalidated);
@@ -248,10 +273,13 @@ export class GPUProbeClipmapGI {
             z: transform[14],
             budget: settings.brick_build_budget,
             providers: this.#providers,
+            material_writers: this.#material_writers,
             scene,
             movers,
         });
 
+        const material = this.#material;
+
         const clusters = this.#graph_clusters(graph, scene);
 
         // the probes around the same anchor, updated through the bricks (§8): the frustum's windows, and the
@@ -269,14 +297,13 @@ export class GPUProbeClipmapGI {
         world.graph_update({
             graph,
             wants: this.#hit_wants,
-            stbn,
             response_frames: settings.response_frames,
             ray_budget: settings.world_ray_budget,
             rays_per_probe: settings.world_cache_rays_per_probe,
             brick_clipmap: this.#brick_clipmap,
             bricks,
             scene,
-            card_rows: this.#holds.rows_buffer,
+            material,
             // a world cache probe re-samples nothing: its radiance has no skirt for the history's taps, and the
             // rays are the frustum's switch
             history_resampling: false,
@@ -284,6 +311,7 @@ export class GPUProbeClipmapGI {
             clusters,
             bounce_first: frustum,
             bounce_fallback: world,
+            exposure,
         });
 
         this.#screen_wants.set({ depth, normal, camera: view.camera.buffer, stbn, resolution: view.resolution });
@@ -291,19 +319,19 @@ export class GPUProbeClipmapGI {
         frustum.graph_update({
             graph,
             wants: this.#screen_wants,
-            stbn,
             response_frames: settings.response_frames,
             ray_budget: settings.frustum_ray_budget,
             rays_per_probe: settings.rays_per_probe,
             brick_clipmap: this.#brick_clipmap,
             bricks,
             scene,
-            card_rows: this.#holds.rows_buffer,
+            material,
             history_resampling: settings.history_resampling,
             ray_resampling: settings.ray_resampling,
             clusters,
             bounce_first: frustum,
             bounce_fallback: world,
+            exposure,
         });
     }
 
@@ -446,27 +474,59 @@ export class GPUProbeClipmapGI {
      * The debug view the settings ask for, in place of the frame's colour. Record it after
      * {@link graph_update} in the same frame.
      *
+     * The indirect views draw the fused indirect pass (`shader_probe_clipmap_indirect_lighting`) with one lobe
+     * alone, from `indirect`, the inputs the frame's own fused pass takes, to which they add the probes' sampling
+     * bindings ({@link write_sampling_bindings}).
+     *
      * @param {Object} options
      * @param {FrameGraph} options.graph
      * @param {GPUViewContext} options.view
      * @param {ProbeClipmapSettings} options.settings
      * @param {number[]} options.resolution
-     * @returns {number} graph handle of an `rgba8unorm` image
+     * @param {Object} options.indirect the fused indirect pass's inputs this frame, without the probes' bindings
+     * @returns {number} graph handle of the image: `rgba8unorm` for the geometry views, `rgba16float` for the
+     * indirect ones
      */
-    graph_debug_view({ graph, view, settings, resolution }) {
+    graph_debug_view({ graph, view, settings, resolution, indirect }) {
         switch (settings.debug_view) {
             case ProbeClipmapDebugView.MeshSDF:
                 return graph_probe_clipmap_debug_mesh_sdf({ graph, view, resolution });
-            case ProbeClipmapDebugView.MeshCards:
-                return graph_probe_clipmap_debug_mesh_cards({
+            case ProbeClipmapDebugView.MeshSurfaces:
+                return graph_probe_clipmap_debug_mesh_surfaces({
                     graph,
                     view,
                     resolution,
-                    cards: view.scene.geometries.sdf.cards,
-                    rows: this.#holds.rows_buffer,
+                    surfaces: view.scene.geometries.sdf.surfaces,
+                    rows: this.#holds.surface_rows_buffer,
                 });
             case ProbeClipmapDebugView.BrickClipmap:
                 return graph_probe_clipmap_debug_brick_clipmap({ graph, view, resolution, brick_clipmap: this.#brick_clipmap });
+            case ProbeClipmapDebugView.IndirectDiffuse:
+                return graph_probe_clipmap_debug_indirect({
+                    graph,
+                    lobe: ProbeClipmapIndirectLobe.Diffuse,
+                    inputs: this.write_sampling_bindings(indirect),
+                    resolution,
+                });
+            case ProbeClipmapDebugView.IndirectSpecular:
+                return graph_probe_clipmap_debug_indirect({
+                    graph,
+                    lobe: ProbeClipmapIndirectLobe.Specular,
+                    inputs: this.write_sampling_bindings(indirect),
+                    resolution,
+                });
+            case ProbeClipmapDebugView.BrickMaterial:
+            case ProbeClipmapDebugView.BrickMetalRough:
+                return graph_probe_clipmap_debug_brick_material({
+                    graph,
+                    view,
+                    resolution,
+                    brick_clipmap: this.#brick_clipmap,
+                    material: this.#material,
+                    channel: settings.debug_view === ProbeClipmapDebugView.BrickMaterial
+                        ? ProbeClipmapDebugBrickMaterialChannel.Albedo
+                        : ProbeClipmapDebugBrickMaterialChannel.MetalRough,
+                });
             default:
                 throw new Error(`no debug view to record for ${settings.debug_view}`);
         }
@@ -532,6 +592,11 @@ export class GPUProbeClipmapGI {
             voxel_size: settings.brick_voxel_size,
         });
 
+        this.#material = new GPUBrickMaterial(device, {
+            capacity: this.#brick_clipmap.capacity,
+        });
+        this.#material_writers.push(this.#material);
+
         // the frustum's slots start at 2·N²·C, a power of two: a visible surface crosses each cascade as a shell a
         // cell thick, doubled for the cage. The world cache's start there too: the surfaces that want it are the
         // frustum's hits', not the screen's, so its own lattice says nothing of how many there are
@@ -584,6 +649,10 @@ export class GPUProbeClipmapGI {
         this.#probe_clipmap.destroy();
         this.#world_cache.destroy();
         this.#mesh_provider.destroy();
+        this.#material.destroy();
+
+        this.#material = undefined;
+        this.#material_writers.length = 0;
 
         this.#mesh_provider = undefined;
         this.#order_providers();