@woosh/meep-engine 3.57.0 → 3.58.0

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

@@ -15,7 +15,7 @@ import { AnimationClips } from "../../../engine/graphics3/animation/AnimationCli
 import { prefab_compile } from "../../../engine/graphics3/prefab/prefab_compile.js";
 import { AnimationClipFlags } from "../../renderer/animation/AnimationClipFlags.js";
 import { camera_frame_sphere } from "../../renderer/camera/camera_frame_sphere.js";
-import { OrbitalCameraController } from "../../renderer/camera/OrbitalCameraController.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 { make_sunlight } from "../../renderer/light/make_sunlight.js";

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

@@ -3,7 +3,7 @@ import { DEG_TO_RAD } from "../../../core/math/DEG_TO_RAD.js";
 import { NumericInterval } from "../../../core/math/interval/NumericInterval.js";
 import { seededRandom } from "../../../core/math/random/seededRandom.js";
 import { camera_frame_sphere } from "../../renderer/camera/camera_frame_sphere.js";
-import { OrbitalCameraController } from "../../renderer/camera/OrbitalCameraController.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 { BoxGeometry } from "../../renderer/geometry/BoxGeometry.js";

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

@@ -1,6 +1,6 @@
 import Vector3 from "../../../core/geom/Vector3.js";
 import { PerspectiveCamera } from "../../renderer/camera/PerspectiveCamera.js";
-import { OrbitalCameraController } from "../../renderer/camera/OrbitalCameraController.js";
+import { OrbitalCameraController } from "../../renderer/camera/orbital/OrbitalCameraController.js";
 import { Renderer } from "../../renderer/Renderer.js";
 import { ShadeIndirectLightingMode } from "../../renderer/ShadeIndirectLightingMode.js";
 import { FixedProjection } from "../ssr_variance/capture.js";

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

@@ -1,7 +1,7 @@
 import { SpatialFilterProbe } from "./SpatialFilterProbe.js";
 import Vector3 from "../../../core/geom/Vector3.js";
 import { PerspectiveCamera } from "../../renderer/camera/PerspectiveCamera.js";
-import { OrbitalCameraController } from "../../renderer/camera/OrbitalCameraController.js";
+import { OrbitalCameraController } from "../../renderer/camera/orbital/OrbitalCameraController.js";
 import { create_frame_loop } from "../../renderer/create_frame_loop.js";
 import { Renderer } from "../../renderer/Renderer.js";
 import { ShadeIndirectLightingMode } from "../../renderer/ShadeIndirectLightingMode.js";

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

@@ -1,5 +1,5 @@
 import Vector3 from "../../../core/geom/Vector3.js";
-import { OrbitalCameraController } from "../../renderer/camera/OrbitalCameraController.js";
+import { OrbitalCameraController } from "../../renderer/camera/orbital/OrbitalCameraController.js";
 import { PerspectiveCamera } from "../../renderer/camera/PerspectiveCamera.js";
 import { Renderer } from "../../renderer/Renderer.js";
 import { ShadeIndirectLightingMode } from "../../renderer/ShadeIndirectLightingMode.js";

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

@@ -2,7 +2,7 @@ import { Color } from "../../../core/color/Color.js";
 import Vector3 from "../../../core/geom/Vector3.js";
 import { EntityComponentDataset } from "../../../engine/ecs/EntityComponentDataset.js";
 import { Transform64 } from "../../../engine/ecs/transform/Transform64.js";
-import { OrbitalCameraController } from "../../renderer/camera/OrbitalCameraController.js";
+import { OrbitalCameraController } from "../../renderer/camera/orbital/OrbitalCameraController.js";
 import { PerspectiveCamera } from "../../renderer/camera/PerspectiveCamera.js";
 import { VGEO_CUT_STAT } from "../../renderer/geometry/virtual/runtime/layout/VGEO_CUT_STAT.js";
 import { VirtualGeometry } from "../../renderer/geometry/virtual/runtime/VirtualGeometry.js";

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

@@ -4,7 +4,7 @@ import Vector3 from "../../../core/geom/Vector3.js";
 import { GIGABYTE } from "../../../core/science/units/memory/GIGABYTE.js";
 import { EntityComponentDataset } from "../../../engine/ecs/EntityComponentDataset.js";
 import { Transform64 } from "../../../engine/ecs/transform/Transform64.js";
-import { OrbitalCameraController } from "../../renderer/camera/OrbitalCameraController.js";
+import { OrbitalCameraController } from "../../renderer/camera/orbital/OrbitalCameraController.js";
 import { PerspectiveCamera } from "../../renderer/camera/PerspectiveCamera.js";
 import {
     vgeo_byte_source_over_url

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

@@ -6,7 +6,7 @@ import { MIE_PARTICLES_STANDARD_PRECOMPUTED } from "../../../core/math/physics/m
 import { t64_set_rotation_axis_angle } from "../../../engine/ecs/transform/t64_set_rotation_axis_angle.js";
 import { GPUProfileLevel } from "../../device/timing/profile/GPUProfileLevel.js";
 import { GPUProfileSession } from "../../device/timing/profile/GPUProfileSession.js";
-import { OrbitalCameraController } from "../../renderer/camera/OrbitalCameraController.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 { make_sunlight } from "../../renderer/light/make_sunlight.js";

package/src/shade/playground/vsm/index.html

@@ -71,7 +71,10 @@
         <input id="budget" type="range" min="0" max="64" step="1" value="8">
     </label>
     <label><span>LOD bias (coarser →) <output id="bias-value">0.0</output></span>
-        <input id="bias" type="range" min="-2" max="3" step="0.5" value="0">
+        <input id="bias" type="range" min="-2" max="3" step="0.5" value="0">
+    </label>
+    <label><span>Max pool load (0 = off) <output id="max-load-value">0.85</output></span>
+        <input id="max-load" type="range" min="0" max="1" step="0.05" value="0.85">
     </label>
     <label><span>Finest texel</span>
         <select id="texel">

package/src/shade/playground/vsm/main.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/vsm/main.js"],"names":[],"mappings":"AAsCA,uCA8VC"}
+{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/vsm/main.js"],"names":[],"mappings":"AAsCA,uCAiWC"}

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

@@ -1,5 +1,5 @@
 import Vector3 from "../../../core/geom/Vector3.js";
-import { OrbitalCameraController } from "../../renderer/camera/OrbitalCameraController.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 { Renderer } from "../../renderer/Renderer.js";
@@ -140,7 +140,8 @@ export async function start() {
     function apply_settings() {
         renderer.feature_virtual_shadow_maps = element('technique').value === 'vsm';
         renderer.shadow_virtual_page_budget = element('pause').checked ? 0 : Number(element('budget').value);
-        renderer.shadow_virtual_lod_bias = Number(element('bias').value);
+        renderer.shadow_virtual_lod_bias = Number(element('bias').value);
+        renderer.shadow_virtual_max_load_factor = Number(element('max-load').value);
         renderer.shadow_virtual_first_texel_size = Number(element('texel').value);
         renderer.feature_taa_enabled = element('taa').checked;
 
@@ -148,11 +149,12 @@ export async function start() {
         overlay.inset = element('inset').checked;
 
         element('budget-value').textContent = element('budget').value;
-        element('bias-value').textContent = Number(element('bias').value).toFixed(1);
+        element('bias-value').textContent = Number(element('bias').value).toFixed(1);
+        element('max-load-value').textContent = Number(element('max-load').value).toFixed(2);
         element('crowd-value').textContent = element('crowd').value;
     }
 
-    for (const id of ['technique', 'budget', 'bias', 'texel', 'debug', 'inset', 'pause', 'taa']) {
+    for (const id of ['technique', 'budget', 'bias', 'max-load', 'texel', 'debug', 'inset', 'pause', 'taa']) {
         element(id).addEventListener('input', apply_settings);
     }
 
@@ -201,7 +203,8 @@ export async function start() {
 
             lines.push(
                 `movers in scene: ${world.mover_count}`,
-                `pages: ${slots.used} / ${slots.capacity} resident`,
+                `pages: ${slots.used} / ${slots.capacity} resident (demand ${(s.load * 100).toFixed(1)}%)`,
+                `lod bias: ${map.lod_bias.toFixed(2)} + ${s.dynamic_lod_bias.toFixed(2)} dyn = ${map.effective_lod_bias.toFixed(2)}`,
                 `this frame: ${s.renders} rendered, ${s.backlog} waiting`,
                 `reading: ${s.wants} wanted, ${s.uncovered} uncovered, ${s.requests_dropped} dropped`,
                 `movers: ${s.movers}${s.movers > 4096 ? ' (overflow: all stale)' : ''}`,

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

@@ -20,7 +20,7 @@ import { FluidEffectorsComponent } from "../../../engine/physics/fluid/ecs/Fluid
 import { FluidEffectorsSystem } from "../../../engine/physics/fluid/ecs/FluidEffectorsSystem.js";
 import { GPUFluidComponent } from "../../../engine/physics/fluid/ecs/GPUFluidComponent.js";
 import { GlobalFluidEffector } from "../../../engine/physics/fluid/effector/GlobalFluidEffector.js";
-import { OrbitalCameraController } from "../../renderer/camera/OrbitalCameraController.js";
+import { OrbitalCameraController } from "../../renderer/camera/orbital/OrbitalCameraController.js";
 import { create_frame_loop } from "../../renderer/create_frame_loop.js";
 import { DynamicMeshAVBOITChannel } from "../../renderer/dynamic/DynamicMeshAVBOITChannel.js";
 import { Scene } from "../../renderer/scene/Scene.js";

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

@@ -18,7 +18,7 @@ import { GlobalFluidEffector } from "../../../engine/physics/fluid/effector/Glob
 import { GPUProfileLevel } from "../../device/timing/profile/GPUProfileLevel.js";
 import { GPUProfileSession } from "../../device/timing/profile/GPUProfileSession.js";
 import { sgpt_read_capture } from "../../device/timing/profile/sgpt_read_capture.js";
-import { OrbitalCameraController } from "../../renderer/camera/OrbitalCameraController.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 { load_default_environment } from "../load_default_environment.js";

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

@@ -29,6 +29,12 @@ export class Renderer {
      * @type {ShadeIndirectLightingMode}
      */
     indirect_lighting_mode: ShadeIndirectLightingMode;
+    /**
+     * 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: ProbeClipmapSettings;
     /**
      * 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
@@ -103,6 +109,12 @@ export class Renderer {
      * @type {number}
      */
     shadow_virtual_lod_bias: number;
+    set shadow_virtual_max_load_factor(v: number);
+    get shadow_virtual_max_load_factor(): number;
+    set shadow_virtual_low_load_factor(v: number);
+    get shadow_virtual_low_load_factor(): number;
+    set shadow_virtual_max_dynamic_lod_bias(v: number);
+    get shadow_virtual_max_dynamic_lod_bias(): number;
     set shadow_virtual_first_texel_size(v: number);
     get shadow_virtual_first_texel_size(): number;
     feature_bloom_enabled: boolean;
@@ -542,6 +554,7 @@ export type GPUSceneContext = import("./scene/GPUSceneContext.js").GPUSceneConte
 export type Scene = import("./scene/Scene.js").Scene;
 import { SceneManager } from "./scene/SceneManager.js";
 import { ShadeIndirectLightingMode } from "./ShadeIndirectLightingMode.js";
+import { ProbeClipmapSettings } from "./global_illumination/probe_clipmap/ProbeClipmapSettings.js";
 import { ShadeTransparencyMode } from "./ShadeTransparencyMode.js";
 import { ShadeToneMappingMode } from "./ShadeToneMappingMode.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

@@ -49,6 +49,9 @@ import { shader_diffuse_IBL } from "./global_illumination/ibl/shader_diffuse_IBL
 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 +111,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 +223,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 +402,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}.
@@ -1137,6 +1221,8 @@ 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,
                     inputs: {
@@ -1656,6 +1742,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 +1977,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();
@@ -2430,6 +2518,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 +2678,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,
             });
         }
 
@@ -2779,6 +2876,25 @@ 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,
+            });
+        } else {
+            this.#probe_clipmap_gi.release();
+        }
+
         const volumetrics = this.#volumetrics.graph_update({
             graph,
             view: view_ctx,
@@ -3092,6 +3208,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) {

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/fluid/FluidCascadePlacement.d.ts

@@ -18,63 +18,21 @@ export const FLUID_CASCADE_HYSTERESIS: number;
  * @type {number}
  */
 export const FLUID_CASCADE_NEST_MARGIN: number;
-/**
- * Smallest window side, cells, that nests: a child covers half its parent, so the other half must
- * hold the margin on both sides, rounded out to the corner lattice.
- * @type {number}
- */
-export const FLUID_CASCADE_NEST_RESOLUTION_MIN: number;
-/**
- * What {@link FluidCascadePlacementplace } did.
- */
-export type FluidCascadePlacementResult = number;
-/**
- * What {@link FluidCascadePlacement#place} did.
- * @readonly
- * @enum {number}
- */
-export const FluidCascadePlacementResult: Readonly<{
-    /** The window held. */
-    Held: 0;
-    /** The window moved, and the rest of the stack stayed. */
-    Moved: 1;
-    /** The move would have left a child outside its parent: the whole stack was re-placed. */
-    Jumped: 2;
-}>;
 /**
  * Where the windows of a stack of fluid cascades are (GPU_FLUID_CASCADES_PROPOSAL_2026_10_16.md §7): the
  * CPU half of `GPUFluidCascadeStack`, on the CPU alone so that placement is pinned without a device.
  *
- * Cascade `c` has cells of `cell_size·2^c` and the same resolution N; its window is
- * `[corner, corner + N)` in its own cells, and world cell `g` of it covers `[g·h_c, (g + 1)·h_c)`, so
- * the lattices nest: child cells `2G` and `2G + 1` lie in parent cell `G`. Every corner change goes
- * through S0's window maths: {@link ClipmapWindowSet} places, `window_scroll_regions` (the stack's) says
- * what a move exposed, and storage wraps, so a window that moves keeps every cell it still holds.
- *
- * **Placement** ({@link place}), on a cascade's own step tick, coarsest first:
- * 1. the hysteretic rule (`ClipmapWindowSet#place`, corners in 4s, moved past 2.1 cells of the anchor);
- * 2. a jump check: if that leaves the cascade's window not inside its parent's, or its child's window
- *    not inside its own, the move is a jump and the **whole stack is re-placed**
- *    ({@link place_all});
- * 3. the nesting clamp (`ClipmapWindowSet#clamp_corner`): the corner is held so that its window keeps
- *    {@link FLUID_CASCADE_NEST_MARGIN} parent cells inside its parent's, and so that its child's
- *    window keeps the margin inside its own. Both ranges hold the corner it had, so both clamps
- *    together land in both.
- *
- * {@link place_all} places every cascade, coarsest first, by the hysteretic rule, and clamps each into
- * its parent: the first placement, and the answer to a jump.
- *
- * {@link begin} remembers every corner, so that after a tick's placements {@link moved} and
- * {@link previous_corner} say what to fill.
- *
- * Nothing here allocates once constructed.
+ * A {@link ClipmapCascadePlacement} with the fluid's rule: corners in {@link FLUID_CASCADE_CORNER_STEP}s,
+ * moved once the anchor is more than 2.1 cells from a window's centre, and every child
+ * {@link FLUID_CASCADE_NEST_MARGIN} parent cells inside its parent, which needs 32 cells an axis. The
+ * stack places a cascade on its own step tick, coarsest first.
  */
-export class FluidCascadePlacement {
+export class FluidCascadePlacement extends ClipmapCascadePlacement {
     /**
      * @param {object} options
      * @param {number} options.cascade_count 1 to 8
-     * @param {ArrayLike<number>} options.resolution cells on each axis, powers of two; at least
-     *   {@link FLUID_CASCADE_NEST_RESOLUTION_MIN} when there is more than one cascade
+     * @param {ArrayLike<number>} options.resolution cells on each axis, powers of two; at least 32 when
+     *   there is more than one cascade
      * @param {number} options.cell_size metres, cascade 0's
      */
     constructor({ cascade_count, resolution, cell_size }: {
@@ -82,61 +40,6 @@ export class FluidCascadePlacement {
         resolution: ArrayLike<number>;
         cell_size: number;
     });
-    /** @returns {number} */
-    get cascade_count(): number;
-    /** @returns {Readonly<Int32Array>} */
-    get resolution(): Readonly<Int32Array>;
-    /**
-     * Whether the stack has been placed.
-     * @returns {boolean}
-     */
-    get placed(): boolean;
-    /**
-     * A cascade's cell, metres: `cell_size·2^c`.
-     * @param {number} cascade
-     * @returns {number}
-     */
-    cell_size(cascade: number): number;
-    /**
-     * @param {number} cascade
-     * @param {number} axis
-     * @returns {number} the cascade's corner on the axis, in its own cells
-     */
-    corner(cascade: number, axis: number): number;
-    /**
-     * @param {number} cascade
-     * @param {number} axis
-     * @returns {number} the corner it had at the last {@link begin}
-     */
-    previous_corner(cascade: number, axis: number): number;
-    /**
-     * @param {number} cascade
-     * @returns {boolean} whether its corner moved since the last {@link begin}
-     */
-    moved(cascade: number): boolean;
-    /**
-     * Remember every corner: what {@link moved} and {@link previous_corner} compare with.
-     */
-    begin(): void;
-    /**
-     * Place every cascade, coarsest first, by the hysteretic rule, each child clamped into its parent.
-     *
-     * @param {number} x the anchor, world metres
-     * @param {number} y
-     * @param {number} z
-     */
-    place_all(x: number, y: number, z: number): void;
-    /**
-     * Place one cascade on its own step tick: the hysteretic rule, then the jump check, then the
-     * nesting clamp. Before the first {@link place_all} this places the whole stack.
-     *
-     * @param {number} cascade
-     * @param {number} x the anchor, world metres
-     * @param {number} y
-     * @param {number} z
-     * @returns {FluidCascadePlacementResult}
-     */
-    place(cascade: number, x: number, y: number, z: number): FluidCascadePlacementResult;
-    #private;
 }
+import { ClipmapCascadePlacement } from "../../../core/geom/clipmap/ClipmapCascadePlacement.js";
 //# sourceMappingURL=FluidCascadePlacement.d.ts.map

package/src/shade/renderer/fluid/FluidCascadePlacement.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"FluidCascadePlacement.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/fluid/FluidCascadePlacement.js"],"names":[],"mappings":"AAIA;;;;GAIG;AACH,wCAFU,MAAM,CAE2B;AAE3C;;;;GAIG;AACH,uCAFU,MAAM,CAE4B;AAE5C;;;;;;GAMG;AACH,wCAFU,MAAM,CAE2B;AAE3C;;;;GAIG;AACH,gDAFU,MAAM,CAEoC;;;;0CAK1C,MAAM;AAHhB;;;;GAIG;AACH;IACI,uBAAuB;;IAEvB,0DAA0D;;IAE1D,0FAA0F;;GAE3F;AAgBH;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH;IAkBI;;;;;;OAMG;IACH;QAL2B,aAAa,EAA7B,MAAM;QACqB,UAAU,EAArC,UAAU,MAAM,CAAC;QAED,SAAS,EAAzB,MAAM;OA2BhB;IAED,wBAAwB;IACxB,4BAEC;IAED,sCAAsC;IACtC,uCAEC;IAED;;;OAGG;IACH,sBAEC;IAED;;;;OAIG;IACH,mBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;OAIG;IACH,gBAJW,MAAM,QACN,MAAM,GACJ,MAAM,CAIlB;IAED;;;;OAIG;IACH,yBAJW,MAAM,QACN,MAAM,GACJ,MAAM,CAIlB;IAED;;;OAGG;IACH,eAHW,MAAM,GACJ,OAAO,CAQnB;IAED;;OAEG;IACH,cAMC;IA2DD;;;;;;OAMG;IACH,aAJW,MAAM,KACN,MAAM,KACN,MAAM,QAyBhB;IAED;;;;;;;;;OASG;IACH,eANW,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,GACJ,2BAA2B,CAwCvC;;CACJ"}
+{"version":3,"file":"FluidCascadePlacement.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/fluid/FluidCascadePlacement.js"],"names":[],"mappings":"AAGA;;;;GAIG;AACH,wCAFU,MAAM,CAE2B;AAE3C;;;;GAIG;AACH,uCAFU,MAAM,CAE4B;AAE5C;;;;;;GAMG;AACH,wCAFU,MAAM,CAE2B;AAE3C;;;;;;;;GAQG;AACH;IACI;;;;;;OAMG;IACH;QAL2B,aAAa,EAA7B,MAAM;QACqB,UAAU,EAArC,UAAU,MAAM,CAAC;QAED,SAAS,EAAzB,MAAM;OAahB;CACJ;wCAtDuC,uDAAuD"}