@woosh/meep-engine 3.46.0 → 3.49.0

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

@@ -38,6 +38,13 @@ export class Renderer {
      * @type {ShadeTransparencyMode}
      */
     transparency_mode: ShadeTransparencyMode;
+    /**
+     * How the exposed scene colour becomes display colour, on every output. An SDR and an HDR display run the same
+     * mode, so a scene looks alike on both; see {@link ShadeToneMappingMode}. Read every frame, so it can be flipped
+     * at runtime. A mode not in use at {@link initialize} compiles its pass on the first frame that draws with it.
+     * @type {ShadeToneMappingMode}
+     */
+    tone_mapping_mode: ShadeToneMappingMode;
     /**
      * Switches of the AVBOIT mode, read every frame while {@link transparency_mode} selects it.
      * @type {AVBOITSettings}
@@ -83,6 +90,10 @@ export class Renderer {
      * @type {boolean}
      */
     feature_virtual_shadow_maps: boolean;
+    /**
+     * @returns {ShaderSwitchSet} see {@link #shader_switches}
+     */
+    get shader_switches(): ShaderSwitchSet;
     set shadow_virtual_page_budget(v: number);
     get shadow_virtual_page_budget(): number;
     /**
@@ -421,6 +432,8 @@ export class Renderer {
      */
     get nss(): NSS;
     /**
+     * Rejects with a {@link ShadeDeviceFailure} when there is no usable device — no WebGPU, no
+     * adapter, an adapter below {@link SHADE_DEVICE_FLOOR}, or a refused device request.
      *
      * @param {Object} [options]
      * @param {GPUCanvasContext} [options.context] Optional, if not provided - one will be created.
@@ -432,6 +445,22 @@ export class Renderer {
         device?: GPUDevice;
         pixelRatio?: number;
     }): Promise<void>;
+    /**
+     * Offer the pipelines a frame draws with — see {@link PipelineEnquiry}. {@link initialize}
+     * compiles the answer off the main thread, and {@link render} draws nothing until it is in.
+     *
+     * Each subsystem is asked only when the feature flag that runs it is on, so the answer follows the
+     * features as they are set at that moment. It covers the default renderer: the opaque raster,
+     * shading, IBL, ambient occlusion, TAA, sharpening, bloom, exposure and the tonemap. Everything
+     * else is made the old way, by the first frame that draws with it: the features that are off by
+     * default (ReSTIR's passes, SSR, depth of field, motion blur, NSS, path tracing), the indirect
+     * lighting modes other than IBL, a feature turned on after {@link initialize}, and whatever a
+     * scene's content brings — shadow casters, transparent and alpha-tested materials, volumes,
+     * particles.
+     *
+     * @param {PipelineEnquiry} enquiry
+     */
+    enquirePipelines(enquiry: PipelineEnquiry): void;
     /**
      * Release everything {@link initialize} built, in reverse.
      *
@@ -472,9 +501,11 @@ export class Renderer {
      * simulation, the animation tick and exposure adaptation all step by it. Zero by default, which
      * draws the current state and moves nothing; a fixed fraction of a second here instead would run
      * the simulation at that rate no matter what the caller's clock was doing.
-     * @returns {boolean} whether a frame was encoded and submitted. False only when there is nothing
-     * to draw with — the device was lost, or the renderer destroyed. Frames the GPU has not finished
-     * yet neither hold this one back nor make it return false.
+     * @returns {boolean} whether a frame was encoded and submitted. False when there is nothing to
+     * draw with — the device was lost, or the renderer destroyed — and while a pipeline prepared
+     * ahead of use is still compiling: the ones {@link initialize} asked for, or a template
+     * prewarmed at a level load. Frames the GPU has not finished yet neither
+     * hold this one back nor make it return false.
      */
     render(camera: PerspectiveCamera, scene: Scene, time_delta_seconds?: number): boolean;
     /**
@@ -508,7 +539,9 @@ export type Scene = import("./scene/Scene.js").Scene;
 import { SceneManager } from "./scene/SceneManager.js";
 import { ShadeIndirectLightingMode } from "./ShadeIndirectLightingMode.js";
 import { ShadeTransparencyMode } from "./ShadeTransparencyMode.js";
+import { ShadeToneMappingMode } from "./ShadeToneMappingMode.js";
 import { AVBOITSettings } from "./rasterize/native/avboit/AVBOITSettings.js";
+import { ShaderSwitchSet } from "./shader/compiler/ShaderSwitchSet.js";
 import { MotionBlur } from "./postprocess/motion_blur/MotionBlur.js";
 import { DepthOfField } from "./postprocess/dof/raymarch/DepthOfField.js";
 import { DepthOfFieldU } from "./postprocess/dof/gather/DepthOfFieldU.js";
@@ -523,5 +556,6 @@ import { ReSTIRDI } from "./restir/di/ReSTIRDI.js";
 import { GPUParticleSystem } from "./particles/GPUParticleSystem.js";
 import { ShadeUpscalerType } from "./ShadeUpscalerType.js";
 import { NSS } from "./postprocess/nss/NSS.js";
+import { PipelineEnquiry } from "../device/pipeline/PipelineEnquiry.js";
 import { AccumulatingPathTracer } from "./path_tracer/accumulating/AccumulatingPathTracer.js";
 //# sourceMappingURL=Renderer.d.ts.map

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

@@ -11,14 +11,21 @@ import {
 import { FrameGraph } from "../../engine/graphics/render/frame_graph/FrameGraph.js";
 import { TextureDescriptor } from "../descriptor/texture/TextureDescriptor.js";
 import { WebGPUExtensionType } from "../descriptor/WebGPUExtensionType.js";
+import { SHADE_DEVICE_FLOOR } from "../device/SHADE_DEVICE_FLOOR.js";
+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 { CameraManager } from "./camera/CameraManager.js";
 import { shader_background } from "./deferred/shader_background.js";
 import { shader_composite_volumetrics } from "./deferred/shader_composite_volumetrics.js";
 import { shader_deferred_main, shader_deferred_main_restir } from "./deferred/shader_deferred_main.js";
 import { shader_tonemap_HDR } from "./deferred/shader_tonemap_HDR.js";
+import { shader_tonemap_HDR_none } from "./deferred/shader_tonemap_HDR_none.js";
+import { shader_tonemap_HDR_pbr_neutral } from "./deferred/shader_tonemap_HDR_pbr_neutral.js";
 import { shader_tonemap_LDR } from "./deferred/shader_tonemap_LDR.js";
+import { shader_tonemap_LDR_none } from "./deferred/shader_tonemap_LDR_none.js";
+import { shader_tonemap_LDR_pbr_neutral } from "./deferred/shader_tonemap_LDR_pbr_neutral.js";
 import { FrameContext } from "./extension/FrameContext.js";
 import { FramePhase } from "./extension/FramePhase.js";
 import { GBufferTextures } from "./extension/GBufferTextures.js";
@@ -38,9 +45,15 @@ import { GPULightProbeVolumeRenderer } from "./global_illumination/lpv/bake/GPUL
 import { shader_diffuse_LPV } from "./global_illumination/lpv/shader_diffuse_LPV.js";
 import { shader_resolve_indirect_lighting } from "./global_illumination/shader_resolve_indirect_lighting.js";
 import { GraphicsContext } from "./GraphicsContext.js";
-import { graph_build_light_clusters } from "./light/cluster/graph_build_light_clusters.js";
+import {
+    enquire_build_light_clusters_pipelines,
+    graph_build_light_clusters
+} from "./light/cluster/graph_build_light_clusters.js";
 import { AccumulatingPathTracer } from "./path_tracer/accumulating/AccumulatingPathTracer.js";
-import { graph_postprocess_bloom } from "./postprocess/bloom/graph_postprocess_bloom.js";
+import {
+    enquire_postprocess_bloom_pipelines,
+    graph_postprocess_bloom
+} from "./postprocess/bloom/graph_postprocess_bloom.js";
 import { shader_ffx_rcas } from "./postprocess/cas/shader_ffx_rcas.js";
 import { DepthOfFieldU } from "./postprocess/dof/gather/DepthOfFieldU.js";
 import { DepthOfField } from "./postprocess/dof/raymarch/DepthOfField.js";
@@ -50,7 +63,10 @@ import { NSS } from "./postprocess/nss/NSS.js";
 import { PostProcess } from "./postprocess/PostProcess.js";
 import { shader_depth_occlusion_clip } from "./postprocess/taa/shader_depth_occlusion_clip.js";
 import { TAA } from "./postprocess/taa/TAA.js";
-import { graph_add_per_object_velocity } from "./postprocess/velocity/graph_add_per_object_velocity.js";
+import {
+    enquire_per_object_velocity_pipelines,
+    graph_add_per_object_velocity
+} from "./postprocess/velocity/graph_add_per_object_velocity.js";
 import { shader_debug_velocity } from "./postprocess/velocity/shader_debug_velocity.js";
 import {
     graph_rasterize_meshes_transparent_oit
@@ -64,19 +80,24 @@ import {
 import {
     viz_rasterization_opaque_pass_descriptor
 } from "./rasterize/native/viz/viz_rasterization_opaque_pass_descriptor.js";
+import { CullPolicy } from "./rasterize/bucket/construct_primitive_state.js";
 import { RasterizationJob } from "./rasterize/RasterizationJob.js";
-import { graph_rasterize_scene } from "./rasterize/standard/graph_rasterize_scene.js";
+import { enquire_rasterize_scene_pipelines, graph_rasterize_scene } from "./rasterize/standard/graph_rasterize_scene.js";
 import { ReSTIRDI } from "./restir/di/ReSTIRDI.js";
 import { GPUParticleSystem } from "./particles/GPUParticleSystem.js";
 import { SceneManager } from "./scene/SceneManager.js";
 import { ShadeIndirectLightingMode } from "./ShadeIndirectLightingMode.js";
+import { ShadeToneMappingMode } from "./ShadeToneMappingMode.js";
 import { ShadeTransparencyMode } from "./ShadeTransparencyMode.js";
 import { AVBOITSettings } from "./rasterize/native/avboit/AVBOITSettings.js";
+import { ShaderSwitchSet } from "./shader/compiler/ShaderSwitchSet.js";
 import { graph_image_pass } from "./shader/graph/graph_image_pass.js";
 import { graph_import_buffer } from "./shader/graph/graph_import_buffer.js";
 import { graph_import_texture } from "./shader/graph/graph_import_texture.js";
 import { ShadeUpscalerType } from "./ShadeUpscalerType.js";
 import { DEFAULT_SHADOWMAP_UPDATE_BUDGET } from "./shadow/map/DEFAULT_SHADOWMAP_UPDATE_BUDGET.js";
+import { SHADOW_DIRECTIONAL_TECHNIQUE } from "./shadow/map/shader/SHADOW_DIRECTIONAL_TECHNIQUE.js";
+import { ShadowDirectionalTechnique } from "./shadow/map/ShadowDirectionalTechnique.js";
 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";
@@ -198,6 +219,14 @@ export class Renderer {
      */
     transparency_mode = ShadeTransparencyMode.AVBOIT;
 
+    /**
+     * How the exposed scene colour becomes display colour, on every output. An SDR and an HDR display run the same
+     * mode, so a scene looks alike on both; see {@link ShadeToneMappingMode}. Read every frame, so it can be flipped
+     * at runtime. A mode not in use at {@link initialize} compiles its pass on the first frame that draws with it.
+     * @type {ShadeToneMappingMode}
+     */
+    tone_mapping_mode = ShadeToneMappingMode.GT7;
+
     /**
      * Switches of the AVBOIT mode, read every frame while {@link transparency_mode} selects it.
      * @type {AVBOITSettings}
@@ -282,6 +311,34 @@ export class Renderer {
      */
     feature_virtual_shadow_maps = false;
 
+    /**
+     * The values of the shader switches, for every pass this renderer records: what its feature flags
+     * make of the switches its shaders decide ({@link SHADOW_DIRECTIONAL_TECHNIQUE} from
+     * {@link feature_virtual_shadow_maps}). A pass hands it to the shaders it draws with, which build
+     * their variant for it. Interned, so it stays the same object until a flag changes, and looking a
+     * variant up by it allocates nothing.
+     *
+     * @type {ShaderSwitchSet}
+     */
+    #shader_switches = ShaderSwitchSet.EMPTY;
+
+    /**
+     * @returns {ShaderSwitchSet} see {@link #shader_switches}
+     */
+    get shader_switches() {
+        return this.#shader_switches;
+    }
+
+    /**
+     * Bring {@link #shader_switches} up to the feature flags. Allocates nothing while they are unchanged.
+     */
+    #update_shader_switches() {
+        this.#shader_switches = this.#shader_switches.with(
+            SHADOW_DIRECTIONAL_TECHNIQUE,
+            this.feature_virtual_shadow_maps ? ShadowDirectionalTechnique.Virtual : ShadowDirectionalTechnique.Cascades
+        );
+    }
+
     /**
      * Virtual shadow map pages a scene may render per frame, pushed to the scene's shadow context
      * each frame; see {@link DEFAULT_VSM_PAGE_BUDGET} for what a page costs and what waits.
@@ -1375,6 +1432,8 @@ export class Renderer {
     }
 
     /**
+     * Rejects with a {@link ShadeDeviceFailure} when there is no usable device — no WebGPU, no
+     * adapter, an adapter below {@link SHADE_DEVICE_FLOOR}, or a refused device request.
      *
      * @param {Object} [options]
      * @param {GPUCanvasContext} [options.context] Optional, if not provided - one will be created.
@@ -1387,8 +1446,8 @@ export class Renderer {
                          pixelRatio = window.devicePixelRatio,
                      } = {}) {
 
-        if (!('gpu' in navigator)) {
-            throw new Error('navigator.gpu not available — WebGPU disabled or unsupported');
+        if (navigator.gpu === undefined) {
+            throw ShadeDeviceFailure.webgpu_unavailable();
         }
 
         this.#update_presentation_format();
@@ -1414,13 +1473,7 @@ export class Renderer {
         if (device === undefined) {
             // no device present, let's create one
 
-            const gpu = navigator.gpu;
-
-            if (gpu === undefined) {
-                throw ShadeDeviceFailure.webgpu_unavailable();
-            }
-
-            const adapter = await gpu.requestAdapter({
+            const adapter = await navigator.gpu.requestAdapter({
                 powerPreference: "high-performance",
             });
 
@@ -1441,27 +1494,22 @@ export class Renderer {
             //
             // console.warn('adapter limits:', adapter.limits);
 
-            const maxStorageBuffersPerShaderStage = adapter.limits.maxStorageBuffersPerShaderStage;
+            // The whole floor is checked before a device is asked for, so a refusal names every gap,
+            // with the numbers this adapter offers, rather than whichever one requestDevice trips on.
+            const unmet = shade_device_floor_unmet(adapter);
 
-            if (maxStorageBuffersPerShaderStage < 10) {
-                throw ShadeDeviceFailure.below_floor(
-                    `requires at least 10 storage buffers per shader stage, adapter offers ${maxStorageBuffersPerShaderStage}`
-                );
+            if (unmet.length > 0) {
+                throw ShadeDeviceFailure.below_floor(unmet);
             }
 
-            const requiredFeatures = [
-                // required for indirect draw that's used extensively in Shade
-                WebGPUExtensionType.IndirectFirstInstance,
-                // required for OIT (might be unavailable)
-                WebGPUExtensionType.Float32Blendable,
-            ];
+            const requiredFeatures = SHADE_DEVICE_FLOOR.features.slice();
 
             // add features if they are available
             const optional_desired = [
                 // Profiling only, and some browsers withhold it on hardware that is otherwise
                 // fine — so it is taken when offered and the timers go quiet when it is not
                 // (E7, sponsor 2026-08-16). Requiring it would refuse to start on those browsers
-                // for the sake of a feature the game does not need to run.
+                // for the sake of a feature the renderer does not need to run.
                 WebGPUExtensionType.TimestampQuery,
                 WebGPUExtensionType.Subgroups,
                 WebGPUExtensionType.TextureFormatsTier1,
@@ -1475,35 +1523,28 @@ export class Renderer {
                 WebGPUExtensionType.TextureCompressionASTC,
             ];
 
-            // valid required features
-            for (const feature of requiredFeatures) {
-                if (!adapter.features.has(feature)) {
-                    throw ShadeDeviceFailure.below_floor(`adapter does not support required feature '${feature}'`);
-                }
-            }
-
             for (const feature of optional_desired) {
                 if (adapter.features.has(feature)) {
                     requiredFeatures.push(feature);
                 }
             }
 
+            try {
+                device = await adapter.requestDevice({
+                    requiredLimits: {
+                        ...SHADE_DEVICE_FLOOR.limits,
 
-            device = await adapter.requestDevice({
-                requiredLimits: {
-                    // required for large G-buffers
-                    maxColorAttachmentBytesPerSample: 32,
-
-                    /*
-                     grab the largest buffer limit we can get, default limits are super-low
-                     */
-                    maxBufferSize: adapter.limits.maxBufferSize,
-                    maxStorageBufferBindingSize: adapter.limits.maxStorageBufferBindingSize,
-
-                    maxStorageBuffersPerShaderStage: 10,
-                },
-                requiredFeatures
-            });
+                        /*
+                         grab the largest buffer limit we can get, default limits are super-low
+                         */
+                        maxBufferSize: adapter.limits.maxBufferSize,
+                        maxStorageBufferBindingSize: adapter.limits.maxStorageBufferBindingSize,
+                    },
+                    requiredFeatures
+                });
+            } catch (error) {
+                throw ShadeDeviceFailure.device_request_failed(error.message);
+            }
 
             // NOTE: according to spec (as of 2025/09/19) - adapter can only be used to create one device, after which it becomes "consumed"
             //       see https://www.w3.org/TR/webgpu/#adapters
@@ -1515,18 +1556,6 @@ export class Renderer {
             this.#handle_device_lost(info);
         })
 
-        if (context === undefined) {
-            const canvas = document.createElement('canvas');
-            canvas.width = window.innerWidth;
-            canvas.height = window.innerHeight;
-
-            context = canvas.getContext('webgpu');
-
-            if (context === null) {
-                throw new Error('Failed to bind GPUCanvasContext');
-            }
-        }
-
         assert.ok(device.features.has("indirect-first-instance"), '"indirect-first-instance" feature needs to be enabled for non-zero firstInstance values to be used.')
         assert.isInstanceOf(context, GPUCanvasContext, 'context', 'GPUCanvasContext');
 
@@ -1607,6 +1636,126 @@ export class Renderer {
 
         window.matchMedia("(dynamic-range: high)").addEventListener("change", this.#update_hdr_support);
 
+        this.#prepare_pipelines();
+    }
+
+    /**
+     * Offer the pipelines a frame draws with — see {@link PipelineEnquiry}. {@link initialize}
+     * compiles the answer off the main thread, and {@link render} draws nothing until it is in.
+     *
+     * Each subsystem is asked only when the feature flag that runs it is on, so the answer follows the
+     * features as they are set at that moment. It covers the default renderer: the opaque raster,
+     * shading, IBL, ambient occlusion, TAA, sharpening, bloom, exposure and the tonemap. Everything
+     * else is made the old way, by the first frame that draws with it: the features that are off by
+     * default (ReSTIR's passes, SSR, depth of field, motion blur, NSS, path tracing), the indirect
+     * lighting modes other than IBL, a feature turned on after {@link initialize}, and whatever a
+     * scene's content brings — shadow casters, transparent and alpha-tested materials, volumes,
+     * particles.
+     *
+     * @param {PipelineEnquiry} enquiry
+     */
+    enquirePipelines(enquiry) {
+        const graphics = this.#graphics;
+
+        // The longest compile goes first. With everything else compiling beside it this one is the
+        // whole wait (~1 s of a cold simple-cube's ~1.1 s), and where there are fewer compile
+        // workers than pipelines, the order they are asked for is roughly the order they start.
+        this.#update_shader_switches();
+
+        const deferred_shader = (this.feature_restir_di_enabled ? shader_deferred_main_restir : shader_deferred_main)
+            .variant(this.#shader_switches);
+
+        enquiry.render.push(deferred_shader.pipeline);
+
+        // the scene colour target's format: the background and the indirect-lighting resolve draw into
+        // the target the shading pass made
+        const color_formats = [deferred_shader.pipeline.fragment.targets[0].format];
+
+        graphics.materials.enquirePipelines(enquiry);
+        this.#scenes.enquirePipelines(enquiry);
+
+        enquire_rasterize_scene_pipelines(enquiry, viz_rasterization_opaque_pass_descriptor, CullPolicy.Standard);
+
+        enquire_per_object_velocity_pipelines(enquiry);
+        enquiry.render.push(shader_depth_occlusion_clip.pipeline);
+        enquire_build_light_clusters_pipelines(enquiry);
+
+        if (this.feature_ssao_enabled) {
+            this.#postprocess.ssao.enquirePipelines(enquiry);
+        }
+
+        enquiry.render.push(shader_background.pipeline_for(color_formats));
+
+        if (this.indirect_lighting_mode === ShadeIndirectLightingMode.IBL) {
+            if (!this.feature_ssr_enabled) {
+                // what SSR replaces
+                enquiry.render.push(shader_specular_IBL.pipeline);
+            }
+
+            enquiry.render.push(shader_diffuse_IBL.pipeline);
+            enquiry.render.push(shader_resolve_indirect_lighting.pipeline_for(color_formats));
+        }
+
+        if (this.feature_taa_enabled && this.upscale_type === ShadeUpscalerType.TAA) {
+            this.#taa.enquirePipelines(enquiry, this.#textures_taa_history[0].descriptor.format);
+        }
+
+        if (this.feature_sharpening_enabled) {
+            enquiry.render.push(shader_ffx_rcas.pipeline);
+        }
+
+        if (this.feature_bloom_enabled) {
+            enquire_postprocess_bloom_pipelines(enquiry);
+        }
+
+        if (this.feature_automatic_exposure_enabled) {
+            this.#autoexposure.enquirePipelines(enquiry);
+        }
+
+        enquiry.render.push(this.#tonemap_shader().pipeline_for([this.#presentation_format]));
+    }
+
+    /**
+     * The pass that writes the canvas: the output's dynamic range picks the SDR or the HDR form, and
+     * {@link tone_mapping_mode} picks the operator.
+     *
+     * @returns {import("./shader/ImageShader.js").ImageShader}
+     */
+    #tonemap_shader() {
+        assert.enum(this.tone_mapping_mode, ShadeToneMappingMode, 'tone_mapping_mode');
+
+        if (this.tone_mapping_mode === ShadeToneMappingMode.NONE) {
+            return this.#hdr_supported ? shader_tonemap_HDR_none : shader_tonemap_LDR_none;
+        }
+
+        if (this.tone_mapping_mode === ShadeToneMappingMode.PBR_NEUTRAL) {
+            return this.#hdr_supported ? shader_tonemap_HDR_pbr_neutral : shader_tonemap_LDR_pbr_neutral;
+        }
+
+        return this.#hdr_supported ? shader_tonemap_HDR : shader_tonemap_LDR;
+    }
+
+    /**
+     * Compile what {@link enquirePipelines} offers, off the main thread — see {@link PipelineEnquiry}.
+     */
+    #prepare_pipelines() {
+        const enquiry = PipelineEnquiry.from(this.device);
+
+        this.enquirePipelines(enquiry);
+
+        const graphics = this.#graphics;
+
+        const render = enquiry.render;
+
+        for (let i = 0; i < render.length; i++) {
+            graphics.render_pipelines.prepare(render[i]);
+        }
+
+        const compute = enquiry.compute;
+
+        for (let i = 0; i < compute.length; i++) {
+            graphics.compute_pipelines.prepare(compute[i]);
+        }
     }
 
     /**
@@ -1985,9 +2134,11 @@ export class Renderer {
      * simulation, the animation tick and exposure adaptation all step by it. Zero by default, which
      * draws the current state and moves nothing; a fixed fraction of a second here instead would run
      * the simulation at that rate no matter what the caller's clock was doing.
-     * @returns {boolean} whether a frame was encoded and submitted. False only when there is nothing
-     * to draw with — the device was lost, or the renderer destroyed. Frames the GPU has not finished
-     * yet neither hold this one back nor make it return false.
+     * @returns {boolean} whether a frame was encoded and submitted. False when there is nothing to
+     * draw with — the device was lost, or the renderer destroyed — and while a pipeline prepared
+     * ahead of use is still compiling: the ones {@link initialize} asked for, or a template
+     * prewarmed at a level load. Frames the GPU has not finished yet neither
+     * hold this one back nor make it return false.
      */
     render(
         camera,
@@ -2000,6 +2151,18 @@ export class Renderer {
             return false;
         }
 
+        const graphics = this.#graphics;
+
+        if (graphics.render_pipelines.pending_count > 0 || graphics.compute_pipelines.pending_count > 0) {
+            /*
+             Pipelines prepared ahead of use are still compiling. A frame encoded now would make
+             each one it reaches again, synchronously — one after another on the thread that also
+             presents the page, the very wait the asynchronous compile exists to avoid. Nothing is
+             encoded and the canvas keeps what it had.
+            */
+            return false;
+        }
+
         this.#ensure_context_configured();
 
         const canvas_texture = this.context.getCurrentTexture();
@@ -2173,6 +2336,8 @@ export class Renderer {
         // Virtual shadow maps for directional lights, and what they may spend; a flip of the flag or
         // of the first texel rebuilds the maps inside process_lights.
         sm.use_virtual_shadow_maps = this.feature_virtual_shadow_maps;
+        // and the shaders that sample those maps, built for the same technique, in the same frame
+        this.#update_shader_switches();
         sm.virtual_page_budget = this.#shadow_virtual_page_budget;
         sm.virtual_lod_bias = this.shadow_virtual_lod_bias;
         sm.virtual_first_texel_size = this.#shadow_virtual_first_texel_size;
@@ -2529,6 +2694,7 @@ export class Renderer {
             light_cluster_parameters: light_clusters.parameters,
             shadowmap_atlas: gr_shadowmap_atlas,
             indirect_lighting_mode: this.indirect_lighting_mode,
+            shader_switches: this.#shader_switches,
         });
 
         /**
@@ -2550,6 +2716,7 @@ export class Renderer {
             gBufferNormal: gr_texture_normal,
             gBufferAlbedo: gr_texture_material_albedo_ao,
             gBufferEmissive: gr_texture_material_emissive,
+            tSplitSum: STATIC_GRAPHICS_ENGINE_ASSETS.split_sum,
 
             //
             light_data: lights.buffer_data,
@@ -2591,7 +2758,7 @@ export class Renderer {
         // Main shading pass
         [current_color_out] = graph_image_pass({
             graph,
-            shader: deferred_shader,
+            shader: deferred_shader.variant(this.#shader_switches),
             input_depth: gr_texture_depth_current,
             inputs: deferred_inputs,
             output_resolution: view_ctx.resolution,
@@ -2790,6 +2957,7 @@ export class Renderer {
                 volumetrics_irradiance: volumetrics.irradiance,
 
                 indirect_lighting_mode: this.indirect_lighting_mode,
+                shader_switches: this.#shader_switches,
                 avboit: this.avboit,
                 side_channels,
             });
@@ -2987,15 +3155,17 @@ export class Renderer {
 
         current_color_out = record_scene_color.color;
 
-        if (this.#hdr_supported) {
+        const tonemap = this.#tonemap_shader();
+
+        if (tonemap === shader_tonemap_HDR || tonemap === shader_tonemap_HDR_pbr_neutral) {
+            // an operator on an HDR display is told the display's peak; the paper white is a constant
             [current_color_out] = graph_image_pass({
                 graph,
-                shader: shader_tonemap_HDR,
+                shader: tonemap,
                 inputs: {
                     input_color: current_color_out,
                     settings: {
                         peak_nits: this.#display_peak_brightness_nits,
-                        paper_white_nits: 100, // SDR spec is 80, but 100 has been accepted as de-facto in recent years
                     },
                     exposure
                 },
@@ -3004,7 +3174,7 @@ export class Renderer {
         } else {
             [current_color_out] = graph_image_pass({
                 graph,
-                shader: shader_tonemap_LDR,
+                shader: tonemap,
                 inputs: {
                     input_color: current_color_out,
                     exposure

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

@@ -0,0 +1,14 @@
+/**
+ * How the exposed scene colour becomes display colour.
+ *
+ * One choice for every display. The same mode runs on an SDR and an HDR output, so a scene looks the same on both up
+ * to the SDR display's limits. That is the reason Polyphony give for GT7's operator, and there is no per-output
+ * setting on purpose.
+ */
+export type ShadeToneMappingMode = number;
+export namespace ShadeToneMappingMode {
+    let GT7: number;
+    let NONE: number;
+    let PBR_NEUTRAL: number;
+}
+//# sourceMappingURL=ShadeToneMappingMode.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ShadeToneMappingMode.d.ts","sourceRoot":"","sources":["../../../../src/shade/renderer/ShadeToneMappingMode.js"],"names":[],"mappings":";;;;;;;mCAOU,MAAM"}

package/src/shade/renderer/ShadeToneMappingMode.js

@@ -0,0 +1,30 @@
+/**
+ * How the exposed scene colour becomes display colour.
+ *
+ * One choice for every display. The same mode runs on an SDR and an HDR output, so a scene looks the same on both up
+ * to the SDR display's limits. That is the reason Polyphony give for GT7's operator, and there is no per-output
+ * setting on purpose.
+ *
+ * @enum {number}
+ */
+export const ShadeToneMappingMode = {
+    /**
+     * GT7 tone mapping (Polyphony Digital, SIGGRAPH 2025). An exposed 1.0 shows at a 250 cd/m² paper white on both
+     * outputs. SDR clips at that paper white, the curve's SDR mode, and HDR rolls off to the display's peak.
+     */
+    GT7: 0,
+    /**
+     * No tone mapping: the exposed colour as it is, with 1.0 at SDR white. An SDR output clips everything above 1.0,
+     * and an HDR output shows it as far as the display reaches.
+     */
+    NONE: 1,
+    /**
+     * Khronos PBR Neutral (Lalish, 2024). Base colours under 0.8 come out as they are, less a 0.04 Fresnel offset, and
+     * hues never shift: made for showing products. SDR is the specification, which rolls highlights off to SDR white
+     * and toward white. HDR puts the display's peak in place of the specification's 1, so everything below the
+     * compression start looks the same on both outputs, and a highlight rolls off to the display's peak instead.
+     *
+     * An exposed 0.18 shows at 0.14 of SDR white, where {@link GT7} shows it at 0.179.
+     */
+    PBR_NEUTRAL: 2,
+};