@woosh/meep-engine 3.67.0 → 3.68.0

package/src/shade/renderer/global_illumination/screen_probe/shader_screen_probe_importance.js

@@ -0,0 +1,457 @@
+import { chunk_rgb_to_luminance } from "../../shader/chunk/color/chunk_rgb_to_luminance.js";
+import { chunk_project_position_from_depth } from "../../shader/chunk/camera/chunk_project_position_from_depth.js";
+import { chunk_is_background } from "../../shader/chunk/depth/chunk_is_background.js";
+import {
+    chunk_decode_g_buffer_face_normal
+} from "../../shader/chunk/geometry/normal/chunk_decode_g_buffer_face_normal.js";
+import { chunk_decode_g_buffer_normal } from "../../shader/chunk/geometry/normal/chunk_decode_g_buffer_normal.js";
+import { chunk_folded_workgroup_index } from "../../shader/chunk/grid/chunk_folded_workgroup_index.js";
+import { chunk_sh3_cosine_convolved_basis_at } from "../../shader/chunk/spherical_harmonics/chunk_sh3_basis_at.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { ComputeShader } from "../../shader/ComputeShader.js";
+import { ShaderResourceDescriptor } from "../../shader/resource/ShaderResourceDescriptor.js";
+import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
+import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
+import { STBN_VEC2_RESOURCE } from "../../STATIC_GRAPHICS_ENGINE_ASSET_RESOURCES.js";
+import { chunk_probe_clipmap_sample_radiance } from "../probe_clipmap/probe/chunk_probe_clipmap_sample_radiance.js";
+import { PROBE_CLIPMAP_SAMPLING_GROUP } from "../probe_clipmap/probe/chunk_probe_clipmap_pick.js";
+import {
+    chunk_screen_probe,
+    chunk_screen_probe_counts,
+    chunk_screen_probe_ray_jitter,
+    SCREEN_PROBE_DISPATCH_READ_RESOURCE,
+    SCREEN_PROBE_EXPOSURE_PREVIOUS_RESOURCE,
+    SCREEN_PROBE_EXPOSURE_RESOURCE,
+    SCREEN_PROBE_FRAME_RESOURCE,
+    SCREEN_PROBE_PICKS_READ_RESOURCE,
+    SCREEN_PROBE_RAY_INFO_WRITE_RESOURCE,
+    SCREEN_PROBES_PREVIOUS_RESOURCE,
+    SCREEN_PROBES_READ_RESOURCE
+} from "./chunk_screen_probe.js";
+import {
+    SCREEN_PROBE_CAMERA_PREVIOUS_RESOURCE,
+    SCREEN_PROBE_CAMERA_RESOURCE,
+    SCREEN_PROBE_DEPTH_RESOURCE,
+    SCREEN_PROBE_PBR_RESOURCE,
+    SCREEN_PROBE_VELOCITY_RESOURCE
+} from "./chunk_screen_probe_surface.js";
+import { chunk_screen_probe_brdf_density } from "./chunk_screen_probe_brdf_density.js";
+import { chunk_screen_probe_lighting_history } from "./chunk_screen_probe_lighting_history.js";
+import { chunk_screen_probe_ray_sort } from "./chunk_screen_probe_ray_sort.js";
+import { chunk_screen_probe_workgroup_sum } from "./chunk_screen_probe_workgroup_sum.js";
+import {
+    SCREEN_PROBE_BRDF_PIXEL_WEIGHT,
+    SCREEN_PROBE_MIN_PDF,
+    SCREEN_PROBE_OCTAHEDRON_LIMIT,
+    SCREEN_PROBE_THREAD_WORKGROUP_SIZE
+} from "./SCREEN_PROBE.js";
+
+/** Each probe's BRDF density, SH3 in three `vec4`s: coefficients 0–3, 4–7, and 8 alone. @type {ShaderResourceDescriptor} */
+export const SCREEN_PROBE_BRDF_READ_RESOURCE = ShaderResourceDescriptor.storageBuffer("screen_probe_brdf", WebGPUArray.vec4f);
+/** @type {ShaderResourceDescriptor} */
+export const SCREEN_PROBE_BRDF_WRITE_RESOURCE = ShaderResourceDescriptor.storageBuffer("screen_probe_brdf", WebGPUArray.vec4f, true);
+
+/** Each probe texel's lighting density, `r32float`, a texel a texel in the probes' atlas. @type {ShaderResourceDescriptor} */
+export const SCREEN_PROBE_LIGHTING_PDF_READ_RESOURCE = ShaderResourceDescriptor.texture("screen_probe_lighting_pdf", "unfilterable-float");
+/** @type {ShaderResourceDescriptor} */
+export const SCREEN_PROBE_LIGHTING_PDF_WRITE_RESOURCE = ShaderResourceDescriptor.storageTexture("screen_probe_lighting_pdf", "r32float", "2d", "write-only");
+
+/** Last frame's probe radiance after the spatial filter, `rgba16float`. @type {ShaderResourceDescriptor} */
+export const SCREEN_PROBE_RADIANCE_HISTORY_RESOURCE = ShaderResourceDescriptor.texture("screen_probe_radiance_history", "unfilterable-float");
+
+/** The G-buffer's shading normals. @type {ShaderResourceDescriptor} */
+export const SCREEN_PROBE_NORMAL_RESOURCE = ShaderResourceDescriptor.texture("tNormal", "uint");
+
+const brdf_resources = new ShaderResourceSetDescriptor();
+
+brdf_resources.createGroup()
+    .add(SCREEN_PROBE_FRAME_RESOURCE)
+    .add(SCREEN_PROBE_CAMERA_RESOURCE)
+    .add(SCREEN_PROBES_READ_RESOURCE)
+    .add(SCREEN_PROBE_DISPATCH_READ_RESOURCE)
+    .add(SCREEN_PROBE_BRDF_WRITE_RESOURCE)
+    .add(SCREEN_PROBE_DEPTH_RESOURCE)
+    .add(SCREEN_PROBE_PBR_RESOURCE)
+    .add(SCREEN_PROBE_NORMAL_RESOURCE);
+
+/**
+ * A probe's BRDF density (Lumen's `ScreenProbeComputeBRDFProbabilityDensityFunctionCS`): a workgroup a probe, a lane a
+ * pixel of an 8 × 8 grid over the square of 2D pixels about it, the pixels whose light interpolates from it. The centre
+ * lane takes the probe's own pixel.
+ *
+ * A pixel counts where it stands on the probe's surface: the probe's plane weight from the pixel's plane is past
+ * `SCREEN_PROBE_BRDF_PIXEL_WEIGHT` (the centre always counts). It adds its clamped cosine lobe about its shading normal
+ * as SH3 (`sh3_cosine_convolved_basis_at`, Lumen's `CalcDiffuseTransferSH3`), and the probe's density is the mean of
+ * the lobes: at a direction, how much the pixels' diffuse would weigh light from it.
+ *
+ * Lumen offsets its grid by `t/8·2D − 1` pixels, to one side of the probe; here the cells are centred on it, as the
+ * pixels that read the probe are.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_screen_probe_brdf_pdf = ComputeShader.from({
+    label: "Screen Probe BRDF PDF",
+    resources: brdf_resources,
+    body: CodeChunk.from(
+        //language=WGSL
+        `
+@compute @workgroup_size(${SCREEN_PROBE_THREAD_WORKGROUP_SIZE})
+fn main(
+    @builtin(workgroup_id) workgroup_id: vec3<u32>,
+    @builtin(local_invocation_index) lane: u32,
+    @builtin(subgroup_invocation_id) subgroup_lane: u32,
+    @builtin(subgroup_size) subgroup_size: u32,
+) {
+    let probe = folded_workgroup_index(workgroup_id);
+
+    if (probe >= screen_probe_count()) {
+        return;
+    }
+
+    let record = screen_probes[probe];
+
+    if (record.depth <= 0.0) {
+        return;
+    }
+
+    let frame = screen_probe_frame;
+    let span = f32(1u << frame.downsample_shift);
+
+    // an 8 × 8 grid of cells over [-D, D) about the probe, the centre lane on the probe's own pixel
+    let cell = vec2<f32>(f32(lane & 7u), f32(lane >> 3u));
+    let centre = lane == 36u;
+    let offset = select((cell + 0.5) * (span * 0.25) - span, vec2<f32>(0.0), centre);
+    let pixel = vec2<u32>(clamp(vec2<f32>(screen_probe_pixel_decode(record.pixel)) + offset, vec2<f32>(0.0), vec2<f32>(frame.view_size - 1u)));
+
+    var lobe = array<f32, 9>();
+    var counted = 0.0;
+
+    let device_depth = textureLoad(tDepth, pixel, 0).r;
+
+    if (!is_background(device_depth)) {
+        let uv = (vec2<f32>(pixel) + 0.5) / vec2<f32>(frame.view_size);
+        let position = project_position_from_depth(uv, device_depth, camera.view_projection_matrix_inverse);
+        let face = decode_g_buffer_face_normal(textureLoad(tPBR, pixel, 0));
+        let plane = vec4<f32>(face, dot(face, position));
+
+        if (centre || screen_probe_plane_weight(plane, record.position, record.depth) > ${SCREEN_PROBE_BRDF_PIXEL_WEIGHT}) {
+            lobe = sh3_cosine_convolved_basis_at(decode_g_buffer_normal(textureLoad(tNormal, pixel, 0).x));
+            counted = 1.0;
+        }
+    }
+
+    let s0 = screen_probe_workgroup_sum(vec4<f32>(lobe[0], lobe[1], lobe[2], lobe[3]), lane, subgroup_lane, subgroup_size);
+    let s1 = screen_probe_workgroup_sum(vec4<f32>(lobe[4], lobe[5], lobe[6], lobe[7]), lane, subgroup_lane, subgroup_size);
+    let s2 = screen_probe_workgroup_sum(vec4<f32>(lobe[8], counted, 0.0, 0.0), lane, subgroup_lane, subgroup_size);
+
+    if (lane == 0u) {
+        // the centre always counts, so the count is at least one
+        let mean = 1.0 / max(s2.y, 1.0);
+
+        screen_probe_brdf[probe * 3u] = s0 * mean;
+        screen_probe_brdf[probe * 3u + 1u] = s1 * mean;
+        screen_probe_brdf[probe * 3u + 2u] = vec4<f32>(s2.x * mean, 0.0, 0.0, 0.0);
+    }
+}
+`, [
+            chunk_screen_probe,
+            chunk_screen_probe_counts,
+            chunk_screen_probe_workgroup_sum,
+            chunk_folded_workgroup_index,
+            chunk_is_background,
+            chunk_project_position_from_depth,
+            chunk_decode_g_buffer_face_normal,
+            chunk_decode_g_buffer_normal,
+            chunk_sh3_cosine_convolved_basis_at,
+        ]),
+});
+
+const lighting_resources = new ShaderResourceSetDescriptor();
+
+lighting_resources.createGroup()
+    .add(SCREEN_PROBE_FRAME_RESOURCE)
+    .add(SCREEN_PROBE_EXPOSURE_RESOURCE)
+    .add(SCREEN_PROBE_EXPOSURE_PREVIOUS_RESOURCE)
+    .add(SCREEN_PROBE_CAMERA_PREVIOUS_RESOURCE)
+    .add(SCREEN_PROBE_VELOCITY_RESOURCE)
+    .add(SCREEN_PROBES_READ_RESOURCE)
+    .add(SCREEN_PROBES_PREVIOUS_RESOURCE)
+    .add(SCREEN_PROBE_PICKS_READ_RESOURCE)
+    .add(SCREEN_PROBE_DISPATCH_READ_RESOURCE)
+    .add(SCREEN_PROBE_RADIANCE_HISTORY_RESOURCE)
+    .add(SCREEN_PROBE_LIGHTING_PDF_WRITE_RESOURCE)
+    .add(STBN_VEC2_RESOURCE);
+
+lighting_resources.addGroup(PROBE_CLIPMAP_SAMPLING_GROUP);
+
+/**
+ * A probe's lighting density (Lumen's `ScreenProbeComputeLightingProbabilityDensityFunctionCS`): a workgroup a probe,
+ * its lanes over its n² texels.
+ *
+ * - **History**: last frame's four uniform probes around the probe's surface point that stood on its surface
+ *   (`screen_probe_lighting_history`), each giving its filtered radiance in the same texel, since a texel is a
+ *   direction in the world. They are averaged, pre-exposed as last frame's exposure left them and brought to this
+ *   frame's (`screen_probe_exposure` over `screen_probe_exposure_previous`), as Lumen rescales its history.
+ * - **The rest**: the share of the four that gave nothing, 1 − accepted / 4, is the world-space probes' radiance the
+ *   probe's pick reads (`screen_probe_picks`), along the texel's direction at this frame's jitter, pre-exposed by this
+ *   frame's exposure. Where nothing was picked, the history alone, or one where there is none: a density that ranks
+ *   nothing.
+ * - The density is each texel's luminance over the probe's sum.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_screen_probe_lighting_pdf = ComputeShader.from({
+    label: "Screen Probe Lighting PDF",
+    resources: lighting_resources,
+    body: CodeChunk.from(
+        //language=WGSL
+        `
+const SCREEN_PROBE_TEXEL_LIMIT = ${SCREEN_PROBE_OCTAHEDRON_LIMIT * SCREEN_PROBE_OCTAHEDRON_LIMIT}u;
+
+var<workgroup> screen_probe_texel_pdf: array<f32, SCREEN_PROBE_TEXEL_LIMIT>;
+
+// a history probe's radiance in a texel, none where it gave none: a uniform probe's place in last frame's atlas is its
+// tile's
+fn screen_probe_history_radiance(index: u32, texel: vec2<u32>) -> vec3<f32> {
+    if (index == SCREEN_PROBE_HISTORY_NONE) {
+        return vec3<f32>(0.0);
+    }
+
+    let columns = screen_probe_frame.previous_tile_count.x;
+    let base = vec2<u32>(index % columns, index / columns) * screen_probe_frame.octahedron_resolution;
+
+    return textureLoad(screen_probe_radiance_history, base + texel, 0).rgb;
+}
+
+fn screen_probe_picked_radiance(pick: ScreenProbePick, direction: vec3<f32>) -> vec3<f32> {
+    var radiance = vec3<f32>(0.0);
+
+    // each share by name
+    if (pick.weights.x > 0.0) { radiance += pick.weights.x * probe_clipmap_radiance(pick.slots.x, direction).rgb; }
+    if (pick.weights.y > 0.0) { radiance += pick.weights.y * probe_clipmap_radiance(pick.slots.y, direction).rgb; }
+    if (pick.weights.z > 0.0) { radiance += pick.weights.z * probe_clipmap_radiance(pick.slots.z, direction).rgb; }
+    if (pick.weights.w > 0.0) { radiance += pick.weights.w * probe_clipmap_radiance(pick.slots.w, direction).rgb; }
+
+    return radiance;
+}
+
+@compute @workgroup_size(${SCREEN_PROBE_THREAD_WORKGROUP_SIZE})
+fn main(
+    @builtin(workgroup_id) workgroup_id: vec3<u32>,
+    @builtin(local_invocation_index) lane: u32,
+    @builtin(subgroup_invocation_id) subgroup_lane: u32,
+    @builtin(subgroup_size) subgroup_size: u32,
+) {
+    let probe = folded_workgroup_index(workgroup_id);
+
+    if (probe >= screen_probe_count()) {
+        return;
+    }
+
+    let record = screen_probes[probe];
+
+    if (record.depth <= 0.0) {
+        return;
+    }
+
+    let frame = screen_probe_frame;
+    let n = frame.octahedron_resolution;
+    let texels = n * n;
+    let pick = screen_probe_picks[probe];
+    let picked = dot(pick.weights, vec4<f32>(1.0)) > 0.0;
+
+    // last frame's four uniform probes around the point, where they stood on its surface
+    let history = screen_probe_lighting_history(record);
+    let accepted = dot(select(vec4<f32>(0.0), vec4<f32>(1.0), history != vec4<u32>(SCREEN_PROBE_HISTORY_NONE)), vec4<f32>(1.0));
+    let rest = 1.0 - saturate(accepted / 4.0);
+    let exposure = screen_probe_exposure.value;
+    let rescale = exposure / max(screen_probe_exposure_previous.value, 1e-20);
+    let jitter = screen_probe_ray_jitter(screen_probe_noise_tile(probe, screen_probe_pixel_decode(record.pixel)));
+
+    var local_sum = 0.0;
+
+    for (var t = lane; t < texels; t += ${SCREEN_PROBE_THREAD_WORKGROUP_SIZE}u) {
+        let texel = vec2<u32>(t & (n - 1u), t >> frame.octahedron_shift);
+
+        var lighting = vec3<f32>(0.0);
+
+        if (accepted > 0.0) {
+            lighting = (screen_probe_history_radiance(history.x, texel) + screen_probe_history_radiance(history.y, texel)
+                + screen_probe_history_radiance(history.z, texel) + screen_probe_history_radiance(history.w, texel)) * (rescale / accepted);
+        }
+
+        if (rest > 0.0 && picked) {
+            let direction = screen_probe_ray_direction(screen_probe_ray_info_pack(texel, 1u), jitter);
+
+            lighting += (rest * exposure) * screen_probe_picked_radiance(pick, direction);
+        } else if (accepted == 0.0) {
+            lighting = vec3<f32>(1.0);
+        }
+
+        let pdf = rgb_to_luminance(lighting);
+
+        screen_probe_texel_pdf[t] = pdf;
+        local_sum += pdf;
+    }
+
+    let total = screen_probe_workgroup_sum(vec4<f32>(local_sum, 0.0, 0.0, 0.0), lane, subgroup_lane, subgroup_size).x;
+    let inverse = 1.0 / max(total, 1e-4);
+
+    for (var t = lane; t < texels; t += ${SCREEN_PROBE_THREAD_WORKGROUP_SIZE}u) {
+        textureStore(screen_probe_lighting_pdf, screen_probe_texel(probe, t), vec4<f32>(screen_probe_texel_pdf[t] * inverse, 0.0, 0.0, 0.0));
+    }
+}
+`, [
+            chunk_screen_probe,
+            chunk_screen_probe_counts,
+            chunk_screen_probe_ray_jitter,
+            chunk_screen_probe_workgroup_sum,
+            chunk_folded_workgroup_index,
+            chunk_screen_probe_lighting_history,
+            chunk_rgb_to_luminance,
+            chunk_probe_clipmap_sample_radiance,
+        ]),
+});
+
+const rays_resources = new ShaderResourceSetDescriptor();
+
+rays_resources.createGroup()
+    .add(SCREEN_PROBE_FRAME_RESOURCE)
+    .add(SCREEN_PROBES_READ_RESOURCE)
+    .add(SCREEN_PROBE_DISPATCH_READ_RESOURCE)
+    .add(SCREEN_PROBE_BRDF_READ_RESOURCE)
+    .add(SCREEN_PROBE_LIGHTING_PDF_READ_RESOURCE)
+    .add(SCREEN_PROBE_RAY_INFO_WRITE_RESOURCE);
+
+/**
+ * A probe's rays (Lumen's `ScreenProbeGenerateRaysCS`): a workgroup a probe, its lanes over its n² rays, each written
+ * as the texel and level it falls in (`screen_probe_ray_info_pack`), a ray's slot its place in the sorted order.
+ *
+ * 1. **Density**: each texel's BRDF density at its centre, `max(0, Σ brdf·Y(ω))`; times its lighting density · n².
+ *    A texel any of whose directions the BRDF density reaches `SCREEN_PROBE_MIN_PDF` is held there
+ *    (`screen_probe_brdf_keeps`), so the light ranks texels and only the pixels' lobes cull one; another falls under
+ *    it unless its light lifts it.
+ * 2. **Sort**: the probe's own rays, ascending by density, ties in index order (`screen_probe_ray_sort`: the engine's
+ *    bitonic network in the workgroup's memory, O(n² log² n) a probe, where Lumen ranks every ray against every other,
+ *    O(n⁴)).
+ * 3. **Reassignment**: the sorted rays in threes from the lowest; a three whose highest is under the minimum gives
+ *    its rays to the highest texel not yet given, from the top: that texel splits into its four children at twice the
+ *    resolution, the three take three children and the texel the fourth. One level only, as Lumen's parallel path.
+ *    A child holds a quarter of its parent's solid angle (the map is equal-area), which the composite weighs it by.
+ *
+ * With importance sampling off, or where the probe stands on no surface, ray i is texel i at the probe's own n.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_screen_probe_generate_rays = ComputeShader.from({
+    label: "Screen Probe Generate Rays",
+    resources: rays_resources,
+    body: CodeChunk.from(
+        //language=WGSL
+        `
+const SCREEN_PROBE_TEXEL_LIMIT = ${SCREEN_PROBE_OCTAHEDRON_LIMIT * SCREEN_PROBE_OCTAHEDRON_LIMIT}u;
+
+var<workgroup> screen_probe_split: atomic<u32>;
+
+fn screen_probe_brdf_of(probe: u32) -> ScreenProbeBRDF {
+    return ScreenProbeBRDF(screen_probe_brdf[probe * 3u], screen_probe_brdf[probe * 3u + 1u], screen_probe_brdf[probe * 3u + 2u].x);
+}
+
+@compute @workgroup_size(${SCREEN_PROBE_THREAD_WORKGROUP_SIZE})
+fn main(
+    @builtin(workgroup_id) workgroup_id: vec3<u32>,
+    @builtin(local_invocation_index) lane: u32,
+) {
+    let probe = folded_workgroup_index(workgroup_id);
+
+    if (probe >= screen_probe_count()) {
+        return;
+    }
+
+    let frame = screen_probe_frame;
+    let n = frame.octahedron_resolution;
+    let count = n * n;
+    let record = screen_probes[probe];
+
+    if (frame.importance_sampling == 0u || record.depth <= 0.0) {
+        for (var t = lane; t < count; t += ${SCREEN_PROBE_THREAD_WORKGROUP_SIZE}u) {
+            textureStore(screen_probe_ray_info, screen_probe_texel(probe, t), vec4<u32>(screen_probe_ray_info_pack(vec2<u32>(t & (n - 1u), t >> frame.octahedron_shift), 1u), 0u, 0u, 0u));
+        }
+
+        return;
+    }
+
+    let scale = f32(count);
+    let brdf = screen_probe_brdf_of(probe);
+
+    for (var t = lane; t < count; t += ${SCREEN_PROBE_THREAD_WORKGROUP_SIZE}u) {
+        let texel = vec2<u32>(t & (n - 1u), t >> frame.octahedron_shift);
+        let direction = uv_equal_area_sphere_decode((vec2<f32>(texel) + 0.5) / f32(n));
+
+        let density = screen_probe_brdf_density(brdf, direction);
+        let lighting = textureLoad(screen_probe_lighting_pdf, screen_probe_texel(probe, t), 0).r;
+
+        var pdf = density * lighting * scale;
+
+        // the light ranks what the lobes keep, it culls nothing
+        if (screen_probe_brdf_keeps(brdf, texel, n)) {
+            pdf = max(pdf, ${SCREEN_PROBE_MIN_PDF});
+        }
+
+        // held off −0, so the density's bits order as it does
+        screen_probe_sort[t] = vec2<u32>(screen_probe_ray_info_pack(texel, 1u), bitcast<u32>(abs(pdf)));
+    }
+
+    if (lane == 0u) {
+        atomicStore(&screen_probe_split, 0u);
+    }
+
+    workgroupBarrier();
+
+    screen_probe_ray_sort(lane, ${SCREEN_PROBE_THREAD_WORKGROUP_SIZE}u, count);
+
+    // threes of the lowest under the minimum give their rays to the highest, one texel each from the top
+    for (var i = lane; i < count; i += ${SCREEN_PROBE_THREAD_WORKGROUP_SIZE}u) {
+        let three = i / 3u;
+        let member = i - 3u * three;
+        let split = count - 1u - three;
+        let highest = 3u * three + 2u;
+
+        if (highest < split && bitcast<f32>(screen_probe_sort[count + highest].y) < ${SCREEN_PROBE_MIN_PDF}) {
+            let parent = screen_probe_sort[count + split].x;
+            let child = screen_probe_ray_info_texel(parent) * 2u + vec2<u32>((member + 1u) & 1u, (member + 1u) >> 1u);
+
+            screen_probe_sort[count + i] = vec2<u32>(screen_probe_ray_info_pack(child, screen_probe_ray_info_level(parent) - 1u), 0u);
+
+            if (member == 0u) {
+                atomicAdd(&screen_probe_split, 1u);
+            }
+        }
+    }
+
+    workgroupBarrier();
+
+    let split_count = atomicLoad(&screen_probe_split);
+
+    // and each split texel takes its first child
+    for (var i = lane; i < split_count; i += ${SCREEN_PROBE_THREAD_WORKGROUP_SIZE}u) {
+        let at = count + count - 1u - i;
+        let parent = screen_probe_sort[at].x;
+
+        screen_probe_sort[at] = vec2<u32>(screen_probe_ray_info_pack(screen_probe_ray_info_texel(parent) * 2u, screen_probe_ray_info_level(parent) - 1u), 0u);
+    }
+
+    workgroupBarrier();
+
+    for (var t = lane; t < count; t += ${SCREEN_PROBE_THREAD_WORKGROUP_SIZE}u) {
+        textureStore(screen_probe_ray_info, screen_probe_texel(probe, t), vec4<u32>(screen_probe_sort[count + t].x, 0u, 0u, 0u));
+    }
+}
+`, [
+            chunk_screen_probe,
+            chunk_screen_probe_counts,
+            chunk_folded_workgroup_index,
+            chunk_screen_probe_ray_sort,
+            chunk_screen_probe_brdf_density,
+        ]),
+});

package/src/shade/renderer/global_illumination/screen_probe/shader_screen_probe_indirect_lighting.d.ts

@@ -0,0 +1,27 @@
+/**
+ * The screen probes' deferred indirect light in one pass, for SSR off: the diffuse is the screen probes' (the temporal
+ * filter's output, E at the bent normal), and the specular the world-space probes', picked and resolved as the probe
+ * clipmap's fused pass takes it (`probe_clipmap_radiance_of`), the environment's where no probe weighs anything. The
+ * two are resolved as `shader_resolve_indirect_lighting` resolves the IBL pair: AO multiplies the diffuse, the
+ * specular is occluded along its lobe, and the result is added to the scene's colour.
+ *
+ * @type {ImageShader}
+ */
+export const shader_screen_probe_indirect_lighting: ImageShader;
+/**
+ * The screen probes' deferred diffuse, for SSR on: the temporal filter's output, E at the bent normal, times AO, as
+ * the IBL pass bakes AO in at the source, so `shader_resolve_indirect_lighting` and SSR's hits read it as any mode's.
+ *
+ * @type {ImageShader}
+ */
+export const shader_screen_probe_diffuse: ImageShader;
+/**
+ * Keep the frame's lit colour of the opaque surfaces for the next frame's screen traces: a thread a pixel, copied as
+ * it stands once the indirect light is added, before fog and transparencies, which are not the surfaces' radiance.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_screen_probe_color_capture: ComputeShader;
+import { ImageShader } from "../../shader/ImageShader.js";
+import { ComputeShader } from "../../shader/ComputeShader.js";
+//# sourceMappingURL=shader_screen_probe_indirect_lighting.d.ts.map

package/src/shade/renderer/global_illumination/screen_probe/shader_screen_probe_indirect_lighting.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shader_screen_probe_indirect_lighting.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/global_illumination/screen_probe/shader_screen_probe_indirect_lighting.js"],"names":[],"mappings":"AAmDA;;;;;;;;GAQG;AACH,oDAFU,WAAW,CA8FlB;AAQH;;;;;GAKG;AACH,0CAFU,WAAW,CAyBlB;AAQH;;;;;GAKG;AACH,gDAFU,aAAa,CAiBpB;4BAxMyB,6BAA6B;8BAD3B,+BAA+B"}