@woosh/meep-engine 3.61.0 → 3.61.2

package/src/shade/renderer/Renderer.js

@@ -2838,6 +2838,9 @@ export class Renderer {
         let gr_texture_depth_current = gr_raster_depth;
         const gr_buffer_camera_current = graph_import_buffer(graph, view_ctx.camera.gpu_buffer, "camera/current");
         const gr_buffer_camera_previous = graph_import_buffer(graph, view_ctx.gpu_previous_camera_state.gpu_buffer, "camera/previous");
+        // the exposure the last frame was shown with, until this frame's own is written over it past the bloom: a pass
+        // recorded ahead of that reads it as the display's exposure
+        const gr_exposure_multiplier = graph_import_buffer(graph, this.#autoexposure.multiplier, "exposure multiplier");
         const gr_texture_hzb = graph_import_texture(graph, view_ctx.hierarchical_z_buffer.texture, "HZB");
         const gr_texture_environment = graph_import_texture(graph, view_ctx.scene.lights.environment);
 
@@ -3004,6 +3007,7 @@ export class Renderer {
                 normal: gr_texture_normal,
                 stbn: STATIC_GRAPHICS_ENGINE_ASSETS.stbn_vec2,
                 movers: gr_scene_movers,
+                exposure: gr_exposure_multiplier,
             });
         } else {
             this.#probe_clipmap_gi.release();
@@ -3461,13 +3465,14 @@ export class Renderer {
             exposure = this.#autoexposure.update({
                 graph,
                 input_color: metered_color,
+                multiplier: gr_exposure_multiplier,
                 time_delta_seconds,
             });
         }
 
 
         if (this.feature_automatic_exposure_enabled === false) {
-            exposure = this.#autoexposure.unadapted({ graph });
+            exposure = this.#autoexposure.unadapted({ graph, multiplier: gr_exposure_multiplier });
         }
 
 

package/src/shade/renderer/buffer/graph_read_buffer.d.ts

@@ -5,7 +5,9 @@
  * @param {number} buffer
  * @param {number} [offset=0]
  * @param {number} [size] defaults to buffer.size - offset
- * @param {number} [timeout] in milliseconds, 0 for no timeout. Timeout will start immediately, meaning that if you don't schedule the graph immediately - you might see unexpected behaviour.
+ * @param {number} [timeout] in milliseconds, 0 for no timeout: how long the read waits for its pass to run, starting
+ * now. A graph that is never run, or stops at a throwing pass before this one, rejects the read here. Once the pass has
+ * run, the read waits for the device however far behind it is, and settles when the mapping does.
  * @returns {Promise<Reference<ArrayBuffer>>} don't forget to release the reference
  */
 export function graph_read_buffer({ graph, buffer, offset, size, timeout }: FrameGraph): Promise<Reference<ArrayBuffer>>;

package/src/shade/renderer/buffer/graph_read_buffer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graph_read_buffer.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/buffer/graph_read_buffer.js"],"names":[],"mappings":"AAOA;;;;;;;;;GASG;AACH,yFAFa,QAAQ,UAAU,WAAW,CAAC,CAAC,CAuH3C;0BApIyB,2CAA2C"}
+{"version":3,"file":"graph_read_buffer.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/buffer/graph_read_buffer.js"],"names":[],"mappings":"AAOA;;;;;;;;;;;GAWG;AACH,yFAFa,QAAQ,UAAU,WAAW,CAAC,CAAC,CAwH3C;0BAvIyB,2CAA2C"}

package/src/shade/renderer/buffer/graph_read_buffer.js

@@ -12,7 +12,9 @@ const scratch_buffer_descriptor = new BufferResourceDescriptor();
  * @param {number} buffer
  * @param {number} [offset=0]
  * @param {number} [size] defaults to buffer.size - offset
- * @param {number} [timeout] in milliseconds, 0 for no timeout. Timeout will start immediately, meaning that if you don't schedule the graph immediately - you might see unexpected behaviour.
+ * @param {number} [timeout] in milliseconds, 0 for no timeout: how long the read waits for its pass to run, starting
+ * now. A graph that is never run, or stops at a throwing pass before this one, rejects the read here. Once the pass has
+ * run, the read waits for the device however far behind it is, and settles when the mapping does.
  * @returns {Promise<Reference<ArrayBuffer>>} don't forget to release the reference
  */
 export function graph_read_buffer({
@@ -47,6 +49,12 @@ export function graph_read_buffer({
      * @param {GraphicsExecutionContext} context
      */
     function execute(data, resources, context) {
+        // the copy is recorded: the mapping lands, or is refused, however long the device takes
+        if (timeout_handle !== -1) {
+            clearTimeout(timeout_handle);
+            timeout_handle = -1;
+        }
+
         /**
          * @type {GPUBuffer}
          */
@@ -94,11 +102,6 @@ export function graph_read_buffer({
                 return;
             }
 
-            if (timeout_handle !== -1) {
-                clearTimeout(timeout_handle);
-                timeout_handle = -1;
-            }
-
             const data = destination.getMappedRange(0, _size);
 
             ref = new Reference();

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

@@ -68,8 +68,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 +80,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.

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":"AAuBA;;;;;;GAMG;AAEH;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH;IAwSI;;;;OAIG;IACH,oDAJW,eAAe,YACf,oBAAoB,GAClB,OAAO,CAUnB;IAzOD;;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;aAmIhB;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;yBAhlBY,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"}

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

@@ -178,13 +178,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
@@ -269,7 +273,6 @@ 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,
@@ -284,6 +287,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,7 +295,6 @@ 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,
@@ -304,6 +307,7 @@ export class GPUProbeClipmapGI {
             clusters,
             bounce_first: frustum,
             bounce_fallback: world,
+            exposure,
         });
     }
 

package/src/shade/renderer/global_illumination/probe_clipmap/probe/GPUProbeClipmap.d.ts

@@ -13,7 +13,7 @@
  *   stacked along z: the slot of the point's probe, or none. Allocated whole, since the lattice follows
  *   from the structure alone.
  * - a slot each: a state of two words, the kind and updates and then where relocation moved it
- *   (`PROBE_CLIPMAP.js`), a 48-byte record (`PROBE_RECORD_STRUCT`), an octahedral radiance tile of
+ *   (`PROBE_CLIPMAP.js`), a 64-byte record (`PROBE_RECORD_STRUCT`), an octahedral radiance tile of
  *   {@link radiance_resolution}² texels and a depth-moment tile of {@link depth_resolution}², in two 2-D
  *   tile atlases. The depth tile has a one-texel skirt, which the pick's bilinear tap reads; the radiance
  *   tile has one where {@link radiance_skirt}, for the specular's tap, and none where nothing samples it.
@@ -211,7 +211,6 @@ export class GPUProbeClipmap {
      * @param {Object} options
      * @param {FrameGraph} options.graph
      * @param {ProbeClipmapWants} options.wants who wants the frame's probes
-     * @param {*} options.stbn the 2-channel spatio-temporal blue noise, `STATIC_GRAPHICS_ENGINE_ASSETS.stbn_vec2`
      * @param {number} options.response_frames frames over which a re-sampled neighbour's history goes stale, τ
      * @param {number} options.ray_budget rays a frame
      * @param {number} options.rays_per_probe rays an update, R: the frame updates ⌊ray_budget / R⌋ probes at most
@@ -230,11 +229,13 @@ export class GPUProbeClipmap {
      *   bricks' cascades, which the hits' local lights come from
      * @param {GPUProbeClipmap} options.bounce_first the clipmap a hit takes its next bounce from first
      * @param {GPUProbeClipmap} options.bounce_fallback the clipmap it takes it from where the first has no probe
+     * @param {number} options.exposure the graph handle of the factor the display multiplies radiance by ahead of its
+     *   tone curve, a single f32, as the last frame was shown: the exposure the probes' estimators state their
+     *   thresholds in
      */
-    graph_update({ graph, wants, stbn, response_frames, ray_budget, rays_per_probe, brick_clipmap, bricks, scene, card_rows, history_resampling, ray_resampling, clusters, bounce_first, bounce_fallback }: {
+    graph_update({ graph, wants, response_frames, ray_budget, rays_per_probe, brick_clipmap, bricks, scene, card_rows, history_resampling, ray_resampling, clusters, bounce_first, bounce_fallback, exposure }: {
         graph: FrameGraph;
         wants: ProbeClipmapWants;
-        stbn: any;
         response_frames: number;
         ray_budget: number;
         rays_per_probe: number;
@@ -250,6 +251,7 @@ export class GPUProbeClipmap {
         };
         bounce_first: GPUProbeClipmap;
         bounce_fallback: GPUProbeClipmap;
+        exposure: number;
     }): void;
     destroy(): void;
     #private;

package/src/shade/renderer/global_illumination/probe_clipmap/probe/GPUProbeClipmap.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUProbeClipmap.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/GPUProbeClipmap.js"],"names":[],"mappings":"AAiIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmDG;AACH;IA4QI;;;;;;;;;;;;;;;;;OAiBG;IACH;QAf2B,aAAa,EAA7B,MAAM;QAEU,UAAU,EAA1B,MAAM;QAGU,OAAO,EAAvB,MAAM;QACU,mBAAmB,EAAnC,MAAM;QAEU,gBAAgB,EAAhC,MAAM;QACW,cAAc,EAA/B,OAAO;QAES,KAAK,EAArB,MAAM;QACU,QAAQ,EAAxB,MAAM;OA8GhB;IAxYD;;;OAGG;IACH,wBAHU,MAAM,CAGF;IAEd;;;;OAIG;IACH,qBAHU,MAAM,CAGL;IAEX;;;;OAIG;IACH,kBAHU,MAAM,CAGR;IAER;;;;OAIG;IACH,8BAHU,MAAM,CAGI;IAEpB;;;;OAIG;IACH,2BAHU,MAAM,CAGC;IAEjB;;;;;OAKG;IACH,yBAHU,OAAO,CAGF;IAEf;;;;OAIG;IACH,gBAHU,MAAM,CAGV;IA2VN;;;;;;;;OAQG;IACH,4CAUC;IAED;;OAEG;IACH,8BAEC;IAED;;;;;OAKG;IACH,uBAEC;IAED;;;OAGG;IACH,yBAEC;IAED;;;OAGG;IACH,sBAEC;IAGD;;;OAGG;IACH,0BAEC;IAED;;;;;OAKG;IACH,wBAEC;IAED;;;OAGG;IACH,uBAEC;IAED;;;;OAIG;IACH,gBAJW,MAAM,QACN,MAAM,GACJ,MAAM,CAIlB;IAED;;;OAGG;IACH,mBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;OAGG;IACH,oBAHW,oBAAoB,GAClB,OAAO,CAQnB;IAED;;;;;;;OAOG;IACH,SAJW,MAAM,KACN,MAAM,KACN,MAAM,QA6BhB;IAED;;;;;;;OAOG;IACH,sBAFW,eAAe,QA2BzB;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2BG;IACH;QAtB+B,KAAK,EAAzB,UAAU;QACiB,KAAK,EAAhC,iBAAiB;QACN,IAAI;QACC,eAAe,EAA/B,MAAM;QACU,UAAU,EAA1B,MAAM;QACU,cAAc,EAA9B,MAAM;QACyD,aAAa,EAA5E,OAAO,6BAA6B,EAAE,eAAe;QAErC,MAAM,EAAtB,MAAM;QAE+D,KAAK,EAA1E,OAAO,mCAAmC,EAAE,eAAe;QAExC,SAAS;QACX,kBAAkB,EAAnC,OAAO;QAEU,cAAc,EAA/B,OAAO;QAEiC,QAAQ,EAAhD;YAAC,MAAM,EAAE,MAAM,CAAC;YAAC,IAAI,EAAE,MAAM,CAAA;SAAC;QAEL,YAAY,EAArC,eAAe;QACU,eAAe,EAAxC,eAAe;aAiOzB;IAshBD,gBAcC;;CACJ;mCAz7CY,OAAO,4BAA4B,EAAE,oBAAoB;yBACzD,OAAO,iEAAiE,EAAE,UAAU;gCACpF,OAAO,8BAA8B,EAAE,uBAAuB,GAAC,OAAO,2BAA2B,EAAE,oBAAoB"}
+{"version":3,"file":"GPUProbeClipmap.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/GPUProbeClipmap.js"],"names":[],"mappings":"AAiIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmDG;AACH;IA4QI;;;;;;;;;;;;;;;;;OAiBG;IACH;QAf2B,aAAa,EAA7B,MAAM;QAEU,UAAU,EAA1B,MAAM;QAGU,OAAO,EAAvB,MAAM;QACU,mBAAmB,EAAnC,MAAM;QAEU,gBAAgB,EAAhC,MAAM;QACW,cAAc,EAA/B,OAAO;QAES,KAAK,EAArB,MAAM;QACU,QAAQ,EAAxB,MAAM;OA8GhB;IAxYD;;;OAGG;IACH,wBAHU,MAAM,CAGF;IAEd;;;;OAIG;IACH,qBAHU,MAAM,CAGL;IAEX;;;;OAIG;IACH,kBAHU,MAAM,CAGR;IAER;;;;OAIG;IACH,8BAHU,MAAM,CAGI;IAEpB;;;;OAIG;IACH,2BAHU,MAAM,CAGC;IAEjB;;;;;OAKG;IACH,yBAHU,OAAO,CAGF;IAEf;;;;OAIG;IACH,gBAHU,MAAM,CAGV;IA2VN;;;;;;;;OAQG;IACH,4CAUC;IAED;;OAEG;IACH,8BAEC;IAED;;;;;OAKG;IACH,uBAEC;IAED;;;OAGG;IACH,yBAEC;IAED;;;OAGG;IACH,sBAEC;IAGD;;;OAGG;IACH,0BAEC;IAED;;;;;OAKG;IACH,wBAEC;IAED;;;OAGG;IACH,uBAEC;IAED;;;;OAIG;IACH,gBAJW,MAAM,QACN,MAAM,GACJ,MAAM,CAIlB;IAED;;;OAGG;IACH,mBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;OAGG;IACH,oBAHW,oBAAoB,GAClB,OAAO,CAQnB;IAED;;;;;;;OAOG;IACH,SAJW,MAAM,KACN,MAAM,KACN,MAAM,QA6BhB;IAED;;;;;;;OAOG;IACH,sBAFW,eAAe,QA2BzB;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IACH;QAxB+B,KAAK,EAAzB,UAAU;QACiB,KAAK,EAAhC,iBAAiB;QACD,eAAe,EAA/B,MAAM;QACU,UAAU,EAA1B,MAAM;QACU,cAAc,EAA9B,MAAM;QACyD,aAAa,EAA5E,OAAO,6BAA6B,EAAE,eAAe;QAErC,MAAM,EAAtB,MAAM;QAE+D,KAAK,EAA1E,OAAO,mCAAmC,EAAE,eAAe;QAExC,SAAS;QACX,kBAAkB,EAAnC,OAAO;QAEU,cAAc,EAA/B,OAAO;QAEiC,QAAQ,EAAhD;YAAC,MAAM,EAAE,MAAM,CAAC;YAAC,IAAI,EAAE,MAAM,CAAA;SAAC;QAEL,YAAY,EAArC,eAAe;QACU,eAAe,EAAxC,eAAe;QACC,QAAQ,EAAxB,MAAM;aAmOhB;IAqhBD,gBAcC;;CACJ;mCA17CY,OAAO,4BAA4B,EAAE,oBAAoB;yBACzD,OAAO,iEAAiE,EAAE,UAAU;gCACpF,OAAO,8BAA8B,EAAE,uBAAuB,GAAC,OAAO,2BAA2B,EAAE,oBAAoB"}

package/src/shade/renderer/global_illumination/probe_clipmap/probe/GPUProbeClipmap.js

@@ -142,7 +142,7 @@ const SAMPLING_RADIANCE_TILES_PER_ROW_RECIPROCAL = PROBE_SAMPLING_STRUCT.get("ra
  *   stacked along z: the slot of the point's probe, or none. Allocated whole, since the lattice follows
  *   from the structure alone.
  * - a slot each: a state of two words, the kind and updates and then where relocation moved it
- *   (`PROBE_CLIPMAP.js`), a 48-byte record (`PROBE_RECORD_STRUCT`), an octahedral radiance tile of
+ *   (`PROBE_CLIPMAP.js`), a 64-byte record (`PROBE_RECORD_STRUCT`), an octahedral radiance tile of
  *   {@link radiance_resolution}² texels and a depth-moment tile of {@link depth_resolution}², in two 2-D
  *   tile atlases. The depth tile has a one-texel skirt, which the pick's bilinear tap reads; the radiance
  *   tile has one where {@link radiance_skirt}, for the specular's tap, and none where nothing samples it.
@@ -422,9 +422,9 @@ export class GPUProbeClipmap {
     /** The ray counts' scan's, which names its buffers its own way. */
     #ray_scan_bindings = { scan_in: null, scan_out: null, spine: null, command: null };
 
-    #lifetime_data = { counters: -1, stbn: -1, want_depth: -1, want_normal: -1 };
+    #lifetime_data = { counters: -1, want_depth: -1, want_normal: -1 };
 
-    #update_data = { counters: -1, bricks: -1, world_cluster_lookup: -1, world_cluster_data: -1 };
+    #update_data = { counters: -1, bricks: -1, world_cluster_lookup: -1, world_cluster_data: -1, exposure: -1 };
 
     /** The frame's wants. @type {ProbeClipmapWants|null} */
     #wants = null;
@@ -764,7 +764,6 @@ export class GPUProbeClipmap {
      * @param {Object} options
      * @param {FrameGraph} options.graph
      * @param {ProbeClipmapWants} options.wants who wants the frame's probes
-     * @param {*} options.stbn the 2-channel spatio-temporal blue noise, `STATIC_GRAPHICS_ENGINE_ASSETS.stbn_vec2`
      * @param {number} options.response_frames frames over which a re-sampled neighbour's history goes stale, τ
      * @param {number} options.ray_budget rays a frame
      * @param {number} options.rays_per_probe rays an update, R: the frame updates ⌊ray_budget / R⌋ probes at most
@@ -783,11 +782,13 @@ export class GPUProbeClipmap {
      *   bricks' cascades, which the hits' local lights come from
      * @param {GPUProbeClipmap} options.bounce_first the clipmap a hit takes its next bounce from first
      * @param {GPUProbeClipmap} options.bounce_fallback the clipmap it takes it from where the first has no probe
+     * @param {number} options.exposure the graph handle of the factor the display multiplies radiance by ahead of its
+     *   tone curve, a single f32, as the last frame was shown: the exposure the probes' estimators state their
+     *   thresholds in
      */
-    graph_update({ graph, wants, stbn, response_frames, ray_budget, rays_per_probe, brick_clipmap, bricks, scene, card_rows, history_resampling, ray_resampling, clusters, bounce_first, bounce_fallback }) {
+    graph_update({ graph, wants, response_frames, ray_budget, rays_per_probe, brick_clipmap, bricks, scene, card_rows, history_resampling, ray_resampling, clusters, bounce_first, bounce_fallback, exposure }) {
         assert.defined(graph, 'graph');
         assert.defined(wants, 'wants');
-        assert.defined(stbn, 'stbn');
         assert.isFinite(response_frames, 'response_frames');
         assert.greaterThan(response_frames, 0, 'response_frames');
         assert.isPositiveInteger(rays_per_probe, 'rays_per_probe');
@@ -803,6 +804,7 @@ export class GPUProbeClipmap {
         assert.isNonNegativeInteger(clusters.data, 'clusters.data');
         assert.defined(bounce_first, 'bounce_first');
         assert.defined(bounce_fallback, 'bounce_fallback');
+        assert.isNonNegativeInteger(exposure, 'exposure');
         assert.equal(this.#placed_frame, this.#frame, 'windows placed this frame: place() or place_within() first');
         assert.notOk(this.#destroyed, 'destroyed');
 
@@ -971,7 +973,6 @@ export class GPUProbeClipmap {
         const pass = graph.add(`${this.label} Lifetime`, data, this.#execute_lifetime);
 
         data.counters = pass.write(graph_import_buffer(graph, this.#counters, `${this.label} counters`));
-        data.stbn = stbn;
 
         wants.graph_declare(pass, data);
 
@@ -985,6 +986,7 @@ export class GPUProbeClipmap {
         update_data.bricks = update.read(bricks);
         update_data.world_cluster_lookup = update.read(clusters.lookup);
         update_data.world_cluster_data = update.read(clusters.data);
+        update_data.exposure = update.read(exposure);
 
         update.make_side_effect();
 
@@ -1191,8 +1193,6 @@ export class GPUProbeClipmap {
             command_offset: 4 * PROBE_DISPATCH_ACTIVE,
         });
 
-        b.tSTBN_vec2 = data.stbn;
-
         // the frame's wants, into the wanted bits and list
         const want = this.#want_bindings;
 
@@ -1420,6 +1420,7 @@ export class GPUProbeClipmap {
         this.write_sampling_bindings(b);
         b.probe_resamples = this.#resamples;
         b.probe_estimators = this.#estimators;
+        b.probe_exposure = resources.get(data.exposure);
 
         if (this.#history_resampling) {
             b.settings = this.#resample_settings;

package/src/shade/renderer/global_illumination/probe_clipmap/probe/PROBE_CLIPMAP.d.ts

@@ -195,6 +195,18 @@ export const PROBE_RELOCATION_STEPS: number;
  * @type {number}
  */
 export const PROBE_RAY_ORIGIN_JITTER: number;
+/**
+ * The stream of a ray's noise (`probe_clipmap_ray_noise`) that jitters its direction inside its texel.
+ * @type {number}
+ */
+export const PROBE_RAY_NOISE_JITTER: number;
+/**
+ * The stream of a ray's noise that picks the probes at its hit for the next bounce. It is drawn apart from
+ * the jitter, which places the hit: a weighted pick is unbiased only when its noise is independent of the
+ * weights.
+ * @type {number}
+ */
+export const PROBE_RAY_NOISE_PICK: number;
 /**
  * A miss's depth sample, and the most any sample is, in spacings: the farthest a cage tests a probe's depth,
  * (1 + {@link PROBE_RELOCATION_LIMIT})·√3 (D9). A biased point lies within a spacing of the corner's lattice

package/src/shade/renderer/global_illumination/probe_clipmap/probe/PROBE_CLIPMAP.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"PROBE_CLIPMAP.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/PROBE_CLIPMAP.js"],"names":[],"mappings":"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"}
+{"version":3,"file":"PROBE_CLIPMAP.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/PROBE_CLIPMAP.js"],"names":[],"mappings":"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"}

package/src/shade/renderer/global_illumination/probe_clipmap/probe/PROBE_CLIPMAP.js

@@ -229,6 +229,20 @@ export const PROBE_RELOCATION_STEPS = 3;
  */
 export const PROBE_RAY_ORIGIN_JITTER = 1 / 16;
 
+/**
+ * The stream of a ray's noise (`probe_clipmap_ray_noise`) that jitters its direction inside its texel.
+ * @type {number}
+ */
+export const PROBE_RAY_NOISE_JITTER = 0x510E527F;
+
+/**
+ * The stream of a ray's noise that picks the probes at its hit for the next bounce. It is drawn apart from
+ * the jitter, which places the hit: a weighted pick is unbiased only when its noise is independent of the
+ * weights.
+ * @type {number}
+ */
+export const PROBE_RAY_NOISE_PICK = 0x9B05688C;
+
 /**
  * A miss's depth sample, and the most any sample is, in spacings: the farthest a cage tests a probe's depth,
  * (1 + {@link PROBE_RELOCATION_LIMIT})·√3 (D9). A biased point lies within a spacing of the corner's lattice