@woosh/meep-engine 3.57.0 → 3.59.0

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,9 +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: 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;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,4CAFU,eAAe,CAE4D;gCA1BrD,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,9 +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: 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}
  */
@@ -31,3 +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_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"}

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

@@ -4,6 +4,7 @@ import { CAMERA_UNIFORM_STRUCT } from "../../../camera/CAMERA_UNIFORM_STRUCT.js"
 import { SHADING_LIGHT_RESOURCE_GROUP } from "../../../deferred/SHADING_LIGHT_RESOURCE_GROUP.js";
 import { DEPTH_BACKGROUND_VALUE } from "../../../depth/DEPTH_BACKGROUND_VALUE.js";
 import { BRICK4_DATA_STRUCT } from "../../../global_illumination/brick4/gpu/BRICK4_DATA_STRUCT.js";
+import { PROBE_CLIPMAP_SAMPLING_GROUP } from "../../../global_illumination/probe_clipmap/probe/chunk_probe_clipmap_pick.js";
 import { STANDARD_MATERIAL_TEMPLATE } from "../../../material/standard/STANDARD_MATERIAL_TEMPLATE.js";
 import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
 import { RenderPassColorAttachmentDescriptor } from "../../../shader/pass/RenderPassColorAttachmentDescriptor.js";
@@ -31,7 +32,8 @@ import {
 
 /**
  * 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}
  */
@@ -52,12 +54,26 @@ AVBOIT_DRAW_VIEW_GROUP
     .addTexture("tVolumetrics", "float", "3d")
     .addTexture("tSTBN_vec3", "float", "3d")
 
+// the probes, read under the probe clipmap's indirect lighting; their owner binds them in every mode
+for (const declaration of PROBE_CLIPMAP_SAMPLING_GROUP.resources) {
+    AVBOIT_DRAW_VIEW_GROUP.add(declaration);
+}
+
 const pass_groups = [AVBOIT_DRAW_VIEW_GROUP, SHADING_LIGHT_RESOURCE_GROUP];
 
 // the view group keeps the visibility the orchestrator builds its bind group for, as the vertex stage
-// reads the camera from it; the lights are the fragment stage's alone
+// reads the camera from it, but for the probes; they and the lights are the fragment stage's alone, which
+// keeps the vertex stage at 8 storage buffers of the 10 a device is asked for
+const view_layout = AVBOIT_DRAW_VIEW_GROUP.generateBindGroupLayoutDescriptor(GPUShaderStage.VERTEX | GPUShaderStage.FRAGMENT);
+
+for (const declaration of PROBE_CLIPMAP_SAMPLING_GROUP.resources) {
+    const binding = AVBOIT_DRAW_VIEW_GROUP.get(declaration.name).binding_index;
+
+    view_layout.entries.find(entry => entry.binding === binding).visibility = GPUShaderStage.FRAGMENT;
+}
+
 const pass_layouts = [
-    AVBOIT_DRAW_VIEW_GROUP.generateBindGroupLayoutDescriptor(GPUShaderStage.VERTEX | GPUShaderStage.FRAGMENT),
+    view_layout,
     FORWARD_LIGHT_LAYOUT,
 ];
 

package/src/shade/renderer/rasterize/native/graph_rasterize_meshes_alpha_tested.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graph_rasterize_meshes_alpha_tested.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/rasterize/native/graph_rasterize_meshes_alpha_tested.js"],"names":[],"mappings":"AAyBA;;;;;;;;;;;;;;;;GAgBG;AACH;IAd+B,KAAK;IACT,OAAO,EAAvB,MAAM;IACkB,QAAQ;IACd,YAAY,GAA9B,OAAO;IACiB,IAAI,GAA5B,aAAa;IACmC,WAAW,GAA3D,SAAS,OAAO,MAAM,cAAc,CAAC;IACrB,KAAK,EAArB,MAAM;IACU,GAAG,EAAnB,MAAM;IACY,oBAAoB,EAAtC,MAAM,EAAE;IACqB,MAAM;IAChB,QAAQ,GAA3B,MAAM,EAAE;IACwB,sBAAsB;IACpD;IAAC,QAAQ,EAAC,OAAO,CAAC;IAAC,KAAK,EAAC,MAAM,CAAC;IAAC,aAAa,EAAC,MAAM,EAAE,CAAA;CAAC,CAuPpE;8BA3R6B,iCAAiC"}
+{"version":3,"file":"graph_rasterize_meshes_alpha_tested.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/rasterize/native/graph_rasterize_meshes_alpha_tested.js"],"names":[],"mappings":"AAyBA;;;;;;;;;;;;;;;;GAgBG;AACH;IAd+B,KAAK;IACT,OAAO,EAAvB,MAAM;IACkB,QAAQ;IACd,YAAY,GAA9B,OAAO;IACiB,IAAI,GAA5B,aAAa;IACmC,WAAW,GAA3D,SAAS,OAAO,MAAM,cAAc,CAAC;IACrB,KAAK,EAArB,MAAM;IACU,GAAG,EAAnB,MAAM;IACY,oBAAoB,EAAtC,MAAM,EAAE;IACqB,MAAM;IAChB,QAAQ,GAA3B,MAAM,EAAE;IACwB,sBAAsB;IACpD;IAAC,QAAQ,EAAC,OAAO,CAAC;IAAC,KAAK,EAAC,MAAM,CAAC;IAAC,aAAa,EAAC,MAAM,EAAE,CAAA;CAAC,CAyPpE;8BA7R6B,iCAAiC"}

package/src/shade/renderer/rasterize/native/graph_rasterize_meshes_alpha_tested.js

@@ -140,7 +140,9 @@ export function graph_rasterize_meshes_alpha_tested({
         const partial_clear_needed = !is_viewport_unrestricted && clear_target;
 
         if (partial_clear_needed) {
-            // TODO clear color targets
+            for (let i = 0; i < color_targets.length; i++) {
+                texture_fill_rectangle(encoder, color_targets[i], viewport, render_pass_descriptor.colorAttachments[i].clearValue);
+            }
             texture_fill_rectangle(encoder, depth_texture, viewport, [render_pass_descriptor.depthStencilAttachment.depthClearValue]);
         }
 
@@ -149,7 +151,7 @@ export function graph_rasterize_meshes_alpha_tested({
         const gpu_pass_descriptor = render_pass_descriptor.toGPU({
             colorTargets: color_targets,
             depthTarget: depth_texture,
-            loadOp: clear_target ? "clear" : "load",
+            loadOp: !partial_clear_needed && clear_target ? "clear" : "load",
         });
 
         const pass_encoder = encoder.beginRenderPass(gpu_pass_descriptor);

package/src/shade/renderer/rasterize/native/oit/graph_rasterize_meshes_transparent_oit.d.ts

@@ -14,7 +14,9 @@
  * @param {number} shadowmap_atlas
  * @param {ShaderSwitchSet} [shader_switches] the renderer's; the resolve's pipelines are built for them, and
  *   the set is all the resolve needs to know of the indirect lighting mode
+ * @param {import("../../../global_illumination/probe_clipmap/GPUProbeClipmapGI.js").GPUProbeClipmapGI} probes
+ *   the renderer's probe clipmap GI, whose probes the resolve binds in every mode
  * @returns {number} resource ID of modified color texture
  */
-export function graph_rasterize_meshes_transparent_oit({ graph, buckets, view_ctx, viewport, depth_texture, color_texture, limits, light_cluster_parameters, light_cluster_lookup, light_cluster_data, shadowmap_atlas, volumetrics_lut, volumetrics_metadata, shader_switches, }: FrameGraph): number;
+export function graph_rasterize_meshes_transparent_oit({ graph, buckets, view_ctx, viewport, depth_texture, color_texture, limits, light_cluster_parameters, light_cluster_lookup, light_cluster_data, shadowmap_atlas, volumetrics_lut, volumetrics_metadata, shader_switches, probes, }: FrameGraph): number;
 //# sourceMappingURL=graph_rasterize_meshes_transparent_oit.d.ts.map

package/src/shade/renderer/rasterize/native/oit/graph_rasterize_meshes_transparent_oit.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graph_rasterize_meshes_transparent_oit.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/oit/graph_rasterize_meshes_transparent_oit.js"],"names":[],"mappings":"AA0YA;;;;;;;;;;;;;;;;;GAiBG;AACH,gSAFa,MAAM,CAyOlB"}
+{"version":3,"file":"graph_rasterize_meshes_transparent_oit.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/oit/graph_rasterize_meshes_transparent_oit.js"],"names":[],"mappings":"AAiZA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wSAFa,MAAM,CA6OlB"}

package/src/shade/renderer/rasterize/native/oit/graph_rasterize_meshes_transparent_oit.js

@@ -50,6 +50,8 @@ import { SHADING_SCENE_LAYOUT } from "../../forward/SHADING_SCENE_RESOURCE_GROUP
  * @param {number} output
  * @param {PrimitiveState} primitive
  * @param {ShaderSwitchSet} shader_switches the renderer's; the resolve'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 resolve binds in every mode
  * @return {number}
  */
 function graph_oit_resolve_moments({
@@ -75,8 +77,10 @@ function graph_oit_resolve_moments({
 
                                        output = -1,
                                        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');
@@ -169,22 +173,24 @@ function graph_oit_resolve_moments({
 
         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,
+            moments: t_moments,
+            optical_depth: t_optical_depth,
+            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],
-            OIT_RESOLVE_VIEW_GROUP.generateBindings({
-                camera: view_ctx.camera.buffer.buffer,
-                view: view_ctx.uniform_buffer.buffer,
-                moments: t_moments,
-                optical_depth: t_optical_depth,
-                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)
+            OIT_RESOLVE_VIEW_GROUP.generateBindings(view_inputs, encoder)
         ));
 
         pass_encoder.setBindGroup(RASTERIZATION_SHADER_BIND_GROUP_VIEW, view_bindings);
@@ -206,6 +212,7 @@ function graph_oit_resolve_moments({
 
     const pass_data = {
         shader_switches,
+        probes,
     };
     const pass = graph.add("MBOIT/resolve moments", pass_data, execute);
 
@@ -408,6 +415,8 @@ function graph_oit_generate_moments({
  * @param {number} shadowmap_atlas
  * @param {ShaderSwitchSet} [shader_switches] the renderer's; the resolve's pipelines are built for them, and
  *   the set is all the resolve needs to know of the indirect lighting mode
+ * @param {import("../../../global_illumination/probe_clipmap/GPUProbeClipmapGI.js").GPUProbeClipmapGI} probes
+ *   the renderer's probe clipmap GI, whose probes the resolve binds in every mode
  * @returns {number} resource ID of modified color texture
  */
 export function graph_rasterize_meshes_transparent_oit({
@@ -428,10 +437,12 @@ export function graph_rasterize_meshes_transparent_oit({
                                                            volumetrics_metadata,
 
                                                            shader_switches = ShaderSwitchSet.EMPTY,
+                                                           probes,
                                                        }) {
 
 
     assert.isNonNegativeInteger(buckets, 'buckets');
+    assert.defined(probes, 'probes');
 
     assert.isNonNegativeInteger(light_cluster_parameters, 'light_cluster_parameters');
     assert.isNonNegativeInteger(light_cluster_lookup, 'light_cluster_lookup');
@@ -598,6 +609,7 @@ export function graph_rasterize_meshes_transparent_oit({
         volumetrics_metadata,
 
         shader_switches,
+        probes,
     });
 
     resolved = graph_oit_resolve_moments({
@@ -625,6 +637,7 @@ export function graph_rasterize_meshes_transparent_oit({
         volumetrics_metadata,
 
         shader_switches,
+        probes,
     });
 
     const [blended] = graph_image_pass({