@woosh/meep-engine 3.58.0 → 3.59.0

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

@@ -0,0 +1,360 @@
+import Quaternion from "../../../core/geom/Quaternion.js";
+import Vector3 from "../../../core/geom/Vector3.js";
+import { AABB3 } from "../../../core/geom/3d/aabb/AABB3.js";
+import { DEG_TO_RAD } from "../../../core/math/DEG_TO_RAD.js";
+import { EntityComponentDataset } from "../../../engine/ecs/EntityComponentDataset.js";
+import { Transform64 } from "../../../engine/ecs/transform/Transform64.js";
+import { prefab_compile } from "../../../engine/graphics3/prefab/prefab_compile.js";
+import { prefab_place } from "../../../engine/graphics3/prefab/prefab_place.js";
+import { shade_bundle_bounds } from "../../../engine/graphics3/shade_bundle_bounds.js";
+import { camera_frame_sphere } from "../../renderer/camera/camera_frame_sphere.js";
+import { OrbitalCameraController } from "../../renderer/camera/orbital/OrbitalCameraController.js";
+import { PerspectiveCamera } from "../../renderer/camera/PerspectiveCamera.js";
+import { create_frame_loop } from "../../renderer/create_frame_loop.js";
+import { ProbeClipmapDebugView } from "../../renderer/global_illumination/probe_clipmap/debug/ProbeClipmapDebugView.js";
+import { make_sunlight } from "../../renderer/light/make_sunlight.js";
+import { PointLight } from "../../renderer/light/model/PointLight.js";
+import { place_light } from "../../renderer/light/place_light.js";
+import { load_gltf } from "../../renderer/loader/gltf/load_gltf.js";
+import { Renderer } from "../../renderer/Renderer.js";
+import { Scene } from "../../renderer/scene/Scene.js";
+import { load_scene_from_url } from "../../renderer/scene/serialization/deserialize_scene.js";
+import { ShadeIndirectLightingMode } from "../../renderer/ShadeIndirectLightingMode.js";
+import { load_default_environment } from "../load_default_environment.js";
+import { make_playground_asset_manager } from "../make_playground_asset_manager.js";
+
+/**
+ * The probe clipmap GI (`ShadeIndirectLightingMode.ProbeClipmap`, PROBE_CLIPMAP_PROPOSAL_2026_10_27.md) on
+ * Sponza, to drive by hand: the mode against IBL, its debug views, the sun moved, point lights for the hits'
+ * local lights.
+ *
+ * Runs under the dev server (`npm run dev`), which serves `test_assets/`. The panel is hand-rolled, as the
+ * other playgrounds' are.
+ */
+
+/**
+ * Served by the dev server out of `test_assets/`, which is gitignored; `test_assets/README.md` says how to put
+ * Sponza there.
+ * @type {string}
+ */
+const DEFAULT_SCENE_URL = '/test_assets/Sponza/glTF/Sponza.gltf';
+
+/**
+ * Mesh SDF bricks baked a frame while the caches fill, as this page starts. The engine's default is a frame-time
+ * knob, under which Sponza takes minutes to bake whole.
+ * @type {number}
+ */
+const PAGE_BAKE_BUDGET = 256;
+
+/**
+ * Point lights the toggle places along the scene's long axis.
+ * @type {number}
+ */
+const POINT_LIGHT_COUNT = 8;
+
+/**
+ * A frame-time readout, kept as a rolling mean so the number is readable rather than jittering.
+ */
+class FrameTimer {
+    #samples = new Float64Array(60);
+    #count = 0;
+    #cursor = 0;
+
+    /**
+     * @param {number} seconds
+     */
+    add(seconds) {
+        this.#samples[this.#cursor] = seconds * 1000;
+        this.#cursor = (this.#cursor + 1) % this.#samples.length;
+        this.#count = Math.min(this.#count + 1, this.#samples.length);
+    }
+
+    /**
+     * @returns {number} mean frame time in milliseconds, or 0 before there is anything to average
+     */
+    get mean_ms() {
+        if (this.#count === 0) {
+            return 0;
+        }
+
+        let total = 0;
+
+        for (let i = 0; i < this.#count; i++) {
+            total += this.#samples[i];
+        }
+
+        return total / this.#count;
+    }
+}
+
+/**
+ * Stand the page up. Called by the page rather than run on import, so that nothing here touches the DOM
+ * until there is one.
+ *
+ * @returns {Promise<void>}
+ */
+export async function start() {
+    const element = id => document.getElementById(id);
+
+    const status_element = element('status');
+    const stats_element = element('stats');
+
+    function set_status(text, kind = '') {
+        status_element.textContent = text;
+        status_element.className = kind;
+    }
+
+    const context = element('view').getContext('webgpu');
+
+    if (context === null) {
+        set_status('no WebGPU context — this browser has none, or the page is not a secure context', 'fail');
+        return;
+    }
+
+    const renderer = new Renderer();
+
+    set_status('acquiring a device…');
+
+    await renderer.initialize({ context });
+
+    renderer.indirect_lighting_mode = ShadeIndirectLightingMode.ProbeClipmap;
+    renderer.probe_clipmap.mesh_sdf_bake_budget = PAGE_BAKE_BUDGET;
+
+    const camera = new PerspectiveCamera();
+
+    camera.near = 0.1;
+    camera.far = 200;
+    camera.fov = 72 * DEG_TO_RAD;
+    camera.aspect = renderer.aspect_ratio;
+
+    const scene = new Scene();
+
+    // lights stand at entities, so the scene names a dataset for them
+    scene.dataset = new EntityComponentDataset();
+
+    const scene_context = renderer.scenes.obtain(scene);
+
+    // body rather than the canvas: the controller's keyboard device needs a focusable element
+    const controller = new OrbitalCameraController(camera, document.body);
+
+    // handy from the console
+    globalThis.renderer = renderer;
+    globalThis.scene = scene;
+    globalThis.camera = camera;
+
+    // ---- the scene ------------------------------------------------------------------------
+
+    const url = new URLSearchParams(location.search).get('scene') ?? DEFAULT_SCENE_URL;
+
+    set_status(`loading ${url} …`);
+
+    let bundle;
+
+    try {
+        bundle = /\.gltf$|\.glb$/i.test(url)
+            ? await load_gltf(url, { assetManager: await make_playground_asset_manager() })
+            : await load_scene_from_url(url, scene);
+    } catch (error) {
+        set_status(`could not load ${url} (${error.message}); see test_assets/README.md`, 'fail');
+        console.error(error);
+        return;
+    }
+
+    const placed = prefab_place(scene_context, scene.dataset, prefab_compile(bundle), new Transform64());
+
+    const bounds = new AABB3();
+
+    shade_bundle_bounds(bounds, bundle);
+
+    camera_frame_sphere(controller, Math.hypot(bounds.width, bounds.height, bounds.depth) * 0.5, new Vector3(bounds.centerX, bounds.centerY, bounds.centerZ));
+
+    // inside, low, looking down the long axis: where the light bounces
+    controller.look(
+        new Vector3(bounds.centerX - bounds.width * 0.3, bounds.centerY - bounds.height * 0.2, bounds.centerZ),
+        new Vector3(bounds.centerX + bounds.width * 0.3, bounds.centerY - bounds.height * 0.25, bounds.centerZ)
+    );
+    controller.movement_speed_scale = Math.max(bounds.width, bounds.height, bounds.depth) * 0.05;
+
+    // a sun the sliders turn, whatever lights the file brought
+    const sun = make_sunlight({ intensity: 7.2 });
+
+    place_light(scene, sun);
+
+    const rotation = new Quaternion();
+    const sun_direction = new Vector3();
+
+    /**
+     * The traced reference no longer matches the lights. The tracer restarts on its own when the camera
+     * moves, but not when a light does; while it is off, the restart waits for it to come back on, so that
+     * flipping it on a still camera and still lights keeps what it has accumulated.
+     */
+    let trace_stale = false;
+
+    function lights_changed() {
+        if (renderer.feature_path_tracing_enabled) {
+            renderer.path_tracer.clear_history = true;
+        } else {
+            trace_stale = true;
+        }
+    }
+
+    function aim_sun() {
+        const elevation = Number(element('sun_elevation').value) * DEG_TO_RAD;
+        const azimuth = Number(element('sun_azimuth').value) * DEG_TO_RAD;
+
+        element('sun_elevation_value').textContent = `${element('sun_elevation').value}°`;
+        element('sun_azimuth_value').textContent = `${element('sun_azimuth').value}°`;
+
+        // the light travels down toward the scene
+        sun_direction.set(Math.cos(elevation) * Math.cos(azimuth), -Math.sin(elevation), Math.cos(elevation) * Math.sin(azimuth));
+
+        rotation.fromUnitVectors(Vector3.forward, sun_direction);
+        rotation.normalize();
+
+        sun.transform.setRotation(rotation.x, rotation.y, rotation.z, rotation.w);
+        sun.transform.updateMatrix();
+    }
+
+    aim_sun();
+
+    function on_sun_input() {
+        aim_sun();
+        lights_changed();
+    }
+
+    element('sun_elevation').addEventListener('input', on_sun_input);
+    element('sun_azimuth').addEventListener('input', on_sun_input);
+
+    load_default_environment(scene);
+
+    // ---- controls -------------------------------------------------------------------------
+
+    element('indirect').addEventListener('change', event => {
+        renderer.indirect_lighting_mode = ShadeIndirectLightingMode[event.target.value];
+    });
+
+    element('debug_view').addEventListener('change', event => {
+        renderer.probe_clipmap.debug_view = ProbeClipmapDebugView[event.target.value];
+    });
+
+    const taa_toggle = element('taa');
+    const path_tracing_toggle = element('path_tracing');
+
+    taa_toggle.addEventListener('change', event => {
+        renderer.feature_taa_enabled = event.target.checked;
+    });
+
+    /**
+     * What TAA was before the tracer turned it off, to give it back when the tracer goes.
+     * @type {boolean}
+     */
+    let taa_before_tracing = taa_toggle.checked;
+
+    function set_path_tracing(enabled) {
+        if (enabled === renderer.feature_path_tracing_enabled) {
+            return;
+        }
+
+        path_tracing_toggle.checked = enabled;
+        renderer.feature_path_tracing_enabled = enabled;
+
+        // two temporal filters over one image fight; the tracer accumulates on its own
+        if (enabled) {
+            taa_before_tracing = taa_toggle.checked;
+            taa_toggle.checked = false;
+
+            if (trace_stale) {
+                renderer.path_tracer.clear_history = true;
+                trace_stale = false;
+            }
+        } else {
+            taa_toggle.checked = taa_before_tracing;
+        }
+
+        taa_toggle.disabled = enabled;
+        renderer.feature_taa_enabled = taa_toggle.checked;
+    }
+
+    path_tracing_toggle.addEventListener('change', event => set_path_tracing(event.target.checked));
+
+    document.addEventListener('keydown', event => {
+        // not while typing a number, nor in a select, where P picks an option
+        const typing = event.target === bake_budget || event.target instanceof HTMLSelectElement;
+
+        if (event.code === 'KeyP' && event.repeat === false && typing === false) {
+            set_path_tracing(!renderer.feature_path_tracing_enabled);
+        }
+    });
+
+    const bake_budget = element('bake_budget');
+
+    bake_budget.value = String(PAGE_BAKE_BUDGET);
+    bake_budget.addEventListener('change', () => {
+        const value = Math.round(Number(bake_budget.value));
+
+        if (Number.isInteger(value) && value >= 1 && value <= 8191) {
+            renderer.probe_clipmap.mesh_sdf_bake_budget = value;
+        }
+    });
+
+    /** @type {{light: PointLight, entity: number}[]} */
+    const point_lights = [];
+
+    element('point_lights').addEventListener('change', event => {
+        if (event.target.checked) {
+            for (let i = 0; i < POINT_LIGHT_COUNT; i++) {
+                const light = new PointLight();
+
+                light.intensity = 2;
+                light.distance = 0.25 * bounds.width;
+                light.radius = 0.05;
+                light.casts_shadow = true;
+                light.transform.setTranslation(bounds.x0 + (i + 0.5) / POINT_LIGHT_COUNT * bounds.width, bounds.y0 + 0.15 * bounds.height, bounds.centerZ);
+                light.transform.updateMatrix();
+
+                point_lights.push({ light, entity: place_light(scene, light) });
+            }
+        } else {
+            for (const { light, entity } of point_lights) {
+                scene.lights.remove(light);
+                scene.dataset.removeEntity(entity);
+            }
+
+            point_lights.length = 0;
+        }
+
+        lights_changed();
+    });
+
+    document.body.focus();
+
+    set_status(`loaded — ${placed.drawn} instances`, 'pass');
+
+    // ---- frame loop -----------------------------------------------------------------------
+
+    const frame_timer = new FrameTimer();
+    const sdf = scene_context.geometries.sdf;
+
+    create_frame_loop((time_delta_s, raf_time_s) => {
+        const width = window.innerWidth;
+        const height = window.innerHeight;
+
+        renderer.resize(width, height);
+        renderer.pixel_ratio = window.devicePixelRatio;
+        camera.aspect = width / height;
+
+        controller.update();
+
+        renderer.render(camera, scene, time_delta_s);
+
+        frame_timer.add(raf_time_s);
+
+        const mean = frame_timer.mean_ms;
+        const baking = sdf.baking_count + sdf.queued_count;
+
+        stats_element.textContent =
+            `${mean.toFixed(1)} ms  ·  ${mean > 0 ? (1000 / mean).toFixed(0) : '0'} fps\n`
+            + `mesh SDFs: ${sdf.resident_count} resident${baking > 0 ? `, ${baking} baking` : ''}`
+            + `${renderer.feature_path_tracing_enabled ? `\npath traced: ${renderer.path_tracer.min_sample_count} samples` : ''}`;
+    }, 60);
+}

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

@@ -144,7 +144,9 @@ export class Renderer {
     /**
      * While TAA is off nothing writes the history textures, but the frame counter that
      * indexes them keeps advancing — re-enabling would blend with arbitrarily stale
-     * history of arbitrary parity. Reset temporal history on the transition.
+     * history of arbitrary parity. Reset temporal history on the transition — but not the path
+     * tracer's accumulation, which TAA does not feed: a page flipping between the traced reference
+     * and the rasterized image turns TAA off and back on each time, and would lose the reference.
      * @param {boolean} v
      */
     set feature_taa_enabled(v: boolean);

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

@@ -46,6 +46,10 @@ import {
 } from "./global_illumination/brick4/gpu/draw/shader_brick4_indirect_lighting.js";
 import { shader_brick4_specular } from "./global_illumination/brick4/gpu/draw/shader_brick4_specular.js";
 import { shader_diffuse_IBL } from "./global_illumination/ibl/shader_diffuse_IBL.js";
+import { shader_probe_clipmap_diffuse } from "./global_illumination/probe_clipmap/probe/shader_probe_clipmap_diffuse.js";
+import {
+    shader_probe_clipmap_indirect_lighting
+} from "./global_illumination/probe_clipmap/probe/shader_probe_clipmap_indirect_lighting.js";
 import { shader_specular_IBL } from "./global_illumination/ibl/shader_specular_IBL.js";
 import { GPULightProbeVolumeRenderer } from "./global_illumination/lpv/bake/GPULightProbeVolumeRenderer.js";
 import { shader_diffuse_LPV } from "./global_illumination/lpv/shader_diffuse_LPV.js";
@@ -526,7 +530,9 @@ export class Renderer {
     /**
      * While TAA is off nothing writes the history textures, but the frame counter that
      * indexes them keeps advancing — re-enabling would blend with arbitrarily stale
-     * history of arbitrary parity. Reset temporal history on the transition.
+     * history of arbitrary parity. Reset temporal history on the transition — but not the path
+     * tracer's accumulation, which TAA does not feed: a page flipping between the traced reference
+     * and the rasterized image turns TAA off and back on each time, and would lose the reference.
      * @param {boolean} v
      */
     set feature_taa_enabled(v) {
@@ -535,7 +541,7 @@ export class Renderer {
         }
 
         this.#feature_taa_enabled = v;
-        this.indicate_view_change();
+        this.#reset_temporal_filters();
     }
 
     /**
@@ -1098,12 +1104,19 @@ export class Renderer {
      * Primarily instructs resetting history on temporal accumulation
      */
     indicate_view_change() {
-        this.#postprocess.reset_history();
-
         if (this.#path_tracer !== undefined) {
             this.#path_tracer.clear_history = true;
         }
 
+        this.#reset_temporal_filters();
+    }
+
+    /**
+     * Discard the history every temporal filter blends with.
+     */
+    #reset_temporal_filters() {
+        this.#postprocess.reset_history();
+
         this.#taa.reset_history = true;
 
         if (this.#nss !== undefined) {
@@ -1221,7 +1234,6 @@ export class Renderer {
         // SSR overrides specular below using the same explicitly selected mode.
         switch (mode) {
             case ShadeIndirectLightingMode.IBL:
-            // lit as IBL until its probes are traced (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §13, S4)
             case ShadeIndirectLightingMode.ProbeClipmap:
                 diffuse_pass = {
                     shader: shader_diffuse_IBL,
@@ -1231,6 +1243,7 @@ export class Renderer {
                         tEnvironment: gr_texture_environment,
                     },
                 };
+                // the probe clipmap's too until it has probes (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §9.6)
                 specular_pass = {
                     shader: shader_specular_IBL,
                     inputs: {
@@ -1242,6 +1255,48 @@ export class Renderer {
                         camera: gr_buffer_camera_current,
                     },
                 };
+
+                // its light is the probes' once the mode has run this frame (§9.6); a pixel no probe
+                // weighs anything for takes IBL's inside the passes
+                if (mode === ShadeIndirectLightingMode.ProbeClipmap && this.#probe_clipmap_gi.has_probes) {
+                    // SSR off: both lobes in one pass, from one pick
+                    if (prefer_fused && !this.feature_ssr_enabled) {
+                        [current_color_out] = graph_image_pass({
+                            graph,
+                            shader: shader_probe_clipmap_indirect_lighting,
+                            output: [current_color_out],
+                            input_depth: gr_texture_depth_current,
+                            load_op: "load",
+                            inputs: this.#probe_clipmap_gi.write_sampling_bindings({
+                                tDepth: gr_texture_depth_current,
+                                tNormals: gr_texture_normal,
+                                tBentNormals: bent_normals,
+                                tGBufferAlbedo: gr_texture_material_albedo_ao,
+                                tGBufferPBR: gr_texture_pbr,
+                                tSTBN_vec2: STATIC_GRAPHICS_ENGINE_ASSETS.stbn_vec2,
+                                view: view_ctx.uniform_buffer.buffer,
+                                camera: gr_buffer_camera_current,
+                                tEnvironment: gr_texture_environment,
+                                tSplitSum: STATIC_GRAPHICS_ENGINE_ASSETS.split_sum,
+                            }),
+                        });
+                        return current_color_out;
+                    }
+
+                    diffuse_pass = {
+                        shader: shader_probe_clipmap_diffuse,
+                        inputs: this.#probe_clipmap_gi.write_sampling_bindings({
+                            tDepth: gr_texture_depth_current,
+                            tNormals: gr_texture_normal,
+                            tBentNormals: bent_normals,
+                            tGBufferAlbedo: gr_texture_material_albedo_ao,
+                            tSTBN_vec2: STATIC_GRAPHICS_ENGINE_ASSETS.stbn_vec2,
+                            view: view_ctx.uniform_buffer.buffer,
+                            camera: gr_buffer_camera_current,
+                            tEnvironment: gr_texture_environment,
+                        }),
+                    };
+                }
                 break;
 
             case ShadeIndirectLightingMode.Brick4:
@@ -1331,6 +1386,14 @@ export class Renderer {
                 throw new Error(`Unsupported indirect lighting mode: ${mode}`);
         }
 
+        // before SSR, whose resolve under the probe clipmap reflects the diffuse at the hit's texel
+        const [indirect_diffuse] = graph_image_pass({
+            graph,
+            ...diffuse_pass,
+            input_depth: gr_texture_depth_current,
+            output_resolution: view_ctx.resolution,
+        });
+
         let indirect_specular;
         if (this.feature_ssr_enabled) {
             const ssr = this.#postprocess.ssr.graph_pass({
@@ -1351,6 +1414,9 @@ export class Renderer {
                 input_environment: gr_texture_environment,
                 brick4: ssr_brick4,
                 lpv: ssr_lpv,
+                input_indirect_diffuse: mode === ShadeIndirectLightingMode.ProbeClipmap ? 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,
                 resolution,
             });
@@ -1365,13 +1431,6 @@ export class Renderer {
             });
         }
 
-        const [indirect_diffuse] = graph_image_pass({
-            graph,
-            ...diffuse_pass,
-            input_depth: gr_texture_depth_current,
-            output_resolution: view_ctx.resolution,
-        });
-
         // resolve indirect lighting
         [current_color_out] = graph_image_pass({
             graph,
@@ -1730,6 +1789,12 @@ export class Renderer {
 
         this.#update_output_resolution();
 
+        // The depth ping-pong and the visibility target are created at the internal resolution
+        // below, so it has to be real by then rather than the 1x1 it is declared at: a 1x1 texture
+        // cannot carry G_BUFFER_MIP_LEVELS mips. Only the texture drawn into is resized per frame,
+        // so frame 0's previous depth is used at the size it was created at.
+        this.#update_internal_resolution();
+
         this.#graphics = new GraphicsContext(device);
 
         const graphics = this.#graphics;
@@ -2104,12 +2169,6 @@ export class Renderer {
     }
 
     #apply_size() {
-        const out_w = this.#output_resolution.x;
-        const out_h = this.#output_resolution.y;
-
-        this.#textures_taa_history.forEach(t => t.resize(out_w, out_h));
-
-
         this.#context_needs_update = true;
     }
 
@@ -2155,20 +2214,10 @@ export class Renderer {
             this.#nss.jitter_sequence_size = Math.ceil(nss_base * taa_sequence_scale);
         }
 
-        const in_w = this.#internal_resolution.x;
-        const in_h = this.#internal_resolution.y;
-
-        this.#textures_depth.forEach(t => {
-            t.resize(in_w, in_h)
-        });
-
-        this.#vis_render_target.resize(in_w, in_h);
-
-        // resizing destroys BOTH ping-pong depth textures, including the one holding last
-        // frame's depth — disocclusion/SSAO would read a zeroed "previous depth" this frame
-        // and silently corrupt temporal history. The external resize() path resets history
-        // via indicate_view_change(); internal-resolution changes (DRS steps) must too.
-        this.indicate_view_change();
+        // Nothing is resized here. The visibility target and this frame's depth are sized in
+        // #begin_frame, once the depth ping-pong has cycled, so last frame's depth keeps the size it
+        // was drawn at and stays readable as previous depth. Not a view change either: each temporal
+        // history sees the size change and handles it itself.
 
         this.#internal_resolution_needs_update = false;
     }
@@ -2222,9 +2271,6 @@ export class Renderer {
         }
 
         this.#apply_size();
-
-        // drop history buffers to prevent artifacts
-        this.indicate_view_change();
     }
 
     /**
@@ -2264,8 +2310,10 @@ export class Renderer {
             this.#graphics.virtual_textures.update();
         }
 
-        // cycle depth attachment
+        // cycle depth attachment, then size the target this frame draws into. Previous depth is not
+        // attached, so it keeps the size it was drawn at.
         this.#vis_render_target.depth_attachment = this.texture_depth_current;
+        this.#vis_render_target.resize(this.#internal_resolution.x, this.#internal_resolution.y);
         this.#postprocess.update(this.#frame_count);
 
         // Advance whichever upscaler we're going to ask for jitter on this
@@ -2735,6 +2783,10 @@ export class Renderer {
         const taa_history_0 = this.#get_texture_taa_history(0);
         const taa_history_1 = this.#get_texture_taa_history(-1);
 
+        // Only the texture resolved into follows the output. The history keeps the size it was
+        // resolved at across a resize and is read by uv; it is resized in turn when it is written.
+        taa_history_1.resize(this.#output_resolution.x, this.#output_resolution.y);
+
         const gr_texture_taa_history = graph_import_texture(graph, taa_history_0, "taa history");
         const gr_texture_taa_out = graph_import_texture(graph, taa_history_1, "taa out");
         let gr_texture_depth_previous = graph_import_texture(graph, this.texture_depth_previous, "depth previous");
@@ -2890,6 +2942,7 @@ export class Renderer {
                 // a cache of the lighting, not the simulation: its response runs on the wall clock
                 time: performance.now() / 1000,
                 movers: gr_scene_movers,
+                shadowmap_atlas: gr_shadowmap_atlas,
             });
         } else {
             this.#probe_clipmap_gi.release();
@@ -2906,6 +2959,8 @@ export class Renderer {
             // the running mode's GI source, for froxel GI; it is given no other mode's
             brick4: this.indirect_lighting_mode === ShadeIndirectLightingMode.Brick4 ? view_ctx.scene.volumetric_light_map : undefined,
             lpv: this.indirect_lighting_mode === ShadeIndirectLightingMode.LPV ? view_ctx.scene.light_probe_volume : undefined,
+            // in every mode: a clipmap of no cascade while it has no probes
+            probes: this.#probe_clipmap_gi,
         });
 
         /**
@@ -2978,8 +3033,6 @@ export class Renderer {
                 graph: graph,
                 frame_index: this.#frame_count,
                 input_depth: gr_texture_depth_current,
-                input_color: current_color_out,
-                input_depth_previous: gr_texture_depth_previous,
                 input_velocity: gr_velocity,
                 input_normal: gr_texture_normal,
                 input_occlusion: gr_occlusion_clip,
@@ -3163,6 +3216,8 @@ export class Renderer {
                 volumetrics_irradiance: volumetrics.irradiance,
 
                 shader_switches: this.#shader_switches,
+                // in every mode: a clipmap of no cascade while it has no probes
+                probes: this.#probe_clipmap_gi,
                 avboit: this.avboit,
                 side_channels,
             });
@@ -3243,6 +3298,7 @@ export class Renderer {
                     texture_color_history: gr_texture_taa_history,
                     texture_velocity: gr_velocity,
                     texture_occlusion: gr_occlusion_clip,
+                    output_resolution: this.#output_resolution.asArray(),
                 });
             }
         }

package/src/shade/renderer/extension/ViewTextures.d.ts

@@ -19,7 +19,8 @@ export class ViewTextures extends FrameRecord {
     get depth(): number;
     set depth_previous(handle: number);
     /**
-     * Last frame's depth, which reprojection-shaped effects need.
+     * Last frame's depth, which reprojection-shaped effects need. At the size last frame was drawn
+     * at, which after a resolution change is not {@link depth}'s: address it in its own grid.
      *
      * @returns {number}
      */

package/src/shade/renderer/extension/ViewTextures.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ViewTextures.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/extension/ViewTextures.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;GAWG;AACH;IAMI,0CAKC;IASD,0BAEC;IATD;;OAEG;IACH,oBAEC;IAeD,mCAEC;IAXD;;;;OAIG;IACH,6BAEC;IAeD,oCAEC;IAXD;;;;OAIG;IACH,8BAEC;IAeD,wCAEC;IAXD;;;;OAIG;IACH,kCAEC;;CAKJ;4BA5E2B,kBAAkB"}
+{"version":3,"file":"ViewTextures.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/extension/ViewTextures.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;GAWG;AACH;IAMI,0CAKC;IASD,0BAEC;IATD;;OAEG;IACH,oBAEC;IAgBD,mCAEC;IAZD;;;;;OAKG;IACH,6BAEC;IAeD,oCAEC;IAXD;;;;OAIG;IACH,8BAEC;IAeD,wCAEC;IAXD;;;;OAIG;IACH,kCAEC;;CAKJ;4BA7E2B,kBAAkB"}