@woosh/meep-engine 3.67.0 → 3.69.0

package/src/shade/playground/trails/main.js

@@ -0,0 +1,258 @@
+import Vector3 from "../../../core/geom/Vector3.js";
+import { DEG_TO_RAD } from "../../../core/math/DEG_TO_RAD.js";
+import { Entity } from "../../../engine/ecs/Entity.js";
+import { EntityComponentDataset } from "../../../engine/ecs/EntityComponentDataset.js";
+import { EntityManager } from "../../../engine/ecs/EntityManager.js";
+import { t64_announce_change } from "../../../engine/ecs/transform/t64_announce_change.js";
+import { Transform64 } from "../../../engine/ecs/transform/Transform64.js";
+import Trail3D from "../../../engine/graphics/ecs/trail3d/Trail3D.js";
+import { GraphicsEngine } from "../../../engine/graphics3/GraphicsEngine.js";
+import { Trail3DSystem } from "../../../engine/graphics3/Trail3DSystem.js";
+import { OrbitalCameraController } from "../../renderer/camera/orbital/OrbitalCameraController.js";
+import { create_frame_loop } from "../../renderer/create_frame_loop.js";
+import { Scene } from "../../renderer/scene/Scene.js";
+import { ShadeTransparencyMode } from "../../renderer/ShadeTransparencyMode.js";
+
+/**
+ * A field of trails on figures-of-eight, simulated in compute and extruded in the vertex stage by
+ * `Trail3DSystem`, drawn through AVBOIT.
+ *
+ * Query: `n` trails (64), `age` maxAge in seconds (2), `radial` (8, or a list such as
+ * `4,8,16` taken in turn), `width` (0.08), `debug` to drive frames by hand through `__step(n, dt)`
+ * instead of the frame loop.
+ */
+
+const query = new URLSearchParams(location.search);
+
+const number = (name, fallback) => {
+    const value = Number(query.get(name));
+
+    return query.has(name) && Number.isFinite(value) ? value : fallback;
+};
+
+const COUNT = Math.max(1, Math.floor(number("n", 64)));
+const MAX_AGE = number("age", 2);
+/** Radial segments, one value or a comma list the trails take in turn: each distinct value is its own draw. */
+const RADIALS = (query.get("radial") ?? "8").split(",").map(v => Math.max(3, Math.floor(Number(v) || 8)));
+const WIDTH = number("width", 0.08);
+
+/** Trails per row of the field. */
+const ROW = Math.ceil(Math.sqrt(COUNT));
+
+/** Spacing of the field. */
+const SPACING = 3;
+
+const element = id => document.getElementById(id);
+
+const view_size = () => [Math.max(1, window.innerWidth), Math.max(1, window.innerHeight)];
+
+/**
+ * Where trail `i` is at time `t`: a figure-of-eight round its own place in the field, each at its own
+ * phase, rising and falling.
+ *
+ * @param {number} i
+ * @param {number} t
+ * @param {number[]} out
+ */
+function place(i, t, out) {
+    const column = i % ROW;
+    const row = Math.floor(i / ROW);
+
+    const phase = i * 0.6180339 * Math.PI * 2;
+    const a = phase + t * 1.3;
+
+    out[0] = (column - (ROW - 1) * 0.5) * SPACING + Math.sin(a) * 1.2;
+    out[1] = 1.5 + Math.sin(a * 2 + phase) * 0.5;
+    out[2] = (row - (ROW - 1) * 0.5) * SPACING + Math.sin(a * 2) * 0.8;
+}
+
+/**
+ * A colour per trail, bright and linear.
+ *
+ * @param {number} i
+ * @returns {number[]}
+ */
+function tint(i) {
+    const h = (i * 0.137) % 1;
+    const k = n => (n + h * 6) % 6;
+    const f = n => 1 - Math.max(0, Math.min(k(n), 4 - k(n), 1));
+
+    return [f(5) * 2, f(3) * 2, f(1) * 2];
+}
+
+async function main() {
+    const graphics = new GraphicsEngine();
+    const scene = new Scene();
+
+    graphics.set_scene(scene);
+
+    element("viewport").appendChild(graphics.viewport.el);
+
+    const [width, height] = view_size();
+
+    graphics.viewport.size.set(width, height);
+
+    const dataset = new EntityComponentDataset();
+    const entities = new EntityManager();
+
+    const system = new Trail3DSystem(graphics, scene);
+
+    entities.addSystem(system);
+    entities.attachDataset(dataset);
+
+    await new Promise((resolve, reject) => entities.startup(resolve, reject));
+
+    const transforms = [];
+    const position = [0, 0, 0];
+
+    for (let i = 0; i < COUNT; i++) {
+        const trail = new Trail3D();
+
+        trail.maxAge = MAX_AGE;
+        trail.width = WIDTH;
+        trail.radialSegments = RADIALS[i % RADIALS.length];
+
+        const [r, g, b] = tint(i);
+
+        trail.color.set(r, g, b, 0.9);
+
+        const transform = new Transform64();
+
+        place(i, 0, position);
+        transform.setTranslation(position[0], position[1], position[2]);
+        transform.updateMatrix();
+
+        const entity = new Entity().add(transform).add(trail).build(dataset);
+
+        transforms.push({ entity, transform });
+    }
+
+    const camera = graphics.camera.camera;
+    const extent = ROW * SPACING;
+
+    camera.near = 0.05;
+    camera.far = 1000;
+    camera.fov = 50 * DEG_TO_RAD;
+
+    const controller = new OrbitalCameraController(camera, document.body);
+
+    controller.look(new Vector3(0, extent * 0.55 + 4, extent * 0.75 + 6), new Vector3(0, 1.5, 0));
+
+    graphics.on.contextFailed.add(failure => show_message("There will be no rendering.\n\n" + failure.message));
+
+    try {
+        await graphics.start();
+    } catch (e) {
+        console.error(e);
+        return;
+    }
+
+    const renderer = graphics.renderer;
+
+    /** What the device reported on its own: validation failures and the like. */
+    const gpu_errors = [];
+
+    renderer.graphics.device.addEventListener("uncapturederror", event => {
+        gpu_errors.push(event.error.message);
+        console.error(event.error.message);
+    });
+
+    renderer.transparency_mode = ShadeTransparencyMode.AVBOIT;
+    renderer.feature_automatic_exposure_enabled = false;
+    renderer.exposure_compensation = 0;
+
+    let time = 0;
+    let frame_index = 0;
+
+    /** Frames the renderer drew: none while its pipelines compile. */
+    let drawn = 0;
+
+    /** CPU milliseconds of the last frames: the tick and the render call. */
+    const cpu_ms = [];
+
+    function frame(dt) {
+        const [w, h] = view_size();
+
+        if (w !== graphics.viewport.size.x || h !== graphics.viewport.size.y) {
+            graphics.viewport.size.set(w, h);
+        }
+
+        time += dt;
+
+        for (let i = 0; i < transforms.length; i++) {
+            const { entity, transform } = transforms[i];
+
+            place(i, time, position);
+            transform.setTranslation(position[0], position[1], position[2]);
+            transform.updateMatrix();
+
+            t64_announce_change(dataset, entity);
+        }
+
+        controller.update();
+
+        const t0 = performance.now();
+
+        entities.update(dt);
+        if (graphics.render(dt)) {
+            drawn++;
+        }
+
+        cpu_ms.push(performance.now() - t0);
+
+        if (cpu_ms.length > 600) {
+            cpu_ms.shift();
+        }
+
+        frame_index++;
+
+        if (frame_index % 30 === 0) {
+            const sorted = [...cpu_ms].sort((a, b) => a - b);
+
+            element("hud").textContent = `${COUNT} trails · ${MAX_AGE} s · radial ${RADIALS.join(",")} · `
+                + `CPU ${sorted[Math.floor(sorted.length / 2)].toFixed(2)} ms/frame (median)`;
+        }
+    }
+
+    Object.assign(globalThis, {
+        graphics, renderer, scene, dataset, entities, system, camera, controller, Vector3,
+        __cpu_ms: cpu_ms,
+        __gpu_errors: gpu_errors,
+        __frame_index: () => frame_index,
+        __drawn: () => drawn,
+        __seek: t => {
+            time = t;
+        },
+    });
+
+    if (query.has("debug")) {
+        globalThis.__step = (n = 1, dt = 1 / 60) => {
+            for (let i = 0; i < n; i++) {
+                frame(dt);
+            }
+
+            return frame_index;
+        };
+
+        globalThis.__ready = true;
+
+        return;
+    }
+
+    globalThis.__ready = true;
+
+    create_frame_loop(dt => frame(Math.min(dt, 0.05)));
+}
+
+function show_message(text) {
+    const node = element("message");
+
+    if (node !== null) {
+        node.textContent = text;
+    }
+}
+
+main().catch(e => {
+    console.error(e);
+    show_message("The trails playground failed to start — see the console.\n\n" + e.message);
+});

package/src/shade/renderer/Renderer.d.ts

@@ -44,6 +44,12 @@ export class Renderer {
      * @type {ProbeClipmapSettings}
      */
     probe_clipmap: ProbeClipmapSettings;
+    /**
+     * Settings of {@link ShadeIndirectLightingMode.ScreenProbes}, read every frame it runs; its world, the bricks and
+     * the world-space probes, is set by {@link probe_clipmap}. See {@link ScreenProbeSettings}.
+     * @type {ScreenProbeSettings}
+     */
+    screen_probes: ScreenProbeSettings;
     /**
      * Which order-independent transparency technique draws the transparent buckets. Both modes
      * are wired at the single transparency call site and take the same inputs, so this is safe to
@@ -577,6 +583,7 @@ import { SceneManager } from "./scene/SceneManager.js";
 import { ShadeIndirectLightingMode } from "./ShadeIndirectLightingMode.js";
 import { MaterialDispatch } from "./material/dispatch/MaterialDispatch.js";
 import { ProbeClipmapSettings } from "./global_illumination/probe_clipmap/ProbeClipmapSettings.js";
+import { ScreenProbeSettings } from "./global_illumination/screen_probe/ScreenProbeSettings.js";
 import { ShadeTransparencyMode } from "./ShadeTransparencyMode.js";
 import { ToneMapper } from "./deferred/tonemap/ToneMapper.js";
 import { AVBOITSettings } from "./rasterize/native/avboit/AVBOITSettings.js";

package/src/shade/renderer/Renderer.d.ts.map

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

package/src/shade/renderer/Renderer.js

@@ -16,8 +16,11 @@ import { shade_device_floor_unmet } from "../device/shade_device_floor_unmet.js"
 import { ShadeDeviceFailure } from "../device/ShadeDeviceFailure.js";
 import { PipelineEnquiry } from "../device/pipeline/PipelineEnquiry.js";
 import { ShadeGPUCommandContext } from "../device/ShadeGPUCommandContext.js";
+import { create_atmosphere_sun_state, resolve_atmosphere_sun } from "./atmosphere/resolve_atmosphere_sun.js";
+import { SKY_VIEW_LUT_HEIGHT, SKY_VIEW_LUT_WIDTH, shader_sky_view_lut } from "./atmosphere/shader_sky_view_lut.js";
 import { CameraManager } from "./camera/CameraManager.js";
 import { shader_background } from "./deferred/shader_background.js";
+import { shader_background_sky } from "./deferred/shader_background_sky.js";
 import { shader_composite_volumetrics } from "./deferred/shader_composite_volumetrics.js";
 import { shader_deferred_main } from "./deferred/shader_deferred_main.js";
 import { LOCAL_LIGHT_SHADING } from "./deferred/LOCAL_LIGHT_SHADING.js";
@@ -48,6 +51,14 @@ import { shader_diffuse_LPV } from "./global_illumination/lpv/shader_diffuse_LPV
 import { GPUProbeClipmapGI } from "./global_illumination/probe_clipmap/GPUProbeClipmapGI.js";
 import { ProbeClipmapSettings } from "./global_illumination/probe_clipmap/ProbeClipmapSettings.js";
 import { ProbeClipmapDebugView } from "./global_illumination/probe_clipmap/debug/ProbeClipmapDebugView.js";
+import { GPUScreenProbeGI } from "./global_illumination/screen_probe/GPUScreenProbeGI.js";
+import { ScreenProbeSettings } from "./global_illumination/screen_probe/ScreenProbeSettings.js";
+import { ScreenProbeDebugView } from "./global_illumination/screen_probe/ScreenProbeDebugView.js";
+import { graph_screen_probe_debug_view } from "./global_illumination/screen_probe/graph_screen_probe_debug_view.js";
+import {
+    shader_screen_probe_diffuse,
+    shader_screen_probe_indirect_lighting
+} from "./global_illumination/screen_probe/shader_screen_probe_indirect_lighting.js";
 import { shader_resolve_indirect_lighting } from "./global_illumination/shader_resolve_indirect_lighting.js";
 import { GraphicsContext } from "./GraphicsContext.js";
 import {
@@ -137,6 +148,8 @@ METRICS.create({ name: 'frame_time' });
  */
 const INTERNAL_RESOLUTION_MIN = 1;
 
+const SKY_VIEW_LUT_RESOLUTION = Object.freeze([SKY_VIEW_LUT_WIDTH, SKY_VIEW_LUT_HEIGHT]);
+
 MetricCollectionConsoleMonitor.from(METRICS);
 
 export class Renderer {
@@ -243,6 +256,22 @@ export class Renderer {
      */
     #probe_clipmap_gi;
 
+    /**
+     * Settings of {@link ShadeIndirectLightingMode.ScreenProbes}, read every frame it runs; its world, the bricks and
+     * the world-space probes, is set by {@link probe_clipmap}. See {@link ScreenProbeSettings}.
+     * @type {ScreenProbeSettings}
+     */
+    screen_probes = new ScreenProbeSettings();
+
+    /**
+     * The main view's screen probes under {@link ShadeIndirectLightingMode.ScreenProbes}, over the world
+     * {@link #probe_clipmap_gi} holds: made on the first frame in the mode, given back on the first frame out of it.
+     *
+     * Constructed in {@link initialize}.
+     * @type {GPUScreenProbeGI | undefined}
+     */
+    #screen_probe_gi;
+
     /**
      * Which order-independent transparency technique draws the transparent buckets. Both modes
      * are wired at the single transparency call site and take the same inputs, so this is safe to
@@ -713,6 +742,26 @@ export class Renderer {
      */
     #extensions = new RenderExtensionRegistry();
 
+    /**
+     * Reusable per-frame sun state and immediate uniform payloads for Hillaire Sky-View LUT and
+     * background solar-disc composition.
+     */
+    #sky_sun_state = create_atmosphere_sun_state();
+
+    #sky_view_lut_settings = {
+        sun_direction: this.#sky_sun_state.sun_direction,
+        resolution_x: SKY_VIEW_LUT_WIDTH,
+        sun_irradiance: this.#sky_sun_state.sun_irradiance,
+        resolution_y: SKY_VIEW_LUT_HEIGHT,
+    };
+
+    #sky_background_settings = {
+        sun_direction: this.#sky_sun_state.sun_direction,
+        sun_disk_radius: 0,
+        sun_irradiance: this.#sky_sun_state.sun_irradiance,
+        sun_has_disc: 0,
+    };
+
     /**
      * Raised when there is no usable device — the browser has no WebGPU, the hardware is below the
      * floor, or a working device was lost while running. Carries a {@link ShadeDeviceFailure}.
@@ -1150,6 +1199,8 @@ export class Renderer {
         }
 
         this.#volumetrics?.reset_history();
+
+        this.#screen_probe_gi?.reset_history();
     }
 
     /**
@@ -1252,6 +1303,7 @@ export class Renderer {
      * @param {number} params.gr_occlusion_clip
      * @param {number} params.gr_buffer_camera_current
      * @param {number} params.gr_buffer_camera_previous
+     * @param {number} params.gr_exposure_multiplier - graph resource ID of the exposure the last frame was shown at
      * @param {Vector2} params.resolution
      * @returns {number} Updated scene-color graph resource ID
      */
@@ -1273,6 +1325,7 @@ export class Renderer {
                                  gr_occlusion_clip,
                                  gr_buffer_camera_current,
                                  gr_buffer_camera_previous,
+                                 gr_exposure_multiplier,
                                  resolution,
                              }) {
 
@@ -1354,6 +1407,65 @@ export class Renderer {
                 }
                 break;
 
+            case ShadeIndirectLightingMode.ScreenProbes: {
+                // the diffuse is the screen probes', resolved once the bent normals exist; the specular the world-space
+                // probes', as under the probe clipmap
+                const diffuse = this.#screen_probe_gi.graph_resolve({
+                    graph,
+                    depth: gr_texture_depth_current,
+                    depth_previous: gr_texture_depth_previous,
+                    pbr: gr_texture_pbr,
+                    velocity: gr_velocity,
+                    bent_normals,
+                    exposure: gr_exposure_multiplier,
+                });
+
+                if (prefer_fused && !this.feature_ssr_enabled) {
+                    [current_color_out] = graph_image_pass({
+                        graph,
+                        shader: shader_screen_probe_indirect_lighting,
+                        output: [current_color_out],
+                        input_depth: gr_texture_depth_current,
+                        load_op: "load",
+                        inputs: this.#probe_clipmap_gi.write_sampling_bindings({
+                            ...this.#probe_clipmap_indirect_inputs({
+                                view_ctx,
+                                depth: gr_texture_depth_current,
+                                normal: gr_texture_normal,
+                                bent_normal: bent_normals,
+                                albedo_ao: gr_texture_material_albedo_ao,
+                                pbr: gr_texture_pbr,
+                                environment: gr_texture_environment,
+                                camera: gr_buffer_camera_current,
+                            }),
+                            tScreenProbeDiffuse: diffuse,
+                        }),
+                    });
+
+                    return current_color_out;
+                }
+
+                diffuse_pass = {
+                    shader: shader_screen_probe_diffuse,
+                    inputs: {
+                        tGBufferAlbedo: gr_texture_material_albedo_ao,
+                        tScreenProbeDiffuse: diffuse,
+                    },
+                };
+                specular_pass = {
+                    shader: shader_specular_IBL,
+                    inputs: {
+                        tBentNormals: bent_normals,
+                        tNormals: gr_texture_normal,
+                        tDepth: gr_texture_depth_current,
+                        tPBR: gr_texture_pbr,
+                        tEnvironment: gr_texture_environment,
+                        camera: gr_buffer_camera_current,
+                    },
+                };
+                break;
+            }
+
             case ShadeIndirectLightingMode.Brick4:
                 // SSR needs its own specular resolve and denoising passes.
                 if (prefer_fused && !this.feature_ssr_enabled) {
@@ -1469,7 +1581,7 @@ export class Renderer {
                 input_environment: gr_texture_environment,
                 brick4: ssr_brick4,
                 lpv: ssr_lpv,
-                input_indirect_diffuse: mode === ShadeIndirectLightingMode.ProbeClipmap ? indirect_diffuse : undefined,
+                input_indirect_diffuse: mode === ShadeIndirectLightingMode.ProbeClipmap || mode === ShadeIndirectLightingMode.ScreenProbes ? indirect_diffuse : undefined,
                 // in every mode: a clipmap of no cascade while it has no probes
                 probes: this.#probe_clipmap_gi,
                 shader_switches: this.#shader_switches,
@@ -1843,6 +1955,7 @@ export class Renderer {
         this.#views = new ViewManager(graphics, this.#cameras, this.#scenes);
         this.#volumetrics = new GPUViewVolumetrics(this.device);
         this.#probe_clipmap_gi = new GPUProbeClipmapGI(graphics);
+        this.#screen_probe_gi = new GPUScreenProbeGI(this.device);
 
         const resolution_internal = this.#internal_resolution.asArray();
 
@@ -1954,6 +2067,8 @@ export class Renderer {
         }
 
         enquiry.render.push(shader_background.pipeline_for(color_formats));
+        enquiry.render.push(shader_sky_view_lut.pipeline);
+        enquiry.render.push(shader_background_sky.pipeline_for(color_formats));
 
         if (this.indirect_lighting_mode === ShadeIndirectLightingMode.IBL) {
             if (!this.feature_ssr_enabled) {
@@ -2067,6 +2182,7 @@ export class Renderer {
         this.#nss?.destroy();
         this.#volumetrics?.destroy();
         this.#probe_clipmap_gi?.destroy();
+        this.#screen_probe_gi?.destroy();
 
         this.#views?.destroy();
         this.#scenes?.destroy();
@@ -2964,7 +3080,11 @@ export class Renderer {
         // (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §5); its hits trace their own shadow rays, so it reads no
         // shadow map. Made for this view and these settings on the first frame in the mode, and given back
         // on the first frame out of it.
-        if (this.indirect_lighting_mode === ShadeIndirectLightingMode.ProbeClipmap) {
+        // The screen probes trace the probe clipmap's world and read its world-space probes past their reach, so that
+        // world runs under both modes; the screen probes follow it in the same frame.
+        const screen_probes = this.indirect_lighting_mode === ShadeIndirectLightingMode.ScreenProbes;
+
+        if (this.indirect_lighting_mode === ShadeIndirectLightingMode.ProbeClipmap || screen_probes) {
             this.#probe_clipmap_gi.graph_update({
                 graph,
                 view: view_ctx,
@@ -2979,6 +3099,25 @@ export class Renderer {
             this.#probe_clipmap_gi.release();
         }
 
+        if (screen_probes) {
+            this.#screen_probe_gi.graph_update({
+                graph,
+                view: view_ctx,
+                settings: this.screen_probes,
+                world: this.#probe_clipmap_gi,
+                stbn: STATIC_GRAPHICS_ENGINE_ASSETS.stbn_vec2,
+                depth: gr_texture_depth_current,
+                normal: gr_texture_normal,
+                pbr: gr_texture_pbr,
+                velocity: gr_velocity,
+                occlusion: gr_occlusion_clip,
+                hzb: gr_texture_hzb,
+                exposure: gr_exposure_multiplier,
+            });
+        } else {
+            this.#screen_probe_gi.release();
+        }
+
         const volumetrics = this.#volumetrics.graph_update({
             graph,
             view: view_ctx,
@@ -3098,18 +3237,60 @@ export class Renderer {
 
 
         // Shade background
-        [current_color_out] = graph_image_pass({
-            graph,
-            shader: shader_background,
-            inputs: {
-                camera: view_ctx.camera.buffer,
-                view: view_ctx.uniform_buffer.buffer,
-                tEnvironment: gr_texture_environment,
-            },
-            input_depth: gr_texture_depth_current,
-            load_op: "load",
-            output: [current_color_out],
-        });
+        if (scene_ctx.scene.lights.environment === undefined && scene_ctx.scene.atmosphere.enabled) {
+            const sky = scene_ctx.sky;
+            sky.update();
+
+            const gr_sky_transmittance = volumetrics.lut_transmittance
+                ?? graph_import_texture(graph, sky.lut_transmittance, "sky/transmittance");
+            const gr_sky_multiscatter = volumetrics.lut_multiple_scattering
+                ?? graph_import_texture(graph, sky.lut_multiple_scattering, "sky/multiscatter");
+
+            const sun = resolve_atmosphere_sun(scene_ctx.scene, this.#sky_sun_state);
+            this.#sky_background_settings.sun_disk_radius = sun.sun_disk_radius;
+            this.#sky_background_settings.sun_has_disc = sun.sun_has_disc;
+
+            const [gr_sky_view_lut] = graph_image_pass({
+                graph,
+                shader: shader_sky_view_lut,
+                output_resolution: SKY_VIEW_LUT_RESOLUTION,
+                inputs: {
+                    settings: this.#sky_view_lut_settings,
+                    camera: view_ctx.camera.buffer,
+                    atmosphere: sky.parameters_buffer.buffer,
+                    tSkyLutTransmittance: gr_sky_transmittance,
+                    tSkyLutMultiscatter: gr_sky_multiscatter,
+                },
+            });
+
+            [current_color_out] = graph_image_pass({
+                graph,
+                shader: shader_background_sky,
+                inputs: {
+                    settings: this.#sky_background_settings,
+                    camera: view_ctx.camera.buffer,
+                    atmosphere: sky.parameters_buffer.buffer,
+                    tSkyViewLut: gr_sky_view_lut,
+                    tSkyLutTransmittance: gr_sky_transmittance,
+                },
+                input_depth: gr_texture_depth_current,
+                load_op: "load",
+                output: [current_color_out],
+            });
+        } else {
+            [current_color_out] = graph_image_pass({
+                graph,
+                shader: shader_background,
+                inputs: {
+                    camera: view_ctx.camera.buffer,
+                    view: view_ctx.uniform_buffer.buffer,
+                    tEnvironment: gr_texture_environment,
+                },
+                input_depth: gr_texture_depth_current,
+                load_op: "load",
+                output: [current_color_out],
+            });
+        }
 
         current_color_out = this.#graph_indirect_lighting({
             graph,
@@ -3129,9 +3310,15 @@ export class Renderer {
             gr_occlusion_clip,
             gr_buffer_camera_current,
             gr_buffer_camera_previous,
+            gr_exposure_multiplier,
             resolution,
         });
 
+        // the opaque surfaces' lit colour, the screen probes' hits' radiance next frame: before fog and transparencies
+        if (screen_probes) {
+            this.#screen_probe_gi.graph_capture({ graph, color: current_color_out });
+        }
+
         // Composite volumetric fog over the finalized opaque + background + indirect colour.
         // A dedicated pass (not inline in the shading shaders) because indirect lighting is added
         // in a separate additively-blended pass, so the full surface radiance only exists here.
@@ -3299,7 +3486,18 @@ export class Renderer {
 
         // the probe clipmap mode's debug views replace the colour the same way
         if (
-            this.indirect_lighting_mode === ShadeIndirectLightingMode.ProbeClipmap
+            screen_probes
+            && this.screen_probes.debug_view !== ScreenProbeDebugView.None
+        ) {
+            current_color_out = graph_screen_probe_debug_view({
+                graph,
+                gi: this.#screen_probe_gi,
+                view_mode: this.screen_probes.debug_view,
+                depth: gr_texture_depth_current,
+                resolution: resolution_internal.asArray(),
+            });
+        } else if (
+            (this.indirect_lighting_mode === ShadeIndirectLightingMode.ProbeClipmap || screen_probes)
             && this.probe_clipmap.debug_view !== ProbeClipmapDebugView.None
         ) {
             current_color_out = this.#probe_clipmap_gi.graph_debug_view({

package/src/shade/renderer/ShadeIndirectLightingMode.d.ts

@@ -8,5 +8,6 @@ export namespace ShadeIndirectLightingMode {
     let Brick4: number;
     let LPV: number;
     let ProbeClipmap: number;
+    let ScreenProbes: number;
 }
 //# sourceMappingURL=ShadeIndirectLightingMode.d.ts.map

package/src/shade/renderer/ShadeIndirectLightingMode.js

@@ -17,4 +17,13 @@ export const ShadeIndirectLightingMode = {
      * `Renderer.probe_clipmap`. Lit as {@link IBL} until its probes are traced (that proposal's §13, S4).
      */
     ProbeClipmap: 3,
+    /**
+     * Lumen's screen probe gather over the {@link ProbeClipmap}'s world: probes placed on the G-buffer every few
+     * pixels, more densely where interpolation between them would cross an edge, traced through the screen and
+     * then the SDF bricks, the world-space probes standing in for what lies past a probe's own reach, and
+     * reprojected from frame to frame (`global_illumination/screen_probe/GPUScreenProbeGI.js`). The opaque surfaces'
+     * diffuse light is the screen probes'; everything else reads the world-space probes as under
+     * {@link ProbeClipmap}. Settings are `Renderer.screen_probes`, and `Renderer.probe_clipmap` for the world.
+     */
+    ScreenProbes: 4,
 };