@woosh/meep-engine 3.47.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;
     /**
@@ -434,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.
      *
@@ -474,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;
     /**
@@ -510,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";
@@ -525,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

@@ -14,13 +14,18 @@ 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";
@@ -40,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";
@@ -52,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
@@ -66,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";
@@ -200,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}
@@ -284,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.
@@ -1581,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]);
+        }
     }
 
     /**
@@ -1959,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,
@@ -1974,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();
@@ -2147,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;
@@ -2503,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,
         });
 
         /**
@@ -2524,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,
@@ -2565,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,
@@ -2764,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,
             });
@@ -2961,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
                 },
@@ -2978,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,
+};

package/src/shade/renderer/animation/GPUAnimationManager.d.ts

@@ -28,6 +28,14 @@
  *     update path.
  */
 export class GPUAnimationManager {
+    /**
+     * Offer the pipelines {@link tick} runs on every frame: the transform hierarchy, which composes
+     * world matrices whether or not anything is animated — see {@link PipelineEnquiry}. The clip,
+     * pose and skinning passes are left to the first frame that has a clip or a skin.
+     *
+     * @param {PipelineEnquiry} enquiry
+     */
+    static enquirePipelines(enquiry: PipelineEnquiry): void;
     /**
      * @param {GPUDevice} device
      * @param {string} label
@@ -518,6 +526,7 @@ export class GPUAnimationManager {
     destroy(): void;
     #private;
 }
+export type PipelineEnquiry = import("../../device/pipeline/PipelineEnquiry.js").PipelineEnquiry;
 export type AnimationCurve = import("../../../engine/animation/curve/AnimationCurve.js").AnimationCurve;
 export type GPURecordWriter = import("../buffer/table/serde/generate_record_writer.js").GPURecordWriter;
 export type ShadeGPUCommandContext = import("../../device/ShadeGPUCommandContext.js").ShadeGPUCommandContext;

package/src/shade/renderer/animation/GPUAnimationManager.d.ts.map

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

package/src/shade/renderer/animation/GPUAnimationManager.js

@@ -7,6 +7,7 @@ import { GPUDatabase } from "../buffer/table/GPUDatabase.js";
 import { GPU_DATABASE_NULL } from "../buffer/table/GPU_DATABASE_NULL.js";
 import { generate_record_writer } from "../buffer/table/serde/generate_record_writer.js";
 import {
+    enquire_scene_update_transform_hierarchy_pipelines,
     graph_scene_update_transform_hierarchy
 } from "../scene/hierarchy/graph_scene_update_transform_hierarchy.js";
 import { graph_import_buffer } from "../shader/graph/graph_import_buffer.js";
@@ -48,6 +49,7 @@ import {
 } from "./skinning/shader_skin_matrix_prep.js";
 
 /**
+ * @typedef {import("../../device/pipeline/PipelineEnquiry.js").PipelineEnquiry} PipelineEnquiry
  * @typedef {import("../../../engine/animation/curve/AnimationCurve.js").AnimationCurve} AnimationCurve
  * @typedef {import("../buffer/table/serde/generate_record_writer.js").GPURecordWriter} GPURecordWriter
  * @typedef {import("../../device/ShadeGPUCommandContext.js").ShadeGPUCommandContext} ShadeGPUCommandContext
@@ -351,6 +353,18 @@ function skin_content_equals(skin, joints, inverse_bind_matrices) {
  */
 export class GPUAnimationManager {
 
+    /**
+     * Offer the pipelines {@link tick} runs on every frame: the transform hierarchy, which composes
+     * world matrices whether or not anything is animated — see {@link PipelineEnquiry}. The clip,
+     * pose and skinning passes are left to the first frame that has a clip or a skin.
+     *
+     * @param {PipelineEnquiry} enquiry
+     */
+    static enquirePipelines(enquiry) {
+        enquire_scene_update_transform_hierarchy_pipelines(enquiry);
+    }
+
+
     /** @type {GPUDevice} */
     #device;
 

package/src/shade/renderer/animation/skinning/shader_meshlet_apply_skinning.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_meshlet_apply_skinning.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/animation/skinning/shader_meshlet_apply_skinning.js"],"names":[],"mappings":"AAqCA;;;;GAIG;AACH,yCAA0C;AAiT1C;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,0DAIG;8BAtV2B,+BAA+B"}
+{"version":3,"file":"shader_meshlet_apply_skinning.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/animation/skinning/shader_meshlet_apply_skinning.js"],"names":[],"mappings":"AAqCA;;;;GAIG;AACH,yCAA0C;AAmT1C;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,0DAIG;8BAxV2B,+BAA+B"}

package/src/shade/renderer/animation/skinning/shader_meshlet_apply_skinning.js

@@ -96,9 +96,11 @@ resources.createGroup()
 // skinning into a shared slot would race, so the shader skips the
 // write for any attribute where the flag is set — the cloned slot
 // keeps the source's value and lighting on those vertices uses an
-// undeformed direction. For typical character meshes
-// normals/tangents vary per vertex and so don't get the all-equal
-// collapse, so this skip rarely engages in practice.
+// undeformed direction. MeshletBatch#compress never collapses either
+// on a meshlet that carries skin weights, so the skip engages only
+// for a meshlet encoded before it stopped (2026-10-16): until then a
+// flat cloth sheet, every bind normal alike, collapsed and was lit in
+// its bind pose whatever shape it took.
 //
 // SkinningJoints + SkinningWeights are read-only here. They CAN be
 // compressed — a meshlet where every vertex shares the same joint

package/src/shade/renderer/buffer/table/GPUDatabase.d.ts

@@ -9,6 +9,12 @@
  * see "Rendering 'Assassin's Creed Shadows'" GDC 2025 by Nicolas Lopez
  */
 export class GPUDatabase {
+    /**
+     * Offer the pipelines {@link update} uploads records with — see {@link PipelineEnquiry}.
+     *
+     * @param {PipelineEnquiry} enquiry
+     */
+    static enquirePipelines(enquiry: PipelineEnquiry): void;
     /**
      * @param {Object} options
      * @param {GPUDatabaseDefinition} options.definition Immutable schema
@@ -144,6 +150,7 @@ export class GPUDatabase {
     destroy(): void;
     #private;
 }
+export type PipelineEnquiry = import("../../../device/pipeline/PipelineEnquiry.js").PipelineEnquiry;
 export type ShadeGPUCommandContext = import("../../../device/ShadeGPUCommandContext.js").ShadeGPUCommandContext;
 export type GPUDatabaseDefinition = import("./GPUDatabaseDefinition.js").GPUDatabaseDefinition;
 import { GPUTypedTable } from "./GPUTypedTable.js";

package/src/shade/renderer/buffer/table/GPUDatabase.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUDatabase.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/buffer/table/GPUDatabase.js"],"names":[],"mappings":"AA2CA;;;;;;;;;GASG;AACH;IA6FI;;;;;;OAMG;IACH;QAL0C,UAAU,EAAzC,qBAAqB;QACF,MAAM;QACR,KAAK,GAAtB,MAAM;QACW,uBAAuB,GAAxC,MAAM;OAkJhB;IAlPD;;;OAGG;IACH,YAFU,qBAAqB,CAEpB;IAEX;;;;OAIG;IACH,QAFU,oBAAe,CAElB;IASP;;;OAGG;IACH,kBAAO;IAmDP;;OAEG;IACH,8BAEC;IAED;;;;OAIG;IACH,oBAEC;IA2JD;;;;;OAKG;IACH,UAHW,MAAM,GACJ,qBAAc,SAAS,CAUnC;IAGD;;;;;;;;;;;OAWG;IACH,oCAcC;IAED;;;;;OAKG;IACH,gCAEC;IAoPD;;;;;;;;;;;OAWG;IACH,kCAeC;IAED;;;OAGG;IACH,gBAFW,sBAAsB,QA6FhC;IA+OD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IACH,2BAJW,MAAM,GACJ,QAAQ,KAAG,CAAC,CA6HxB;IAED;;;;;;;OAOG;IACH,+BAJW,MAAM,iBACN,MAAM,GACJ,YAAU,CAkCtB;IAED;;;OAGG;IACH,+BAQC;IAED;;OAEG;IACH,gBASC;;CACJ;qCAxoCY,OAAO,2CAA2C,EAAE,sBAAsB;oCAC1E,OAAO,4BAA4B,EAAE,qBAAqB;8BANzC,oBAAoB;oCALd,0BAA0B"}
+{"version":3,"file":"GPUDatabase.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/buffer/table/GPUDatabase.js"],"names":[],"mappings":"AA4CA;;;;;;;;;GASG;AACH;IAEI;;;;OAIG;IACH,iCAFW,eAAe,QAKzB;IA8FD;;;;;;OAMG;IACH;QAL0C,UAAU,EAAzC,qBAAqB;QACF,MAAM;QACR,KAAK,GAAtB,MAAM;QACW,uBAAuB,GAAxC,MAAM;OAkJhB;IAlPD;;;OAGG;IACH,YAFU,qBAAqB,CAEpB;IAEX;;;;OAIG;IACH,QAFU,oBAAe,CAElB;IASP;;;OAGG;IACH,kBAAO;IAmDP;;OAEG;IACH,8BAEC;IAED;;;;OAIG;IACH,oBAEC;IA2JD;;;;;OAKG;IACH,UAHW,MAAM,GACJ,qBAAc,SAAS,CAUnC;IAGD;;;;;;;;;;;OAWG;IACH,oCAcC;IAED;;;;;OAKG;IACH,gCAEC;IAoPD;;;;;;;;;;;OAWG;IACH,kCAeC;IAED;;;OAGG;IACH,gBAFW,sBAAsB,QA6FhC;IA+OD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IACH,2BAJW,MAAM,GACJ,QAAQ,KAAG,CAAC,CA6HxB;IAED;;;;;;;OAOG;IACH,+BAJW,MAAM,iBACN,MAAM,GACJ,YAAU,CAkCtB;IAED;;;OAGG;IACH,+BAQC;IAED;;OAEG;IACH,gBASC;;CACJ;8BAppCY,OAAO,6CAA6C,EAAE,eAAe;qCACrE,OAAO,2CAA2C,EAAE,sBAAsB;oCAC1E,OAAO,4BAA4B,EAAE,qBAAqB;8BAPzC,oBAAoB;oCALd,0BAA0B"}