@woosh/meep-engine 3.57.0 → 3.59.0

package/src/shade/renderer/Renderer.js

@@ -46,9 +46,16 @@ 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";
+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 { shader_resolve_indirect_lighting } from "./global_illumination/shader_resolve_indirect_lighting.js";
 import { GraphicsContext } from "./GraphicsContext.js";
 import {
@@ -108,6 +115,9 @@ import { ShadowDirectionalTechnique } from "./shadow/map/ShadowDirectionalTechni
 import { SHADOWMAP_CSM_DEFAULT_CASCADE_COUNT } from "./shadow/map/csm/SHADOWMAP_CSM_DEFAULT_CASCADE_COUNT.js";
 import { DEFAULT_VSM_FIRST_TEXEL_SIZE } from "./shadow/vsm/DEFAULT_VSM_FIRST_TEXEL_SIZE.js";
 import { DEFAULT_VSM_PAGE_BUDGET } from "./shadow/vsm/DEFAULT_VSM_PAGE_BUDGET.js";
+import { DEFAULT_VSM_LOW_LOAD_FACTOR } from "./shadow/vsm/DEFAULT_VSM_LOW_LOAD_FACTOR.js";
+import { DEFAULT_VSM_MAX_DYNAMIC_LOD_BIAS } from "./shadow/vsm/DEFAULT_VSM_MAX_DYNAMIC_LOD_BIAS.js";
+import { DEFAULT_VSM_MAX_LOAD_FACTOR } from "./shadow/vsm/DEFAULT_VSM_MAX_LOAD_FACTOR.js";
 import { CascadedSceneSDF } from "./shadow/sdf/cascade/CascadedSceneSDF.js";
 import { STATIC_GRAPHICS_ENGINE_ASSETS } from "./STATIC_GRAPHICS_ENGINE_ASSETS.js";
 import { GPUTextureContext } from "./texture/GPUTextureContext.js";
@@ -217,6 +227,23 @@ export class Renderer {
      */
     indirect_lighting_mode = ShadeIndirectLightingMode.IBL;
 
+    /**
+     * Settings of {@link ShadeIndirectLightingMode.ProbeClipmap}, read every frame it runs. A change to
+     * one of its structural fields builds the mode's clipmaps again; see {@link ProbeClipmapSettings}.
+     * @type {ProbeClipmapSettings}
+     */
+    probe_clipmap = new ProbeClipmapSettings();
+
+    /**
+     * The main view's {@link ShadeIndirectLightingMode.ProbeClipmap}: allocated on the first frame
+     * rendered in the mode, and given back on the first frame out of it. One, like {@link #volumetrics},
+     * since {@link render} draws one main view.
+     *
+     * Constructed in {@link initialize}.
+     * @type {GPUProbeClipmapGI | undefined}
+     */
+    #probe_clipmap_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
@@ -379,6 +406,67 @@ export class Renderer {
      */
     shadow_virtual_lod_bias = 0;
 
+    /**
+     * High-watermark pool demand ratio `(wants + requests_dropped) / slots.capacity` above which a
+     * virtual shadow map dynamically steps its LOD bias up to prevent pool overflow (`0` disables
+     * dynamic throttling). Pushed each frame; see
+     * {@link GPUSceneShadowmapContext.virtual_max_load_factor} and {@link DEFAULT_VSM_MAX_LOAD_FACTOR}.
+     * @type {number}
+     */
+    #shadow_virtual_max_load_factor = DEFAULT_VSM_MAX_LOAD_FACTOR;
+
+    set shadow_virtual_max_load_factor(v) {
+        assert.isNumber(v, 'shadow_virtual_max_load_factor');
+        assert.greaterThanOrEqual(v, 0, 'shadow_virtual_max_load_factor');
+        assert.lessThanOrEqual(v, 1, 'shadow_virtual_max_load_factor');
+
+        this.#shadow_virtual_max_load_factor = v;
+    }
+
+    get shadow_virtual_max_load_factor() {
+        return this.#shadow_virtual_max_load_factor;
+    }
+
+    /**
+     * Low-watermark pool demand ratio below which a virtual shadow map's dynamic LOD bias steps
+     * back down toward zero. Pushed each frame; see
+     * {@link GPUSceneShadowmapContext.virtual_low_load_factor} and {@link DEFAULT_VSM_LOW_LOAD_FACTOR}.
+     * @type {number}
+     */
+    #shadow_virtual_low_load_factor = DEFAULT_VSM_LOW_LOAD_FACTOR;
+
+    set shadow_virtual_low_load_factor(v) {
+        assert.isNumber(v, 'shadow_virtual_low_load_factor');
+        assert.greaterThanOrEqual(v, 0, 'shadow_virtual_low_load_factor');
+        assert.lessThanOrEqual(v, 1, 'shadow_virtual_low_load_factor');
+
+        this.#shadow_virtual_low_load_factor = v;
+    }
+
+    get shadow_virtual_low_load_factor() {
+        return this.#shadow_virtual_low_load_factor;
+    }
+
+    /**
+     * Maximum dynamic LOD bias a virtual shadow map may add under pool pressure (`0` disables
+     * dynamic throttling). Pushed each frame; see
+     * {@link GPUSceneShadowmapContext.virtual_max_dynamic_lod_bias} and
+     * {@link DEFAULT_VSM_MAX_DYNAMIC_LOD_BIAS}.
+     * @type {number}
+     */
+    #shadow_virtual_max_dynamic_lod_bias = DEFAULT_VSM_MAX_DYNAMIC_LOD_BIAS;
+
+    set shadow_virtual_max_dynamic_lod_bias(v) {
+        assert.isNumber(v, 'shadow_virtual_max_dynamic_lod_bias');
+        assert.greaterThanOrEqual(v, 0, 'shadow_virtual_max_dynamic_lod_bias');
+
+        this.#shadow_virtual_max_dynamic_lod_bias = v;
+    }
+
+    get shadow_virtual_max_dynamic_lod_bias() {
+        return this.#shadow_virtual_max_dynamic_lod_bias;
+    }
+
     /**
      * World size of a virtual shadow map's finest texel, in metres. Pushed each frame; a change
      * rebuilds the maps. See {@link DEFAULT_VSM_FIRST_TEXEL_SIZE}.
@@ -442,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) {
@@ -451,7 +541,7 @@ export class Renderer {
         }
 
         this.#feature_taa_enabled = v;
-        this.indicate_view_change();
+        this.#reset_temporal_filters();
     }
 
     /**
@@ -1014,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) {
@@ -1137,6 +1234,7 @@ export class Renderer {
         // SSR overrides specular below using the same explicitly selected mode.
         switch (mode) {
             case ShadeIndirectLightingMode.IBL:
+            case ShadeIndirectLightingMode.ProbeClipmap:
                 diffuse_pass = {
                     shader: shader_diffuse_IBL,
                     inputs: {
@@ -1145,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: {
@@ -1156,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:
@@ -1245,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({
@@ -1265,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,
             });
@@ -1279,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,
@@ -1644,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;
@@ -1656,6 +1807,7 @@ export class Renderer {
         this.#cameras = new CameraManager(this.device);
         this.#views = new ViewManager(graphics, this.#cameras, this.#scenes);
         this.#volumetrics = new GPUViewVolumetrics(this.device);
+        this.#probe_clipmap_gi = new GPUProbeClipmapGI(graphics);
 
         const resolution_internal = this.#internal_resolution.asArray();
 
@@ -1890,6 +2042,7 @@ export class Renderer {
         this.#restir_di?.destroy();
         this.#nss?.destroy();
         this.#volumetrics?.destroy();
+        this.#probe_clipmap_gi?.destroy();
 
         this.#views?.destroy();
         this.#scenes?.destroy();
@@ -2016,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;
     }
 
@@ -2067,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;
     }
@@ -2134,9 +2271,6 @@ export class Renderer {
         }
 
         this.#apply_size();
-
-        // drop history buffers to prevent artifacts
-        this.indicate_view_change();
     }
 
     /**
@@ -2176,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
@@ -2430,6 +2566,9 @@ export class Renderer {
         this.#update_shader_switches();
         sm.virtual_page_budget = this.#shadow_virtual_page_budget;
         sm.virtual_lod_bias = this.shadow_virtual_lod_bias;
+        sm.virtual_max_load_factor = this.#shadow_virtual_max_load_factor;
+        sm.virtual_low_load_factor = this.#shadow_virtual_low_load_factor;
+        sm.virtual_max_dynamic_lod_bias = this.#shadow_virtual_max_dynamic_lod_bias;
         sm.virtual_first_texel_size = this.#shadow_virtual_first_texel_size;
 
         const taa = this.#taa;
@@ -2587,14 +2726,20 @@ export class Renderer {
             });
         }
 
-        // Virtual shadow map feedback: the casters that moved, the pages they left stale, and the
-        // pages this view's depth asks for, read back for the maps' next frames. No-op unless a
-        // directional light has a virtual map.
+        // The scene's mover list for this frame, once for every reader: the rows that moved, changed
+        // what they draw, or changed pose since the list was last made. A frame nothing reads it in
+        // culls it.
+        const gr_scene_movers = view_ctx.scene.graph_movers(graph);
+
+        // Virtual shadow map feedback: the pages the movers left stale, and the pages this view's
+        // depth asks for, read back for the maps' next frames. No-op unless a directional light has a
+        // virtual map.
         if (this.#feature_shadows_enabled) {
             sm.graph_virtual_feedback({
                 graph,
                 view: view_ctx,
                 depth: gr_raster_depth,
+                movers: gr_scene_movers,
             });
         }
 
@@ -2638,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");
@@ -2779,6 +2928,26 @@ export class Renderer {
         // below is skipped on the same fact.
         const has_volumetrics = view_ctx.scene.volumetrics.source.volumes.length > 0;
 
+        // The probe clipmap GI runs after the G-buffer and the shadow maps and before the volumetrics
+        // that sample it (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §5). 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) {
+            this.#probe_clipmap_gi.graph_update({
+                graph,
+                view: view_ctx,
+                settings: this.probe_clipmap,
+                depth: gr_texture_depth_current,
+                normal: gr_texture_normal,
+                stbn: STATIC_GRAPHICS_ENGINE_ASSETS.stbn_vec2,
+                // 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();
+        }
+
         const volumetrics = this.#volumetrics.graph_update({
             graph,
             view: view_ctx,
@@ -2790,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,
         });
 
         /**
@@ -2862,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,
@@ -3047,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,
             });
@@ -3092,6 +3263,19 @@ export class Renderer {
             });
         }
 
+        // the probe clipmap mode's debug views replace the colour the same way
+        if (
+            this.indirect_lighting_mode === ShadeIndirectLightingMode.ProbeClipmap
+            && this.probe_clipmap.debug_view !== ProbeClipmapDebugView.None
+        ) {
+            current_color_out = this.#probe_clipmap_gi.graph_debug_view({
+                graph,
+                view: view_ctx,
+                settings: this.probe_clipmap,
+                resolution: resolution_internal.asArray(),
+            });
+        }
+
         if (this.feature_taa_enabled) {
 
             if (this.upscale_type === ShadeUpscalerType.NSS) {
@@ -3114,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/ShadeIndirectLightingMode.d.ts

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

package/src/shade/renderer/ShadeIndirectLightingMode.js

@@ -11,4 +11,10 @@ export const ShadeIndirectLightingMode = {
     Brick4: 1,
     /** Light Probe Volume (LPV) */
     LPV: 2,
+    /**
+     * Probes on a 3-D clipmap around the camera, traced against a clipmap of SDF bricks
+     * (`global_illumination/probe_clipmap/PROBE_CLIPMAP_PROPOSAL_2026_10_27.md`). Settings are
+     * `Renderer.probe_clipmap`. Lit as {@link IBL} until its probes are traced (that proposal's §13, S4).
+     */
+    ProbeClipmap: 3,
 };

package/src/shade/renderer/camera/orbital/README.md

@@ -1,6 +1,6 @@
 # Orbital camera (momentum)
 
-A drop-in replacement for the legacy [`../OrbitalCameraController.js`](../OrbitalCameraController.js)
+A drop-in replacement for the legacy orbital camera controller
 that makes orbit/pan **responsive while dragging** and **weighty on release** —
 the "throw" feel of Google Earth / Maps, not a spring.
 
@@ -49,13 +49,10 @@ the input adapter is tested by firing synthetic signals at injected fake devices
 independent coast, hold-still-no-throw, pole clamp, precision (no-momentum) mode,
 event→intent mapping.
 
-## Switching
+## Import
 
 ```js
-// before
-import { OrbitalCameraController } from "../../webgpu/renderer/camera/OrbitalCameraController.js";
-// after
-import { OrbitalCameraController } from "../../webgpu/renderer/camera/orbital/index.js";
+import { OrbitalCameraController } from "@woosh/meep-engine/src/shade/renderer/camera/orbital/index.js";
 ```
 
 Constructor `(camera, domElement)` and `look` / `from_transform` / `pan` /

package/src/shade/renderer/deferred/chunk_shade_standard_material_direct_restir.d.ts

@@ -1,5 +1,5 @@
 /**
- * ReSTIR DI variant of {@link chunk_shade_standard_material_direct_heavy}: same
+ * ReSTIR DI variant of {@link chunk_shade_standard_material_direct}: same
  * function name/signature so the deferred shader entry is identical, but the
  * brute-force point/spot froxel-cluster loop is replaced by a single lookup into
  * the ReSTIR-resolved radiance texture (`tRestirRadiance`, already

package/src/shade/renderer/deferred/chunk_shade_standard_material_direct_restir.js

@@ -7,7 +7,7 @@ import { chunk_shade_directional_lights } from "./chunk_shade_directional_lights
 import { RESTIR_RADIANCE_RESOURCE } from "../restir/di/RESTIR_RADIANCE_RESOURCE.js";
 
 /**
- * ReSTIR DI variant of {@link chunk_shade_standard_material_direct_heavy}: same
+ * ReSTIR DI variant of {@link chunk_shade_standard_material_direct}: same
  * function name/signature so the deferred shader entry is identical, but the
  * brute-force point/spot froxel-cluster loop is replaced by a single lookup into
  * the ReSTIR-resolved radiance texture (`tRestirRadiance`, already

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"}

package/src/shade/renderer/extension/ViewTextures.js

@@ -38,7 +38,8 @@ export class ViewTextures extends FrameRecord {
     }
 
     /**
-     * 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}
      */