@woosh/meep-engine 3.58.0 → 3.60.0

package/src/shade/renderer/postprocess/taa/TAA.js

@@ -1,6 +1,7 @@
 //
 
 
+import { assert } from "../../../../core/assert.js";
 import { TemporalJitterSequence } from "../TemporalJitterSequence.js";
 import { graph_image_pass } from "../../shader/graph/graph_image_pass.js";
 import { shader_taa } from "./shader_taa.js";
@@ -86,7 +87,8 @@ export class TAA {
      * @param {number} options.texture_color_history
      * @param {number} options.texture_output
      * @param {number} options.texture_occlusion depth-clip pass output: confidence in r, nearest-depth offset in g
-     * @param view
+     * @param {ArrayLike<number>} options.output_resolution size of `texture_output`; the history keeps
+     *   the size it was resolved at across a resize
      */
     graph_pass({
                    graph,
@@ -95,7 +97,9 @@ export class TAA {
                    texture_color_history = -1,
                    texture_output,
                    texture_occlusion = -1,
+                   output_resolution,
                }) {
+        assert.isArrayLike(output_resolution, 'output_resolution');
 
         const history_validity = this.reset_history ? 0.0 : 1.0;
 
@@ -112,6 +116,7 @@ export class TAA {
                 tOcclusion: texture_occlusion,
                 settings: {
                     jitter: this.Jitter,
+                    output_resolution,
                     history_validity,
                 }
             },

package/src/shade/renderer/postprocess/taa/chunk_fsr2_compute_depth_clip.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_fsr2_compute_depth_clip.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/taa/chunk_fsr2_compute_depth_clip.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,4CAFU,SAAS,CA6FjB;0BAzHwB,oCAAoC"}
+{"version":3,"file":"chunk_fsr2_compute_depth_clip.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/taa/chunk_fsr2_compute_depth_clip.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,4CAFU,SAAS,CAkGjB;0BA9HwB,oCAAoC"}

package/src/shade/renderer/postprocess/taa/chunk_fsr2_compute_depth_clip.js

@@ -42,11 +42,16 @@ fn fsr2_compute_depth_clip(
     render_size: vec2<i32>
 ) -> f32 {
     let fCurrentDepthViewSpace = get_view_space_depth(current_depth_sample, camera_current);
-    
+
+    // previous_coord is in this frame's pixels, and the previous depth keeps the size it was drawn
+    // at across a resolution change, so carry the position into its grid. Equal sizes scale by 1.
+    let previous_size = vec2<i32>(textureDimensions(PrevDepthBuffer));
+    let previous_st = previous_coord * vec2<f32>(previous_size) / vec2<f32>(render_size);
+
     // matches FSR2's GetBilinearSamplingData: iBasePos = floor(prev_coord - 0.5).
     // floor (not truncate) so the bilinear footprint stays correct for negative coords.
-    let sample_coord_fract = fract(previous_coord + 0.5);
-    let sample_coord_i = vec2<i32>(floor(previous_coord - 0.5));
+    let sample_coord_fract = fract(previous_st + 0.5);
+    let sample_coord_i = vec2<i32>(floor(previous_st - 0.5));
     let bilinear_weights = get_bilinear_weights(sample_coord_fract);
 
     var fDilatedSum = 0.0f;
@@ -68,14 +73,14 @@ fn fsr2_compute_depth_clip(
         let iOffset = offsets[iSampleIndex];
         let iSamplePos = sample_coord_i + iOffset;
 
-        if (is_on_screen_i32(iSamplePos, render_size)) {
+        if (is_on_screen_i32(iSamplePos, previous_size)) {
             let fWeight = bilinear_weights[iSampleIndex];
             
             if (fWeight > fReconstructedDepthBilinearWeightThreshold) {
 
                 // 2x2 min-gather of raw prev depth picks the FARTHEST in inverted
                 // depth — see the file docstring for why this is intentional.
-                let fPrevDepthSample = texture_sample_red_min_st(PrevDepthBuffer, previous_coord + vec2<f32>(iOffset) - 0.5, 0);
+                let fPrevDepthSample = texture_sample_red_min_st(PrevDepthBuffer, previous_st + vec2<f32>(iOffset) - 0.5, 0);
                 let fPrevNearestDepthViewSpace = get_view_space_depth(fPrevDepthSample, camera_previous);
 
                 let fDepthDiff = fCurrentDepthViewSpace - fPrevNearestDepthViewSpace;

package/src/shade/renderer/postprocess/taa/shader_taa.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_taa.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/taa/shader_taa.js"],"names":[],"mappings":"AAwCA,+CAAgD;AAGhD;;;GAGG;AACH,4CAFU,SAAS,CASjB;AAEF;;;;GAIG;AACH,gDAFU,SAAS,CAgBjB;AA+LF,qCAaG;0BAhRuB,oCAAoC;4BAClC,6BAA6B"}
+{"version":3,"file":"shader_taa.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/taa/shader_taa.js"],"names":[],"mappings":"AA6CA,+CAAgD;AAGhD;;;GAGG;AACH,4CAFU,SAAS,CASjB;AAEF;;;;GAIG;AACH,gDAFU,SAAS,CAgBjB;AA6LF,qCAaG;0BAnRuB,oCAAoC;4BAClC,6BAA6B"}

package/src/shade/renderer/postprocess/taa/shader_taa.js

@@ -1,6 +1,6 @@
 import { f32, vec2f } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
 import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
-import { chunk_aabb3_normalized_dist } from "../../shader/chunk/geometry/aabb3/chunk_line_aabb3_clipping_distance.js";
+import { chunk_aabb3_normalized_dist } from "../../shader/chunk/geometry/aabb3/chunk_line_aabb3_clipping_distance.js";
 import { F16_MAX_DEFINITION } from "../../shader/chunk/math/F16_MAX_DEFINITION.js";
 import {
     chunk_texture_sample_catmullrom_hardware_5tap_uv
@@ -18,6 +18,11 @@ import { chunk_taa_history_color_bounding_box_YCoCg } from "./chunk_taa_history_
 
 const TAA_SETTINGS_STRUCT = WebGPUStruct.from({
     jitter: vec2f,
+    /**
+     * Size of the target this pass resolves into, in pixels. Not the history's: across a resize the
+     * history keeps the size it was resolved at, and is read by uv.
+     */
+    output_resolution: vec2f,
     /**
      * Used to reset history, should be 1.0 except when reset is required
      */
@@ -26,12 +31,12 @@ const TAA_SETTINGS_STRUCT = WebGPUStruct.from({
 
 const resources = new ShaderResourceSetDescriptor();
 
-// per-pass, 16 bytes, read-only: immediate data rather than a uniform buffer.
+// per-pass, 24 bytes, read-only: immediate data rather than a uniform buffer.
 resources.setImmediate("settings", TAA_SETTINGS_STRUCT);
 resources.createGroup()
     .addSampler("sLinear", "filtering", SAMPLER_LINEAR_UPSCALE)
     .addTexture("VelocityBuffer", "float") // raw velocity, in internal pixels
-    .addTexture("HistoryTexture", "float") // previous resolved frame, at output resolution.
+    .addTexture("HistoryTexture", "float") // previous resolved frame, at the output resolution it was resolved at.
     .addTexture("ColourTexture", "float") // incoming frame, drawn at internal resolution. Typically lower than output.
     .addTexture("tOcclusion", "float") // depth-clip pass output at internal resolution: r confidence, g nearest-depth offset
 ;
@@ -87,9 +92,7 @@ const body = CodeChunk.from(
 //language=WGSL
     `
 fn uv_within_screen( pixel:vec2<f32> ) -> f32{
-    let render_size = textureDimensions(HistoryTexture);
-
-    if(  all( pixel >= vec2( 0.f, 0.f ) ) && all( pixel < vec2f( render_size ) )  ){ 
+    if(  all( pixel >= vec2( 0.f, 0.f ) ) && all( pixel < settings.output_resolution )  ){ 
         return 1.0f;
     } else{
         return  0.f;
@@ -102,10 +105,10 @@ fn main(
     @location(0) uv: vec2<f32>,
 ) -> @location(0) vec4<f32> {
     let resolution_internal = textureDimensions(ColourTexture).xy;
-    let resolution_output = textureDimensions(HistoryTexture).xy;
+    let resolution_output = settings.output_resolution;
     
-    let resolution_ratio = vec2<f32>(resolution_internal.xy) / vec2<f32>(resolution_output.xy);
-    let upscale_ratio = f32(resolution_output.x) / f32(resolution_internal.x);
+    let resolution_ratio = vec2<f32>(resolution_internal.xy) / resolution_output;
+    let upscale_ratio = resolution_output.x / f32(resolution_internal.x);
 
     // positive jitter shifts rendered content right/down by settings.jitter internal pixels (see
     // GPUCameraContext), so the un-jittered content of this output pixel sits at uv + jitter / resolution
@@ -145,14 +148,14 @@ fn main(
         ColourTexture,
         sLinear,
         jittered_uv, 
-    ).rgb;
+    ).rgb;
     let color_current_raw = select(vec3(0.0), clamp(color_current_sample, vec3(0.0), vec3(F16_MAX)), color_current_sample == color_current_sample);
 
     var final_colour:vec4<f32>;
     
     if ( true == hasValidHistory ) {
         
-        let prev_uv = (prevFrameScreenST) / vec2<f32>(resolution_output);
+        let prev_uv = prevFrameScreenST / resolution_output;
     
         // sample history
         var color_history_raw = texture_sample_catmullrom_hardware_5tap_uv( HistoryTexture, sLinear, prev_uv );    
@@ -251,7 +254,7 @@ fn main(
     return final_colour.rgba;
 }
 `, [
-        F16_MAX_DEFINITION,
+        F16_MAX_DEFINITION,
         chunk_taa_decode_color,
         chunk_taa_encode_color,
         chunk_taa_history_color_bounding_box_YCoCg,

package/src/shade/renderer/postprocess/velocity/graph_add_per_object_velocity.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graph_add_per_object_velocity.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/velocity/graph_add_per_object_velocity.js"],"names":[],"mappings":"AA0QA;;;;GAIG;AACH,+DAFW,eAAe,QAIzB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;AACH;IAjB4B,KAAK;IACT,aAAa,EAA1B,MAAM;IACO,gBAAgB,EAA7B,MAAM;IACO,oBAAoB,EAAjC,MAAM;IACO,qBAAqB,EAAlC,MAAM;IACO,uBAAuB,EAApC,MAAM;IACO,mBAAmB,EAAhC,MAAM;IACO,4BAA4B,EAAzC,MAAM;IACO,qBAAqB,EAAlC,MAAM;IACQ,eAAe,EAA7B,OAAO;IAGQ,UAAU,EAAzB,MAAM,EAAE;IACa,IAAI;IACV,aAAa,GAA5B,OAAO;IACL,MAAM,CAgFlB;8BA5WY,OAAO,6CAA6C,EAAE,eAAe"}
+{"version":3,"file":"graph_add_per_object_velocity.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/velocity/graph_add_per_object_velocity.js"],"names":[],"mappings":"AAmRA;;;;GAIG;AACH,+DAFW,eAAe,QAIzB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;AACH;IAjB4B,KAAK;IACT,aAAa,EAA1B,MAAM;IACO,gBAAgB,EAA7B,MAAM;IACO,oBAAoB,EAAjC,MAAM;IACO,qBAAqB,EAAlC,MAAM;IACO,uBAAuB,EAApC,MAAM;IACO,mBAAmB,EAAhC,MAAM;IACO,4BAA4B,EAAzC,MAAM;IACO,qBAAqB,EAAlC,MAAM;IACQ,eAAe,EAA7B,OAAO;IAGQ,UAAU,EAAzB,MAAM,EAAE;IACa,IAAI;IACV,aAAa,GAA5B,OAAO;IACL,MAAM,CAgFlB;8BArXY,OAAO,6CAA6C,EAAE,eAAe"}

package/src/shade/renderer/postprocess/velocity/graph_add_per_object_velocity.js

@@ -96,19 +96,24 @@ fn main(
 ) -> @location(0) vec2<f32> {
 
     let cur_px = coord.xy;
-    let cur_depth = textureLoad(tDepth, vec2<u32>(coord.xy), 0).r;
-    let mesh_id = textureLoad(tVizMesh, vec2<u32>(coord.xy), 0).r;
+    let texel = vec2<u32>(cur_px);
+    let mesh_id = textureLoad(tVizMesh, texel, 0).r;
 
     // ── Background: rotation-only reprojection ──────────────────
+    //
+    // Visibility-buffer clears leave mesh_id == VIZ_INVALID on sky
+    // pixels, where reverse-Z depth is always 0.0. Passing 0.0
+    // directly avoids a tDepth textureLoad on every background pixel.
     if mesh_id == VIZ_INVALID {
         let position_previous = v3_matrix4_project(
-            vec3<f32>(cur_px, cur_depth),
+            vec3<f32>(cur_px, 0.0),
             mReprojectionRotation
         );
         return cur_px - position_previous.xy;
     }
 
     // ── Reconstruct world-space position for this pixel ─────────
+    let cur_depth = textureLoad(tDepth, texel, 0).r;
     let res = vec2<f32>(textureDimensions(tDepth));
     let cur_ndc = vec3<f32>(
         cur_px.x / res.x * 2.0 - 1.0,
@@ -128,21 +133,24 @@ fn main(
     // triangle-within-meshlet. Look up the per-meshlet
     // prev-position offset; sentinel means "not a skinned clone,
     // use rigid per-object math".
-    let triangle_packed = textureLoad(tVizTriangle, vec2<u32>(coord.xy), 0).r;
-    let meshlet_id = (triangle_packed >> 8u) & 0x00FFFFFFu;
-    let tri_local = triangle_packed & 0xFFu;
-
+    //
     // The per-vertex skinning path reads prev_position_offsets /
     // prev_positions, which only hold valid data when a skinned mesh is
     // registered. When skinning is inactive those are placeholder
     // bindings (the scene_database buffer) and reading them would feed
     // garbage offsets into the skinned branch — a non-sentinel word
     // there sends a static triangle down the per-vertex path and
-    // fabricates a constant phantom velocity. Gate the read on
-    // skinning_active and hold the sentinel otherwise, so every pixel
-    // takes the rigid per-object path.
+    // fabricates a constant phantom velocity. Gate both the tVizTriangle
+    // textureLoad and the offset buffer read on skinning_active so
+    // non-skinned scenes skip the full-screen tVizTriangle fetch and
+    // every pixel takes the rigid per-object path.
+    var meshlet_id = 0u;
+    var tri_local = 0u;
     var prev_pos_base = PREV_POS_OFFSET_INVALID;
     if skinning_active.value != 0u {
+        let triangle_packed = textureLoad(tVizTriangle, texel, 0).r;
+        meshlet_id = (triangle_packed >> 8u) & 0x00FFFFFFu;
+        tri_local = triangle_packed & 0xFFu;
         prev_pos_base = prev_position_offsets[meshlet_id];
     }
 
@@ -151,13 +159,14 @@ fn main(
     if prev_pos_base == PREV_POS_OFFSET_INVALID {
         // ── Rigid fallback (static or non-skinned animated) ─────
         //
-        // Per-object motion only: displacement = prev_global ×
-        // inverse(global) maps the current world point back to where
-        // the same mesh-local point sat in the previous frame's
-        // world. Same math as Stage 1.
-        let inv_global = mat4_inverse(node.global);
-        let displacement = node.prev_global * inv_global;
-        let prev_world_h = displacement * vec4<f32>(cur_world, 1.0);
+        // Per-object motion only: inverse(global) maps the current
+        // world point back to mesh-local space, and prev_global
+        // transforms it to where that point sat in the previous
+        // frame's world. Associating right-to-left (two mat4 × vec4
+        // products instead of a mat4 × mat4 plus a mat4 × vec4)
+        // saves 48 FMAs per pixel.
+        let cur_local_h = mat4_inverse(node.global) * vec4<f32>(cur_world, 1.0);
+        let prev_world_h = node.prev_global * cur_local_h;
         prev_world = prev_world_h.xyz / prev_world_h.w;
     } else {
         // ── Skinned per-vertex interpolation ────────────────────

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

@@ -14,10 +14,11 @@
  * - 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.
- * - ProbeClipmap: the environment map, until the mode samples its own probes.
+ * - ProbeClipmap: both from one pick of the probes, the environment map where none weighs anything
+ *   ({@link chunk_forward_sample_indirect_probe_clipmap}).
  *
- * A pipeline that links this binds what every mode reads, `tEnvironment`, `brick4` and `view`, and
- * reads only its own mode's.
+ * A pipeline that links this binds what every mode reads, `tEnvironment`, `brick4`, the probes' group
+ * (`PROBE_CLIPMAP_SAMPLING_GROUP`) and `view`, and reads only its own mode's.
  *
  * @type {CodeChunkChoice}
  */

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

@@ -1 +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;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,4CAFU,eAAe,CAE4D;gCA3BrD,0CAA0C"}
+{"version":3,"file":"chunk_forward_sample_indirect.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/rasterize/forward/chunk_forward_sample_indirect.js"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,4CAFU,eAAe,CAE4D;gCA7BrD,0CAA0C"}

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

@@ -3,6 +3,7 @@ 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";
+import { chunk_forward_sample_indirect_probe_clipmap } from "./chunk_forward_sample_indirect_probe_clipmap.js";
 
 /**
  * The indirect light arriving at a forward-shaded fragment, by the renderer's mode
@@ -20,10 +21,11 @@ import { chunk_forward_sample_indirect_environment } from "./chunk_forward_sampl
  * - 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.
- * - ProbeClipmap: the environment map, until the mode samples its own probes.
+ * - ProbeClipmap: both from one pick of the probes, the environment map where none weighs anything
+ *   ({@link chunk_forward_sample_indirect_probe_clipmap}).
  *
- * A pipeline that links this binds what every mode reads, `tEnvironment`, `brick4` and `view`, and
- * reads only its own mode's.
+ * A pipeline that links this binds what every mode reads, `tEnvironment`, `brick4`, the probes' group
+ * (`PROBE_CLIPMAP_SAMPLING_GROUP`) and `view`, and reads only its own mode's.
  *
  * @type {CodeChunkChoice}
  */
@@ -32,4 +34,4 @@ export const chunk_forward_sample_indirect = CodeChunkChoice.from(INDIRECT_LIGHT
 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);
-chunk_forward_sample_indirect.add(ShadeIndirectLightingMode.ProbeClipmap, chunk_forward_sample_indirect_environment);
+chunk_forward_sample_indirect.add(ShadeIndirectLightingMode.ProbeClipmap, chunk_forward_sample_indirect_probe_clipmap);

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

@@ -0,0 +1,12 @@
+/**
+ * {@link chunk_forward_sample_indirect} from the probe clipmap (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §9.5): one
+ * pick at the fragment by its shading normal and view, jittered by a hash of its position and normal that
+ * changes every frame, as Brick4's is, for both lobes. The irradiance is π × the picked SH resolved at the normal,
+ * the specular the pick's radiance at the fragment's roughness (§9.3); where no probe weighs anything, both are
+ * the environment's. Reads the probes' group, `view` and `tEnvironment`.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_forward_sample_indirect_probe_clipmap: CodeChunk;
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_forward_sample_indirect_probe_clipmap.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_forward_sample_indirect_probe_clipmap.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/rasterize/forward/chunk_forward_sample_indirect_probe_clipmap.js"],"names":[],"mappings":"AAaA;;;;;;;;GAQG;AACH,0DAFU,SAAS,CAoCjB;0BA7CwB,oCAAoC"}

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

@@ -0,0 +1,57 @@
+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 { chunk_probe_clipmap_pick } from "../../global_illumination/probe_clipmap/probe/chunk_probe_clipmap_pick.js";
+import {
+    chunk_probe_clipmap_sample_radiance
+} from "../../global_illumination/probe_clipmap/probe/chunk_probe_clipmap_sample_radiance.js";
+import { PI_DECLARATION } from "../../shader/chunk/math/PI_DECLARATION.js";
+import { chunk_jitter_from_vectors } from "../../shader/chunk/random/chunk_jitter_from_vectors.js";
+import {
+    chunk_resolve_irradiance_sh_to_diffuse
+} from "../../shader/chunk/spherical_harmonics/l1i/chunk_resolve_irradiance_sh_to_diffuse.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+
+/**
+ * {@link chunk_forward_sample_indirect} from the probe clipmap (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §9.5): one
+ * pick at the fragment by its shading normal and view, jittered by a hash of its position and normal that
+ * changes every frame, as Brick4's is, for both lobes. The irradiance is π × the picked SH resolved at the normal,
+ * the specular the pick's radiance at the fragment's roughness (§9.3); where no probe weighs anything, both are
+ * the environment's. Reads the probes' group, `view` and `tEnvironment`.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_forward_sample_indirect_probe_clipmap = 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>,
+) {
+    // one pick for both lobes
+    let pick = probe_clipmap_pick(position_ws, normal, view_direction, jitter_from_vectors(position_ws, normal));
+    let probes = probe_clipmap_sh_of(pick);
+
+    if (probes.found) {
+        // the resolve gives E/π
+        *irradiance = PI * resolve_irradiance_sh_to_diffuse(probes.sh.Y, probes.sh.CoCg, normal);
+        *radiance = probe_clipmap_radiance_of(pick, position_ws, normal, view_direction, roughness).radiance;
+    } else {
+        *irradiance = get_ibl_irradiance(normal);
+        *radiance = get_ibl_radiance(view_direction, normal, roughness);
+    }
+}
+    `, [
+        chunk_get_ibl_radiance,
+        chunk_get_ibl_irradiance,
+        chunk_probe_clipmap_pick,
+        chunk_probe_clipmap_sample_radiance,
+        chunk_resolve_irradiance_sh_to_diffuse,
+        chunk_jitter_from_vectors,
+        PI_DECLARATION,
+    ]
+);

package/src/shade/renderer/rasterize/native/avboit/AVBOITSideChannel.d.ts

@@ -36,8 +36,9 @@
 export type AVBOITSideChannel = {
     /**
      * Optional optics preparation before occupancy; at most one producer per view. Inputs are
-     * immutable opaque resources; the light clusters, the shadow atlas and the shader switches (the
-     * indirect lighting mode among them) are the ones the transparent meshes are lit by. The returned background is read by the one shared resolve.
+     * immutable opaque resources; the light clusters, the shadow atlas, the shader switches (the
+     * indirect lighting mode among them) and the probe clipmap GI, whose probes a pass that can take its
+     * alternative binds in every mode, are the ones the transparent meshes are lit by. The returned background is read by the one shared resolve.
      * Keep prepared state per graph/camera, not on an entity or in a global current-view slot.
      */
     avboit_prepare?: (args: {
@@ -54,6 +55,7 @@ export type AVBOITSideChannel = {
         light_cluster_data: number;
         shadowmap_atlas: number;
         shader_switches: import("../../../shader/compiler/ShaderSwitchSet.js").ShaderSwitchSet;
+        probes: import("../../../global_illumination/probe_clipmap/GPUProbeClipmapGI.js").GPUProbeClipmapGI;
     }) => {
         background_color?: number;
     };

package/src/shade/renderer/rasterize/native/avboit/AVBOITSideChannel.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AVBOITSideChannel.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/avboit/AVBOITSideChannel.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAoCc,CAAC,IAAI,EAAE;QAAC,KAAK,EAAE,OAAO,iEAAiE,EAAE,UAAU,CAAC;QACjH,QAAc,EAAE,OAAO,iCAAiC,EAAE,cAAc,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QACzF,aAAmB,EAAE,MAAM,CAAC;QAAC,aAAa,EAAE,MAAM,CAAC;QAAC,cAAc,EAAE,MAAM,CAAC;QAC3E,WAAiB,EAAE,MAAM,CAAC;QAAC,mBAAmB,EAAE,MAAM,CAAC;QACvD,wBAA8B,EAAE,MAAM,CAAC;QAAC,oBAAoB,EAAE,MAAM,CAAC;QAAC,kBAAkB,EAAE,MAAM,CAAC;QACjG,eAAqB,EAAE,MAAM,CAAC;QAC9B,eAAqB,EAAE,OAAO,6CAA6C,EAAE,eAAe,CAAC;KAC1F,KAAK;QAAC,gBAAgB,CAAC,EAAE,MAAM,CAAA;KAAC;;;;;sBAKtB,CAAC,IAAI,EAAE;QACpB,KAAW,EAAE,OAAO,iEAAiE,EAAE,UAAU,CAAC;QAClG,MAAY,EAAE,MAAM,CAAC;QACrB,kBAAwB,EAAE,UAAU,MAAM,CAAC,CAAC;QAC5C,SAAe,EAAE,MAAM,CAAC;KACrB,KAAK,MAAM;;;;;;;;kBAED,CAAC,IAAI,EAAE;QACpB,KAAW,EAAE,OAAO,iEAAiE,EAAE,UAAU,CAAC;QAClG,MAAY,EAAE,MAAM,CAAC;QACrB,IAAU,EAAE,MAAM,CAAC;QACnB,aAAmB,EAAE,MAAM,CAAC;QAC5B,gBAAsB,EAAE,MAAM,EAAE,CAAC;QACjC,MAAY,EAAE;YAAC,UAAU,EAAE,MAAM,CAAC;YAAC,QAAQ,EAAE,MAAM,CAAC;YAAC,KAAK,EAAE,MAAM,CAAA;SAAC,CAAC;KACjE,KAAK;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAC;;;;;;;;;;;;;;iBAKhD,CAAC,IAAI,EAAE;QACpB,KAAW,EAAE,OAAO,iEAAiE,EAAE,UAAU,CAAC;QAClG,QAAc,EAAE,OAAO,iCAAiC,EAAE,cAAc,CAAC;QACzE,MAAY,EAAE,MAAM,CAAC;QACrB,aAAmB,EAAE,MAAM,CAAC;QAC5B,IAAU,EAAE,MAAM,CAAC;QACnB,QAAc,EAAE,MAAM,CAAC;QACvB,eAAqB,EAAE,MAAM,CAAC;QAC9B,oBAA0B,EAAE,MAAM,CAAC;QACnC,sBAA4B,EAAE;YAAC,CAAC,EAAE,MAAM,CAAC;YAAC,IAAI,EAAE,MAAM,CAAA;SAAC,CAAC;QACxD,YAAkB,EAAE;YAAC,KAAK,EAAE,MAAM,CAAC;YAAC,IAAI,EAAE,MAAM,CAAC;YAAC,UAAU,EAAE,MAAM,CAAC;YAAC,QAAQ,EAAE,MAAM,CAAA;SAAC,CAAC;KACrF,KAAK;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAC;;;;;;sBAW9D,CAAC,IAAI,EAAE,OAAO,iCAAiC,EAAE,cAAc,KAAK,OAAO"}
+{"version":3,"file":"AVBOITSideChannel.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/avboit/AVBOITSideChannel.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAoCc,CAAC,IAAI,EAAE;QAAC,KAAK,EAAE,OAAO,iEAAiE,EAAE,UAAU,CAAC;QACjH,QAAc,EAAE,OAAO,iCAAiC,EAAE,cAAc,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QACzF,aAAmB,EAAE,MAAM,CAAC;QAAC,aAAa,EAAE,MAAM,CAAC;QAAC,cAAc,EAAE,MAAM,CAAC;QAC3E,WAAiB,EAAE,MAAM,CAAC;QAAC,mBAAmB,EAAE,MAAM,CAAC;QACvD,wBAA8B,EAAE,MAAM,CAAC;QAAC,oBAAoB,EAAE,MAAM,CAAC;QAAC,kBAAkB,EAAE,MAAM,CAAC;QACjG,eAAqB,EAAE,MAAM,CAAC;QAC9B,eAAqB,EAAE,OAAO,6CAA6C,EAAE,eAAe,CAAC;QAC7F,MAAY,EAAE,OAAO,iEAAiE,EAAE,iBAAiB,CAAC;KACvG,KAAK;QAAC,gBAAgB,CAAC,EAAE,MAAM,CAAA;KAAC;;;;;sBAMtB,CAAC,IAAI,EAAE;QACpB,KAAW,EAAE,OAAO,iEAAiE,EAAE,UAAU,CAAC;QAClG,MAAY,EAAE,MAAM,CAAC;QACrB,kBAAwB,EAAE,UAAU,MAAM,CAAC,CAAC;QAC5C,SAAe,EAAE,MAAM,CAAC;KACrB,KAAK,MAAM;;;;;;;;kBAED,CAAC,IAAI,EAAE;QACpB,KAAW,EAAE,OAAO,iEAAiE,EAAE,UAAU,CAAC;QAClG,MAAY,EAAE,MAAM,CAAC;QACrB,IAAU,EAAE,MAAM,CAAC;QACnB,aAAmB,EAAE,MAAM,CAAC;QAC5B,gBAAsB,EAAE,MAAM,EAAE,CAAC;QACjC,MAAY,EAAE;YAAC,UAAU,EAAE,MAAM,CAAC;YAAC,QAAQ,EAAE,MAAM,CAAC;YAAC,KAAK,EAAE,MAAM,CAAA;SAAC,CAAC;KACjE,KAAK;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAC;;;;;;;;;;;;;;iBAKhD,CAAC,IAAI,EAAE;QACpB,KAAW,EAAE,OAAO,iEAAiE,EAAE,UAAU,CAAC;QAClG,QAAc,EAAE,OAAO,iCAAiC,EAAE,cAAc,CAAC;QACzE,MAAY,EAAE,MAAM,CAAC;QACrB,aAAmB,EAAE,MAAM,CAAC;QAC5B,IAAU,EAAE,MAAM,CAAC;QACnB,QAAc,EAAE,MAAM,CAAC;QACvB,eAAqB,EAAE,MAAM,CAAC;QAC9B,oBAA0B,EAAE,MAAM,CAAC;QACnC,sBAA4B,EAAE;YAAC,CAAC,EAAE,MAAM,CAAC;YAAC,IAAI,EAAE,MAAM,CAAA;SAAC,CAAC;QACxD,YAAkB,EAAE;YAAC,KAAK,EAAE,MAAM,CAAC;YAAC,IAAI,EAAE,MAAM,CAAC;YAAC,UAAU,EAAE,MAAM,CAAC;YAAC,QAAQ,EAAE,MAAM,CAAA;SAAC,CAAC;KACrF,KAAK;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAC;;;;;;sBAW9D,CAAC,IAAI,EAAE,OAAO,iCAAiC,EAAE,cAAc,KAAK,OAAO"}

package/src/shade/renderer/rasterize/native/avboit/AVBOITSideChannel.js

@@ -41,10 +41,12 @@
  *     light_cluster_parameters: number, light_cluster_lookup: number, light_cluster_data: number,
  *     shadowmap_atlas: number,
  *     shader_switches: import("../../../shader/compiler/ShaderSwitchSet.js").ShaderSwitchSet,
+ *     probes: import("../../../global_illumination/probe_clipmap/GPUProbeClipmapGI.js").GPUProbeClipmapGI,
  * }) => {background_color?: number}} [avboit_prepare]
  *     Optional optics preparation before occupancy; at most one producer per view. Inputs are
- *     immutable opaque resources; the light clusters, the shadow atlas and the shader switches (the
- *     indirect lighting mode among them) are the ones the transparent meshes are lit by. The returned background is read by the one shared resolve.
+ *     immutable opaque resources; the light clusters, the shadow atlas, the shader switches (the
+ *     indirect lighting mode among them) and the probe clipmap GI, whose probes a pass that can take its
+ *     alternative binds in every mode, are the ones the transparent meshes are lit by. The returned background is read by the one shared resolve.
  *     Keep prepared state per graph/camera, not on an entity or in a global current-view slot.
  * @property {(args: {
  *     graph: import("../../../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph,

package/src/shade/renderer/rasterize/native/avboit/graph_rasterize_meshes_transparent_avboit.d.ts

@@ -105,9 +105,11 @@ export function graph_avboit_integrate({ graph, warp, extinction, overflow, voxe
  * @param {number} volumetrics_metadata
  * @param {{color: number, norm: number, extinction: number}} [accumulators] existing targets to add to
  * @param {ShaderSwitchSet} shader_switches the renderer's; the draw's pipelines are built for them
+ * @param {import("../../../global_illumination/probe_clipmap/GPUProbeClipmapGI.js").GPUProbeClipmapGI} probes
+ *   the renderer's probe clipmap GI, whose probes the draw binds in every mode
  * @returns {{color: number, norm: number, extinction: number}}
  */
-export function graph_avboit_draw({ graph, view_ctx, material_count, materials, draw_commands, meshlets, depth_texture, warp, integral, primitive, light_cluster_parameters, light_cluster_lookup, light_cluster_data, shadowmap_atlas, volumetrics_lut, volumetrics_metadata, accumulators, shader_switches, }: FrameGraph): {
+export function graph_avboit_draw({ graph, view_ctx, material_count, materials, draw_commands, meshlets, depth_texture, warp, integral, primitive, light_cluster_parameters, light_cluster_lookup, light_cluster_data, shadowmap_atlas, volumetrics_lut, volumetrics_metadata, accumulators, shader_switches, probes, }: FrameGraph): {
     color: number;
     norm: number;
     extinction: number;
@@ -161,12 +163,15 @@ export function avboit_create_accumulators(pass: FramePassBuilder, resolution: A
  * @param {ShaderSwitchSet} [options.shader_switches] the renderer's; every pipeline that lights a fragment is
  *   built for them, the side channels' included, and the set is all a pass needs to know of the
  *   indirect lighting mode
+ * @param {import("../../../global_illumination/probe_clipmap/GPUProbeClipmapGI.js").GPUProbeClipmapGI} options.probes
+ *   the renderer's probe clipmap GI: every pass that lights a fragment binds its probes in every mode, the side
+ *   channels' included
  * @param {AVBOITSettings} [options.avboit] `Renderer.avboit`; the MBOIT orchestrator ignores it
  * @param {import("./AVBOITSideChannel.js").AVBOITSideChannel[]} [options.side_channels] non-meshlet
  *   sources of transparent fragments; the MBOIT orchestrator ignores them
  * @returns {number} resource ID of the composited color texture
  */
-export function graph_rasterize_meshes_transparent_avboit({ graph, buckets, view_ctx, viewport, depth_texture, color_texture, normal_texture, hzb_texture, environment_texture, limits, light_cluster_parameters, light_cluster_lookup, light_cluster_data, shadowmap_atlas, volumetrics_lut, volumetrics_metadata, volumetrics_irradiance, shader_switches, avboit, side_channels, }: {
+export function graph_rasterize_meshes_transparent_avboit({ graph, buckets, view_ctx, viewport, depth_texture, color_texture, normal_texture, hzb_texture, environment_texture, limits, light_cluster_parameters, light_cluster_lookup, light_cluster_data, shadowmap_atlas, volumetrics_lut, volumetrics_metadata, volumetrics_irradiance, shader_switches, probes, avboit, side_channels, }: {
     graph: FrameGraph;
     buckets: number;
     view_ctx: GPUViewContext;
@@ -185,6 +190,7 @@ export function graph_rasterize_meshes_transparent_avboit({ graph, buckets, view
         CoCg: number;
     };
     shader_switches?: ShaderSwitchSet;
+    probes: import("../../../global_illumination/probe_clipmap/GPUProbeClipmapGI.js").GPUProbeClipmapGI;
     avboit?: AVBOITSettings;
     side_channels?: import("./AVBOITSideChannel.js").AVBOITSideChannel[];
 }): number;

package/src/shade/renderer/rasterize/native/avboit/graph_rasterize_meshes_transparent_avboit.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graph_rasterize_meshes_transparent_avboit.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/avboit/graph_rasterize_meshes_transparent_avboit.js"],"names":[],"mappings":"AA4DA;;;;;GAKG;AACH,oDAHW,UAAU,MAAM,CAAC,GACf,MAAM,EAAE,CAOpB;AAED;;;;;;;;;;;;GAYG;AACH;IAT+B,KAAK;IACA,KAAK;IACd,MAAM,EAAtB,MAAM;IACqB,kBAAkB,EAA7C,UAAU,MAAM,CAAC;IACD,kBAAkB,EAAlC,MAAM;IACU,wBAAwB,EAAxC,MAAM;IACW,SAAS,GAA1B,MAAM;IACJ,MAAM,CA4DlB;AAED;;;;;;;;;;GAUG;AACH;IAP+B,KAAK;IACT,SAAS,EAAzB,MAAM;IACY,gBAAgB,EAAlC,MAAM,EAAE;IACmB,kBAAkB,EAA7C,UAAU,MAAM,CAAC;IACQ,MAAM,GAA/B,cAAc;IACZ,MAAM,CAuDlB;AAED;;;;;;;;;;;;;;;GAeG;AACH,6KAFa;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAC,CAiJjE;AAED;;;;;;;;;;GAUG;AACH;IAP+B,KAAK;IACT,IAAI,EAApB,MAAM;IACU,UAAU,EAA1B,MAAM;IACU,QAAQ,EAAxB,MAAM;IACY,gBAAgB,EAAlC,MAAM,EAAE;IACN,MAAM,CAoClB;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,8TAFa;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAC,CAuM7D;AAED;;;;;;;;GAQG;AACH,+EAHW,UAAU,MAAM,CAAC,GACf;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAC,CAe/E;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH;IAxB+B,KAAK;IACT,OAAO,EAAvB,MAAM;IACkB,QAAQ;IACd,QAAQ,EAA1B,MAAM,EAAE;IACQ,aAAa,EAA7B,MAAM;IACU,aAAa,EAA7B,MAAM;IACuB,MAAM;IACnB,wBAAwB,EAAxC,MAAM;IACU,oBAAoB,EAApC,MAAM;IACU,kBAAkB,EAAlC,MAAM;IACU,eAAe,EAA/B,MAAM;IACU,eAAe,EAA/B,MAAM;IACU,oBAAoB,EAApC,MAAM;IAC6B,sBAAsB,EAAzD;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAC;IAGC,eAAe,GAAzC,eAAe;IAGU,MAAM,GAA/B,cAAc;IACiD,aAAa,GAA5E,OAAO,wBAAwB,EAAE,iBAAiB,EAAE;IAElD,MAAM,CAkTlB;+BA38B8B,qBAAqB;gCAIpB,6CAA6C"}
+{"version":3,"file":"graph_rasterize_meshes_transparent_avboit.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/avboit/graph_rasterize_meshes_transparent_avboit.js"],"names":[],"mappings":"AA4DA;;;;;GAKG;AACH,oDAHW,UAAU,MAAM,CAAC,GACf,MAAM,EAAE,CAOpB;AAED;;;;;;;;;;;;GAYG;AACH;IAT+B,KAAK;IACA,KAAK;IACd,MAAM,EAAtB,MAAM;IACqB,kBAAkB,EAA7C,UAAU,MAAM,CAAC;IACD,kBAAkB,EAAlC,MAAM;IACU,wBAAwB,EAAxC,MAAM;IACW,SAAS,GAA1B,MAAM;IACJ,MAAM,CA4DlB;AAED;;;;;;;;;;GAUG;AACH;IAP+B,KAAK;IACT,SAAS,EAAzB,MAAM;IACY,gBAAgB,EAAlC,MAAM,EAAE;IACmB,kBAAkB,EAA7C,UAAU,MAAM,CAAC;IACQ,MAAM,GAA/B,cAAc;IACZ,MAAM,CAuDlB;AAED;;;;;;;;;;;;;;;GAeG;AACH,6KAFa;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAC,CAiJjE;AAED;;;;;;;;;;GAUG;AACH;IAP+B,KAAK;IACT,IAAI,EAApB,MAAM;IACU,UAAU,EAA1B,MAAM;IACU,QAAQ,EAAxB,MAAM;IACY,gBAAgB,EAAlC,MAAM,EAAE;IACN,MAAM,CAoClB;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,sUAFa;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAC,CA4M7D;AAED;;;;;;;;GAQG;AACH,+EAHW,UAAU,MAAM,CAAC,GACf;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAC,CAe/E;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH;IA3B+B,KAAK;IACT,OAAO,EAAvB,MAAM;IACkB,QAAQ;IACd,QAAQ,EAA1B,MAAM,EAAE;IACQ,aAAa,EAA7B,MAAM;IACU,aAAa,EAA7B,MAAM;IACuB,MAAM;IACnB,wBAAwB,EAAxC,MAAM;IACU,oBAAoB,EAApC,MAAM;IACU,kBAAkB,EAAlC,MAAM;IACU,eAAe,EAA/B,MAAM;IACU,eAAe,EAA/B,MAAM;IACU,oBAAoB,EAApC,MAAM;IAC6B,sBAAsB,EAAzD;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAC;IAGC,eAAe,GAAzC,eAAe;IAGsF,MAAM,EAA3G,OAAO,iEAAiE,EAAE,iBAAiB;IAGlE,MAAM,GAA/B,cAAc;IACiD,aAAa,GAA5E,OAAO,wBAAwB,EAAE,iBAAiB,EAAE;IAElD,MAAM,CAqTlB;+BAx9B8B,qBAAqB;gCAIpB,6CAA6C"}

package/src/shade/renderer/rasterize/native/avboit/graph_rasterize_meshes_transparent_avboit.js

@@ -439,6 +439,8 @@ export function graph_avboit_integrate({
  * @param {number} volumetrics_metadata
  * @param {{color: number, norm: number, extinction: number}} [accumulators] existing targets to add to
  * @param {ShaderSwitchSet} shader_switches the renderer's; the draw's pipelines are built for them
+ * @param {import("../../../global_illumination/probe_clipmap/GPUProbeClipmapGI.js").GPUProbeClipmapGI} probes
+ *   the renderer's probe clipmap GI, whose probes the draw binds in every mode
  * @returns {{color: number, norm: number, extinction: number}}
  */
 export function graph_avboit_draw({
@@ -460,8 +462,10 @@ export function graph_avboit_draw({
                                       volumetrics_metadata,
                                       accumulators,
                                       shader_switches = ShaderSwitchSet.EMPTY,
+                                      probes,
                                   }) {
 
+    assert.defined(probes, 'probes');
     assert.isNonNegativeInteger(material_count, 'material_count');
     assert.isNonNegativeInteger(draw_commands, 'draw_commands');
     assert.isNonNegativeInteger(meshlets, 'meshlets');
@@ -559,22 +563,24 @@ export function graph_avboit_draw({
         const t_split_sum_lut = graphics.textures.obtain(STATIC_GRAPHICS_ENGINE_ASSETS.split_sum);
         const stbn_vec3 = graphics.textures.obtain(STATIC_GRAPHICS_ENGINE_ASSETS.stbn_vec3);
 
-        // by name: every indirect lighting mode's resources, whichever the pipeline's variant reads
+        // by name: every indirect lighting mode's resources, whichever the pipeline's variant reads; the
+        // probes, a clipmap of no cascade while the probe clipmap has none
+        const view_inputs = data.probes.write_sampling_bindings({
+            camera: view_ctx.camera.buffer.buffer,
+            view: view_ctx.uniform_buffer.buffer,
+            warp: warp_buffer,
+            tIntegral: t_integral,
+            brick4: view_ctx.scene.volumetric_light_map.buffer,
+            tSplitSum: t_split_sum_lut,
+            sLinear: sampler_linear,
+            // volumetrics
+            volumetrics_metadata,
+            tVolumetrics: t_volumetrics_lut,
+            tSTBN_vec3: stbn_vec3,
+        });
         const view_bindings = bind_manager.obtain(BindGroupDescriptor.from(
             render_pass_descriptor.pipeline_layout.bindGroupLayouts[RASTERIZATION_SHADER_BIND_GROUP_VIEW],
-            AVBOIT_DRAW_VIEW_GROUP.generateBindings({
-                camera: view_ctx.camera.buffer.buffer,
-                view: view_ctx.uniform_buffer.buffer,
-                warp: warp_buffer,
-                tIntegral: t_integral,
-                brick4: view_ctx.scene.volumetric_light_map.buffer,
-                tSplitSum: t_split_sum_lut,
-                sLinear: sampler_linear,
-                // volumetrics
-                volumetrics_metadata,
-                tVolumetrics: t_volumetrics_lut,
-                tSTBN_vec3: stbn_vec3,
-            }, encoder)
+            AVBOIT_DRAW_VIEW_GROUP.generateBindings(view_inputs, encoder)
         ));
 
         pass_encoder.setBindGroup(RASTERIZATION_SHADER_BIND_GROUP_VIEW, view_bindings);
@@ -595,6 +601,7 @@ export function graph_avboit_draw({
 
     const pass_data = {
         shader_switches,
+        probes,
         clear_targets: accumulators === undefined,
     };
     const pass = graph.add("AVBOIT/draw", pass_data, execute);
@@ -698,6 +705,9 @@ export function avboit_create_accumulators(pass, resolution) {
  * @param {ShaderSwitchSet} [options.shader_switches] the renderer's; every pipeline that lights a fragment is
  *   built for them, the side channels' included, and the set is all a pass needs to know of the
  *   indirect lighting mode
+ * @param {import("../../../global_illumination/probe_clipmap/GPUProbeClipmapGI.js").GPUProbeClipmapGI} options.probes
+ *   the renderer's probe clipmap GI: every pass that lights a fragment binds its probes in every mode, the side
+ *   channels' included
  * @param {AVBOITSettings} [options.avboit] `Renderer.avboit`; the MBOIT orchestrator ignores it
  * @param {import("./AVBOITSideChannel.js").AVBOITSideChannel[]} [options.side_channels] non-meshlet
  *   sources of transparent fragments; the MBOIT orchestrator ignores them
@@ -725,12 +735,14 @@ export function graph_rasterize_meshes_transparent_avboit({
                                                               volumetrics_irradiance,
 
                                                               shader_switches = ShaderSwitchSet.EMPTY,
+                                                              probes,
                                                               avboit = DEFAULT_SETTINGS,
                                                               side_channels = [],
                                                           }) {
 
     assert.isNonNegativeInteger(buckets, 'buckets');
     assert.isArray(side_channels, 'side_channels');
+    assert.defined(probes, 'probes');
     assert.isNonNegativeInteger(color_texture, 'color_texture');
     assert.isNonNegativeInteger(depth_texture, 'depth_texture');
 
@@ -818,7 +830,7 @@ export function graph_rasterize_meshes_transparent_avboit({
     for (const channel of preparers) {
         const prepared = channel.avboit_prepare({ graph, view_ctx, camera: gr_camera, color_texture,
             depth_texture, normal_texture, hzb_texture: gr_hzb, environment_texture, light_cluster_parameters,
-            light_cluster_lookup, light_cluster_data, shadowmap_atlas, shader_switches });
+            light_cluster_lookup, light_cluster_data, shadowmap_atlas, shader_switches, probes });
         if (prepared?.background_color !== undefined) {
             assert.isNonNegativeInteger(prepared.background_color, 'prepared.background_color');
             background_color = prepared.background_color;
@@ -944,6 +956,7 @@ export function graph_rasterize_meshes_transparent_avboit({
         volumetrics_lut,
         volumetrics_metadata,
         shader_switches,
+        probes,
     };
 
     let accumulators = graph_avboit_draw({

package/src/shade/renderer/rasterize/native/avboit/shader_avboit_draw.d.ts

@@ -1,6 +1,7 @@
 /**
  * The draw's own group, group 2: the view, the AVBOIT volume, and what every indirect lighting mode
- * reads (`brick4`; `tEnvironment` is the lights'). The orchestrator binds it by name.
+ * reads (`brick4`, the probe clipmap's probes; `tEnvironment` is the lights'). The orchestrator binds it
+ * by name.
  *
  * @type {ShaderResourceGroupDescriptor}
  */

package/src/shade/renderer/rasterize/native/avboit/shader_avboit_draw.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_avboit_draw.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/avboit/shader_avboit_draw.js"],"names":[],"mappings":"AA+BA;;;;;GAKG;AACH,qCAFU,6BAA6B,CAEmC;AAgC1E;;;;;;GAMG;AACH,iCAFU,sBAAsB,CAmC7B;8CApG2C,2DAA2D;uCAalE,iCAAiC"}
+{"version":3,"file":"shader_avboit_draw.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/avboit/shader_avboit_draw.js"],"names":[],"mappings":"AAgCA;;;;;;GAMG;AACH,qCAFU,6BAA6B,CAEmC;AA8C1E;;;;;;GAMG;AACH,iCAFU,sBAAsB,CAmC7B;8CAnH2C,2DAA2D;uCAalE,iCAAiC"}