@woosh/meep-engine 3.67.0 → 3.69.0

package/src/shade/renderer/fluid/pressure/GPUFluidPressureSolve.d.ts

@@ -41,7 +41,7 @@ export class GPUFluidPressureSolve {
      * @param {*} _resources
      * @param {{encoder: ShadeGPUCommandContext}} context
      */
-    static "__#288@#execute"(data: {
+    static "__#291@#execute"(data: {
         solve: GPUFluidPressureSolve;
         arm: number;
         count: number;

package/src/shade/renderer/fluid/query/GPUFluidQueries.d.ts

@@ -49,7 +49,7 @@ export class GPUFluidQueries {
      * @param {import("../../../../engine/graphics/render/frame_graph/FramePassResources.js").FramePassResources} resources
      * @param {{encoder: import("../../../device/ShadeGPUCommandContext.js").ShadeGPUCommandContext}} context
      */
-    static "__#293@#execute"(pass: object, resources: import("../../../../engine/graphics/render/frame_graph/FramePassResources.js").FramePassResources, context: {
+    static "__#296@#execute"(pass: object, resources: import("../../../../engine/graphics/render/frame_graph/FramePassResources.js").FramePassResources, context: {
         encoder: import("../../../device/ShadeGPUCommandContext.js").ShadeGPUCommandContext;
     }): void;
     /**

package/src/shade/renderer/global_illumination/probe/octahedral/shader_lpv_build_gbuffer.js

@@ -1,7 +1,7 @@
 import { u32 } from "../../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
 import { WebGPUArray } from "../../../shader/type/WebGPUArray.js";
 import { WebGPUStruct } from "../../../shader/type/WebGPUStruct.js";
-import { chunk_sample_environment_color } from "../../../atmosphere/chunk_sample_environment_color.js";
+import { chunk_sample_environment_color } from "../../../light/environment/chunk_sample_environment_color.js";
 import { INDIRECT_MATERIAL_ARRAY_TYPE } from "../../../material/resident/INDIRECT_MATERIAL_ARRAY_TYPE.js";
 import { chunk_indirect_sample_texture } from "../../../path_tracer/shader/chunk_indirect_sample_texture.js";
 

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

@@ -34,7 +34,7 @@ export class GPUProbeClipmapGI {
      * @param {ProbeClipmapSettings} settings
      * @returns {boolean} whether it is what the settings' world cache describes, in their frustum's windows
      */
-    static "__#214@#world_cache_built_for"(world_cache: GPUProbeClipmap, settings: ProbeClipmapSettings): boolean;
+    static "__#215@#world_cache_built_for"(world_cache: GPUProbeClipmap, settings: ProbeClipmapSettings): boolean;
     /**
      * @param {GraphicsContext} graphics
      */
@@ -55,6 +55,24 @@ export class GPUProbeClipmapGI {
      * @returns {ProbeClipmapSceneHolds|undefined} undefined while the mode is not running
      */
     get holds(): ProbeClipmapSceneHolds;
+    /**
+     * @returns {GPUBrickMaterial|undefined} the bricks' surface material, which a ray's hit reads; undefined while the
+     *   mode is not running
+     */
+    get material(): GPUBrickMaterial;
+    /**
+     * @returns {number} the graph handle of the brick clipmap's last write in this frame's {@link graph_update}, which a
+     *   pass tracing the bricks after it reads
+     */
+    get bricks(): number;
+    /**
+     * @returns {{lookup: number, data: number}} graph handles of the world light clusters this frame's
+     *   {@link graph_update} built over the bricks' cascades, where a ray's hit finds its local lights
+     */
+    get clusters(): {
+        lookup: number;
+        data: number;
+    };
     /**
      * Take a frame of the mode: make the clipmaps for `view` and the structure `settings` describe,
      * unless they already are, hold the scene's geometry caches and record their bake. Allocates nothing
@@ -201,4 +219,5 @@ export type BrickProvider = import("./brick/GPUBrickClipmap.js").BrickProvider;
 import { GPUBrickClipmap } from "./brick/GPUBrickClipmap.js";
 import { GPUProbeClipmap } from "./probe/GPUProbeClipmap.js";
 import { ProbeClipmapSceneHolds } from "./ProbeClipmapSceneHolds.js";
+import { GPUBrickMaterial } from "./material/GPUBrickMaterial.js";
 //# sourceMappingURL=GPUProbeClipmapGI.d.ts.map

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":"AA+BA;;;;;;GAMG;AAEH;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH;IAsUI;;;;OAIG;IACH,oDAJW,eAAe,YACf,oBAAoB,GAClB,OAAO,CAUnB;IA/OD;;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;aAyIhB;IAqDD;;;OAGG;IACH,0BAEC;IAED;;;;;;;;;;;;;;;;;;OAkBG;IACH;QAT+B,KAAK,EAAzB,UAAU;QACM,KAAK,EAArB,MAAM;QACU,MAAM,EAAtB,MAAM;QAEW,cAAc,GAA/B,MAAM;QACY,SAAS,GAA3B,OAAO;QACY,MAAM;QACE,UAAU,EAArC,UAAU,MAAM,CAAC;aAmC3B;IAED;;;;;;;;;;;;;;OAcG;IACH;QAN+B,KAAK,EAAzB,UAAU;QACwD,KAAK,EAAvE,OAAO,gCAAgC,EAAE,eAAe;QACxC,MAAM,EAAtB,MAAM;QACU,kBAAkB,EAAlC,MAAM;QACU,wBAAwB,EAAxC,MAAM;aAiBhB;IAED;;;;;;;;;OASG;IACH,4CAUC;IAwDD;;;;;;;;;;;;;;;;OAgBG;IACH;QAR+B,KAAK,EAAzB,UAAU;QACc,IAAI,EAA5B,cAAc;QACgB,QAAQ,EAAtC,oBAAoB;QACF,UAAU,EAA5B,MAAM,EAAE;QACQ,QAAQ;QACtB,MAAM,CA8ClB;IAED;;;;;OAKG;IACH,uBAFW,aAAa,QASvB;IAED;;;OAGG;IACH,0BAHW,aAAa,GACX,OAAO,CAanB;IAqED;;;OAGG;IACH,gBA2BC;IAED,gBAcC;;CACJ;yBA9uBY,OAAO,8DAA8D,EAAE,UAAU;8BACjF,OAAO,0BAA0B,EAAE,eAAe;6BAClD,OAAO,8BAA8B,EAAE,cAAc;mCACrD,OAAO,2BAA2B,EAAE,oBAAoB;4BACxD,OAAO,4BAA4B,EAAE,aAAa;gCA3B/B,4BAA4B;gCAa5B,4BAA4B;uCAMrB,6BAA6B"}
+{"version":3,"file":"GPUProbeClipmapGI.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/global_illumination/probe_clipmap/GPUProbeClipmapGI.js"],"names":[],"mappings":"AA+BA;;;;;;GAMG;AAEH;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH;IAmWI;;;;OAIG;IACH,oDAJW,eAAe,YACf,oBAAoB,GAClB,OAAO,CAUnB;IAzQD;;OAEG;IACH,sBAFW,eAAe,EAMzB;IAED;;OAEG;IACH,qCAEC;IAED;;OAEG;IACH,qCAEC;IAED;;OAEG;IACH,mCAEC;IAED;;OAEG;IACH,oCAEC;IAED;;;OAGG;IACH,iCAEC;IAED;;;OAGG;IACH,qBAEC;IAED;;;OAGG;IACH;gBAHsB,MAAM;cAAQ,MAAM;MAKzC;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;aA2IhB;IAqDD;;;OAGG;IACH,0BAEC;IAED;;;;;;;;;;;;;;;;;;OAkBG;IACH;QAT+B,KAAK,EAAzB,UAAU;QACM,KAAK,EAArB,MAAM;QACU,MAAM,EAAtB,MAAM;QAEW,cAAc,GAA/B,MAAM;QACY,SAAS,GAA3B,OAAO;QACY,MAAM;QACE,UAAU,EAArC,UAAU,MAAM,CAAC;aAmC3B;IAED;;;;;;;;;;;;;;OAcG;IACH;QAN+B,KAAK,EAAzB,UAAU;QACwD,KAAK,EAAvE,OAAO,gCAAgC,EAAE,eAAe;QACxC,MAAM,EAAtB,MAAM;QACU,kBAAkB,EAAlC,MAAM;QACU,wBAAwB,EAAxC,MAAM;aAiBhB;IAED;;;;;;;;;OASG;IACH,4CAUC;IAwDD;;;;;;;;;;;;;;;;OAgBG;IACH;QAR+B,KAAK,EAAzB,UAAU;QACc,IAAI,EAA5B,cAAc;QACgB,QAAQ,EAAtC,oBAAoB;QACF,UAAU,EAA5B,MAAM,EAAE;QACQ,QAAQ;QACtB,MAAM,CA8ClB;IAED;;;;;OAKG;IACH,uBAFW,aAAa,QASvB;IAED;;;OAGG;IACH,0BAHW,aAAa,GACX,OAAO,CAanB;IAqED;;;OAGG;IACH,gBA2BC;IAED,gBAcC;;CACJ;yBA3wBY,OAAO,8DAA8D,EAAE,UAAU;8BACjF,OAAO,0BAA0B,EAAE,eAAe;6BAClD,OAAO,8BAA8B,EAAE,cAAc;mCACrD,OAAO,2BAA2B,EAAE,oBAAoB;4BACxD,OAAO,4BAA4B,EAAE,aAAa;gCA3B/B,4BAA4B;gCAa5B,4BAA4B;uCAMrB,6BAA6B;iCACnC,gCAAgC"}

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

@@ -160,6 +160,9 @@ export class GPUProbeClipmapGI {
      */
     #material_writers = [];
 
+    /** The graph handle of the brick clipmap's last write this frame, as {@link graph_update} left it. */
+    #bricks = -1;
+
     /**
      * @param {GraphicsContext} graphics
      */
@@ -197,6 +200,30 @@ export class GPUProbeClipmapGI {
         return this.#holds;
     }
 
+    /**
+     * @returns {GPUBrickMaterial|undefined} the bricks' surface material, which a ray's hit reads; undefined while the
+     *   mode is not running
+     */
+    get material() {
+        return this.#material;
+    }
+
+    /**
+     * @returns {number} the graph handle of the brick clipmap's last write in this frame's {@link graph_update}, which a
+     *   pass tracing the bricks after it reads
+     */
+    get bricks() {
+        return this.#bricks;
+    }
+
+    /**
+     * @returns {{lookup: number, data: number}} graph handles of the world light clusters this frame's
+     *   {@link graph_update} built over the bricks' cascades, where a ray's hit finds its local lights
+     */
+    get clusters() {
+        return this.#clusters;
+    }
+
     /**
      * Take a frame of the mode: make the clipmaps for `view` and the structure `settings` describe,
      * unless they already are, hold the scene's geometry caches and record their bake. Allocates nothing
@@ -290,6 +317,8 @@ export class GPUProbeClipmapGI {
             movers,
         });
 
+        this.#bricks = bricks;
+
         const material = this.#material;
 
         const clusters = this.#graph_clusters(graph, scene);

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

@@ -0,0 +1,47 @@
+/**
+ * The irradiance a front-face hit in the brick clipmap takes from the directional lights
+ * (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §8.7), shadowed by rays traced through the bricks:
+ *
+ * ```wgsl
+ * fn probe_clipmap_sun_irradiance(position: vec3<f32>, normal: vec3<f32>, cascade: u32, seed: vec2<u32>, t_max: f32, cascade_count: u32, atlas_shift: u32) -> vec3<f32>
+ * ```
+ *
+ * E_dir = Σ colour·max(0, n·l)·visibility over the directional lights. The visibility is a shadow ray toward
+ * each of the first {@link PROBE_SHADOWED_SUNS} lights that cast shadows, in the table's order; lights past them
+ * are unshadowed. It starts a voxel of the hit's cascade off the surface along `normal`, outside the field's
+ * half-voxel expand, and heads for a point of the light's disk drawn as the path tracer draws it
+ * (`cone_sample_direction`), from `seed` and the light's place among the shadowed: a caller that integrates
+ * many hits over a seed that differs between them integrates the penumbra. The light is seen whole if the ray
+ * misses within `t_max`, and not at all if it hits or spends its steps. A surface turned from a light traces no
+ * ray toward it; the light keeps its place among the shadowed all the same.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_probe_clipmap_sun_irradiance: CodeChunk;
+/**
+ * The irradiance a front-face hit in brick cascade `cascade` takes from the local lights, E_loc
+ * (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §8.7):
+ *
+ * ```wgsl
+ * fn probe_clipmap_local_irradiance(cascade: u32, position: vec3<f32>, normal: vec3<f32>, random: vec4<f32>, cascade_count: u32, atlas_shift: u32) -> vec3<f32>
+ * ```
+ *
+ * - One of the point and spot lights of the hit's cell of the world light clusters, built over the bricks'
+ *   cascades so that every hit has one, at most `IRRADIANCE_CLIPMAP_LIGHT_BUDGET` of each; past them lights are
+ *   dropped. Each light's unshadowed irradiance is the irradiance clipmap's, at the footprint of a voxel of the
+ *   hit's cascade, by its cosine at the hit's normal.
+ * - One is picked by weighted reservoir sampling over the cell's lights by `random.x`, its weight the luminance
+ *   of that irradiance, with the number stretched over the candidates as `sample_discrete_wrs` does; it lights
+ *   the hit by its irradiance over the chance of its pick, w/W. A caller blending many hits averages the picks
+ *   to the cell's sum.
+ * - The picked light's shadow is a ray traced through the brick clipmap: from a voxel off the surface, past the
+ *   field's half-voxel expand, toward the point of the light's sphere `random.yzw` draws, as the path tracer
+ *   draws it, stopping short of that point by the light's near clip or a voxel, whichever is more. It sees the
+ *   light if it misses; a hit, or a march that spends its steps, is no light. A light that casts no shadow
+ *   traces none.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_probe_clipmap_local_irradiance: CodeChunk;
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_probe_clipmap_hit_light.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_probe_clipmap_hit_light.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/chunk_probe_clipmap_hit_light.js"],"names":[],"mappings":"AA6BA;;;;;;;;;;;;;;;;;;GAkBG;AACH,iDAFU,SAAS,CAkDZ;AAKP;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,mDAFU,SAAS,CAsHZ;0BAhOmB,uCAAuC"}

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

@@ -0,0 +1,246 @@
+import { MESH_SDF_BRICK_VOXELS } from "../../../geometry/sdf/MESH_SDF.js";
+import { chunk_light_cluster_counts } from "../../../light/cluster/chunk_light_cluster_counts.js";
+import { LIGHT_DATA_RESOURCE } from "../../../light/LIGHT_DATA_RESOURCE.js";
+import { LIGHT_DATABASE_SPEC } from "../../../light/LIGHT_DATABASE_SPEC.js";
+import { LIGHT_FLAGS } from "../../../light/model/io/LIGHT_FLAGS.js";
+import {
+    chunk_world_light_cluster_lookup_at,
+    WORLD_CLUSTER_DATA_RESOURCE
+} from "../../../light/world_cluster/chunk_world_light_cluster_lookup.js";
+import { chunk_rgb_to_luminance } from "../../../shader/chunk/color/chunk_rgb_to_luminance.js";
+import { chunk_cone_sample_direction } from "../../../shader/chunk/geometry/cone/chunk_cone_sample_direction.js";
+import { chunk_sphere_sample_volume } from "../../../shader/chunk/geometry/sphere/chunk_sphere_sample_volume.js";
+import {
+    chunk_directional_lights_iteration_mask
+} from "../../../shader/chunk/light/io/chunk_directional_lights_iteration_mask.js";
+import { chunk_hash_to_float01 } from "../../../shader/chunk/random/chunk_hash_to_float01.js";
+import { chunk_pcg3d } from "../../../shader/chunk/random/pcg/chunk_pcg3d.js";
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+import {
+    chunk_irradiance_clipmap_local_light
+} from "../../../volumetrics/irradiance_clipmap/chunk_irradiance_clipmap_local_light.js";
+import { IRRADIANCE_CLIPMAP_LIGHT_BUDGET } from "../../../volumetrics/irradiance_clipmap/IRRADIANCE_CLIPMAP.js";
+import { BRICK_LEVELS_RESOURCE, chunk_brick_clipmap_trace } from "../brick/chunk_brick_clipmap_trace.js";
+import { PROBE_SHADOWED_SUNS } from "./PROBE_CLIPMAP.js";
+
+const DIRECTIONAL = LIGHT_DATABASE_SPEC.get('light_directional');
+const POINT = LIGHT_DATABASE_SPEC.get('light_point');
+const SPOT = LIGHT_DATABASE_SPEC.get('light_spot');
+
+/**
+ * The irradiance a front-face hit in the brick clipmap takes from the directional lights
+ * (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §8.7), shadowed by rays traced through the bricks:
+ *
+ * ```wgsl
+ * fn probe_clipmap_sun_irradiance(position: vec3<f32>, normal: vec3<f32>, cascade: u32, seed: vec2<u32>, t_max: f32, cascade_count: u32, atlas_shift: u32) -> vec3<f32>
+ * ```
+ *
+ * E_dir = Σ colour·max(0, n·l)·visibility over the directional lights. The visibility is a shadow ray toward
+ * each of the first {@link PROBE_SHADOWED_SUNS} lights that cast shadows, in the table's order; lights past them
+ * are unshadowed. It starts a voxel of the hit's cascade off the surface along `normal`, outside the field's
+ * half-voxel expand, and heads for a point of the light's disk drawn as the path tracer draws it
+ * (`cone_sample_direction`), from `seed` and the light's place among the shadowed: a caller that integrates
+ * many hits over a seed that differs between them integrates the penumbra. The light is seen whole if the ray
+ * misses within `t_max`, and not at all if it hits or spends its steps. A surface turned from a light traces no
+ * ray toward it; the light keeps its place among the shadowed all the same.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_probe_clipmap_sun_irradiance = CodeChunk.from(
+    //language=WGSL
+    `
+fn probe_clipmap_sun_irradiance(position: vec3<f32>, normal: vec3<f32>, cascade: u32, seed: vec2<u32>, t_max: f32, cascade_count: u32, atlas_shift: u32) -> vec3<f32> {
+    let voxel = brick_levels[cascade].cell_size / ${MESH_SDF_BRICK_VOXELS}.0;
+    let lifted = position + voxel * normal;
+
+    var direct = vec3<f32>(0.0);
+    var bits = directional_lights_iteration_mask(&light_data);
+    var shadowed = 0u;
+
+    while (bits != 0u) {
+        let index = countTrailingZeros(bits);
+
+        bits &= ~(1u << index);
+
+        let light = ${DIRECTIONAL.marshalling_method_read}(&light_data, index);
+        let n_dot_l = dot(normal, -light.direction);
+
+        var visible = 1.0;
+
+        if ((light.flags & ${LIGHT_FLAGS.CASTS_SHADOW_BIT}u) != 0u && shadowed < ${PROBE_SHADOWED_SUNS}u) {
+            // a surface turned from the light takes none of it whatever the shadow, so it traces none;
+            // the light keeps its place among the shadowed all the same
+            if (n_dot_l > 0.0) {
+                // a point of the disk of its own for each light, apart from the caller's other draws
+                let hash = pcg3d(vec3<u32>(seed.x, seed.y, 0x3C6EF372u + shadowed));
+                let toward = cone_sample_direction(-light.direction, light.disk_radius, vec2<f32>(hash_to_float01(hash.x), hash_to_float01(hash.y)));
+                let shadow = brick_clipmap_trace(lifted, toward, 0.0, t_max, cascade_count, atlas_shift);
+
+                visible = select(0.0, 1.0, shadow.kind == BRICK_TRACE_MISS);
+            }
+
+            shadowed++;
+        }
+
+        direct += light.color * max(n_dot_l, 0.0) * visible;
+    }
+
+    return direct;
+}
+`, [
+        chunk_brick_clipmap_trace,
+        chunk_cone_sample_direction,
+        chunk_pcg3d,
+        chunk_hash_to_float01,
+        chunk_directional_lights_iteration_mask,
+        DIRECTIONAL.chunk_read,
+    ]);
+
+chunk_probe_clipmap_sun_irradiance.requireResource(LIGHT_DATA_RESOURCE);
+chunk_probe_clipmap_sun_irradiance.requireResource(BRICK_LEVELS_RESOURCE);
+
+/**
+ * The irradiance a front-face hit in brick cascade `cascade` takes from the local lights, E_loc
+ * (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §8.7):
+ *
+ * ```wgsl
+ * fn probe_clipmap_local_irradiance(cascade: u32, position: vec3<f32>, normal: vec3<f32>, random: vec4<f32>, cascade_count: u32, atlas_shift: u32) -> vec3<f32>
+ * ```
+ *
+ * - One of the point and spot lights of the hit's cell of the world light clusters, built over the bricks'
+ *   cascades so that every hit has one, at most `IRRADIANCE_CLIPMAP_LIGHT_BUDGET` of each; past them lights are
+ *   dropped. Each light's unshadowed irradiance is the irradiance clipmap's, at the footprint of a voxel of the
+ *   hit's cascade, by its cosine at the hit's normal.
+ * - One is picked by weighted reservoir sampling over the cell's lights by `random.x`, its weight the luminance
+ *   of that irradiance, with the number stretched over the candidates as `sample_discrete_wrs` does; it lights
+ *   the hit by its irradiance over the chance of its pick, w/W. A caller blending many hits averages the picks
+ *   to the cell's sum.
+ * - The picked light's shadow is a ray traced through the brick clipmap: from a voxel off the surface, past the
+ *   field's half-voxel expand, toward the point of the light's sphere `random.yzw` draws, as the path tracer
+ *   draws it, stopping short of that point by the light's near clip or a voxel, whichever is more. It sees the
+ *   light if it misses; a hit, or a march that spends its steps, is no light. A light that casts no shadow
+ *   traces none.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_probe_clipmap_local_irradiance = CodeChunk.from(
+    //language=WGSL
+    `
+fn probe_clipmap_local_irradiance(cascade: u32, position: vec3<f32>, normal: vec3<f32>, random: vec4<f32>, cascade_count: u32, atlas_shift: u32) -> vec3<f32> {
+    let level = brick_levels[cascade];
+    let voxel = level.cell_size / ${MESH_SDF_BRICK_VOXELS}.0;
+    let cell = world_light_cluster_metadata_at(cascade, level, 0.0, position);
+    let point_count = min(light_cluster_count_point(cell.counts), ${IRRADIANCE_CLIPMAP_LIGHT_BUDGET}u);
+    let spot_count = min(light_cluster_count_spot(cell.counts), ${IRRADIANCE_CLIPMAP_LIGHT_BUDGET}u);
+
+    // the cell's spot lights follow its point lights
+    let spots = cell.offset + light_cluster_count_point(cell.counts);
+
+    // the reservoir: the weights so far, and the light it holds
+    var u = random.x;
+    var total = 0.0;
+    var picked = vec3<f32>(0.0);
+    var picked_weight = 0.0;
+    var picked_index = 0u;
+    var picked_spot = false;
+
+    for (var j = 0u; j < point_count + spot_count; j++) {
+        let spot = j >= point_count;
+        let index = world_cluster_data[select(cell.offset + j, spots + (j - point_count), spot)];
+
+        var irradiance: vec3<f32>;
+
+        if (spot) {
+            let light = irradiance_clipmap_get_spot_light_info_by_index(&light_data, index, position, voxel);
+
+            irradiance = light.color * max(dot(normal, light.direction), 0.0);
+        } else {
+            let light = irradiance_clipmap_get_point_light_info_by_index(&light_data, index, position, voxel);
+
+            irradiance = light.color * max(dot(normal, light.direction), 0.0);
+        }
+
+        let weight = rgb_to_luminance(irradiance);
+
+        if (weight <= 0.0) {
+            continue;
+        }
+
+        // the light takes the reservoir by its share of the weights so far, and the number is stretched back
+        // over [0, 1) from whichever side of the share it fell
+        total += weight;
+
+        let share = weight / total;
+
+        if (u < share) {
+            u = u / share;
+            picked = irradiance;
+            picked_weight = weight;
+            picked_index = index;
+            picked_spot = spot;
+        } else {
+            u = (u - share) / (1.0 - share);
+        }
+    }
+
+    if (total <= 0.0) {
+        return vec3<f32>(0.0);
+    }
+
+    // the pick's light over the chance of the pick, w / W
+    let estimate = picked * (total / picked_weight);
+
+    var source: vec3<f32>;
+    var radius: f32;
+    var near_clip: f32;
+    var flags: u32;
+
+    if (picked_spot) {
+        let light = ${SPOT.marshalling_method_read}(&light_data, picked_index);
+
+        source = light.position;
+        radius = light.radius;
+        near_clip = light.near_clip_distance;
+        flags = light.flags;
+    } else {
+        let light = ${POINT.marshalling_method_read}(&light_data, picked_index);
+
+        source = light.position.xyz;
+        radius = light.radius;
+        near_clip = light.near_clip_distance;
+        flags = light.flags;
+    }
+
+    if ((flags & ${LIGHT_FLAGS.CASTS_SHADOW_BIT}u) == 0u) {
+        return estimate;
+    }
+
+    // from a voxel off the surface, past the half voxel the field's surface may sit off it, to a point of the
+    // light, short of it by the light's near clip or by a voxel for the expand at that end
+    let lifted = position + normal * voxel;
+    let to_light = source + radius * sphere_sample_volume(random.yzw) - lifted;
+    let span = length(to_light);
+    let reach = span - max(near_clip, voxel);
+
+    if (reach <= 0.0) {
+        return estimate;
+    }
+
+    let shadow = brick_clipmap_trace(lifted, to_light / span, 0.0, reach, cascade_count, atlas_shift);
+
+    return select(vec3<f32>(0.0), estimate, shadow.kind == BRICK_TRACE_MISS);
+}
+`, [
+        chunk_world_light_cluster_lookup_at,
+        chunk_light_cluster_counts,
+        chunk_irradiance_clipmap_local_light,
+        chunk_rgb_to_luminance,
+        chunk_brick_clipmap_trace,
+        chunk_sphere_sample_volume,
+        POINT.chunk_read,
+        SPOT.chunk_read,
+    ]);
+
+chunk_probe_clipmap_local_irradiance.requireResource(LIGHT_DATA_RESOURCE);
+chunk_probe_clipmap_local_irradiance.requireResource(BRICK_LEVELS_RESOURCE);
+chunk_probe_clipmap_local_irradiance.requireResource(WORLD_CLUSTER_DATA_RESOURCE);

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

@@ -4,21 +4,10 @@
  * into its flags. It adds ρ_d·E_loc/π to the radiance shade left, ρ_d being the albedo shade left in the
  * ray's \`albedo\`; the next bounce, E_ind, is the bounce pass's, after it (`shader_probe_clipmap_bounce`).
  *
- * - **E_loc, the local lights**: one of the point and spot lights of the hit's cell of the world light
- *   clusters, built over the bricks' cascades so that every hit has one, at most
- *   `IRRADIANCE_CLIPMAP_LIGHT_BUDGET` of each; past them lights are dropped. Each light's unshadowed
- *   irradiance is the irradiance clipmap's, at the footprint of a voxel of the hit's cascade, by its
- *   cosine at the hit's normal.
- *   - One is picked by weighted reservoir sampling over the cell's lights, its weight the luminance of
- *     that irradiance, with one number stretched over the candidates as `sample_discrete_wrs` does; it
- *     lights the hit by its irradiance over the chance of its pick, w/W. The probe's blend of its rays
- *     averages the picks to the cell's sum.
- *   - The picked light's shadow is a ray traced through the brick clipmap, as the hit's own ray was:
- *     from a voxel off the surface, past the field's half-voxel expand, toward a point of the light's
- *     sphere drawn as the path tracer draws it, stopping short of that point by the light's near clip or
- *     a voxel, whichever is more, for the expand at that end. It sees the light if it misses; a hit, or a
- *     march that spends its steps, is no light. A light that casts no shadow traces none.
- *   - The pick and the point are drawn from the ray's slot and direction, fresh every update.
+ * - **E_loc, the local lights**: one of the hit's world light cluster cell's point and spot lights, picked by
+ *   weighted reservoir sampling and shadowed by a ray traced through the brick clipmap
+ *   (`probe_clipmap_local_irradiance`). The probe's blend of its rays averages the picks to the cell's sum.
+ * - The pick and the point are drawn from the ray's slot and direction, fresh every update.
  *
  * Its own pass because shade binds nine of a stage's ten storage buffers; apart from the bounce because the
  * two together would bind twelve storage buffers, and a shadow march is another cost than probe taps

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

@@ -1 +1 @@
-{"version":3,"file":"shader_probe_clipmap_light.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_light.js"],"names":[],"mappings":"AAqEA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,yCAFU,aAAa,CA0KpB;8BAnP2B,kCAAkC"}
+{"version":3,"file":"shader_probe_clipmap_light.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_light.js"],"names":[],"mappings":"AAuDA;;;;;;;;;;;;;;;;GAgBG;AACH,yCAFU,aAAa,CAuDpB;8BA9G2B,kCAAkC"}