@woosh/meep-engine 3.63.2 → 3.64.0

package/src/shade/device/mock/SoftwareGPUCommandEncoder.d.ts

@@ -30,6 +30,23 @@ export class SoftwareGPUCommandEncoder extends SoftwareGPUObjectBase implements
      * @type {(SoftwareGPUComputePassEncoder|SoftwareGPURenderPassEncoder)[]}
      */
     passes: (SoftwareGPUComputePassEncoder | SoftwareGPURenderPassEncoder)[];
+    /**
+     * Everything encoded on this encoder, in the order it was encoded: each pass begun and each copy,
+     * clear and query resolve the encoder accepted. A device runs them in this order, so what one
+     * command finds in a buffer depends on where it sits among the rest — which {@link passes} alone
+     * cannot show for a pass and a copy or clear around it.
+     *
+     * Each entry names its method and carries that call's arguments, with any size the caller left
+     * out filled in:
+     * - `{ method: 'beginComputePass' | 'beginRenderPass', pass }`
+     * - `{ method: 'copyBufferToBuffer', source, source_offset, destination, destination_offset, size }`
+     * - `{ method: 'clearBuffer', buffer, offset, size }`
+     * - `{ method: 'copyTextureToTexture' | 'copyBufferToTexture' | 'copyTextureToBuffer', source, destination, size }`
+     * - `{ method: 'resolveQuerySet', query_set, first_query, query_count, destination, destination_offset }`
+     *
+     * @type {Object[]}
+     */
+    operations: any[];
     finish(): SoftwareGPUCommandBuffer;
     /**
      * Called by a pass this encoder opened, when that pass ends. Releases the lock.

package/src/shade/device/mock/SoftwareGPUCommandEncoder.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SoftwareGPUCommandEncoder.d.ts","sourceRoot":"","sources":["../../../../../src/shade/device/mock/SoftwareGPUCommandEncoder.js"],"names":[],"mappings":"AAgGA;;;;GAIG;AACH,gFAFgB,iBAAiB;IA+D7B;;;;OAIG;IACH,iFAIC;IAzDD;;;;OAIG;IACH,gBAFU,6BAA6B,EAAE,CAErB;IAEpB;;;;OAIG;IACH,eAFU,4BAA4B,EAAE,CAErB;IAEnB;;;;;;OAMG;IACH,QAFU,CAAC,6BAA6B,GAAC,4BAA4B,CAAC,EAAE,CAE5D;IA0EZ,mCAiBC;IAqBD;;;;;OAKG;IACH,wBAHW,6BAA6B,GAAC,4BAA4B,GACxD,IAAI,CAMhB;IAED;;;;;OAKG;IACH,gCAEC;IAED;;;;;;;;;OASG;IACH,sCAHW,MAAM,GACJ,IAAI,CAIhB;IAED;;;;;;;OAOG;IACH,+EAeC;IAED;;;;;;;;;;;;;OAaG;IACH,4BAHW,CAAC,sCAAoC,CAAC,EAAE,GACtC,IAAI,CAUhB;IAkBD;;;;;;;OAOG;IACH,4EAmCC;IAED;;;;;;;;OAQG;IACH,oHAFa,IAAI,CAuBhB;IAED;;;;;OAKG;IACH,kHAFa,IAAI,CAuBhB;IAED;;;;;OAKG;IACH,kHAFa,IAAI,CAuBhB;IAED;;;;;;;;;OASG;IACH,2DANW,MAAM,cACN,MAAM,qDAEN,MAAM,GACJ,IAAI,CAwBhB;IAwCD;;;;OAIG;IACH,sBAFW,MAAM,QAIhB;IAED,sBAEC;IAED;;OAEG;IACH,yBAFW,MAAM,QAIhB;IAyED;;;;;;;;OAQG;IACH,4DANW,MAAM,qDAEN,MAAM,QACN,MAAM,GACJ,IAAI,CAgChB;IAED;;;;;;;OAOG;IACH,gDAJW,MAAM,SACN,MAAM,GACJ,IAAI,CA6BhB;IAGL;;;OAGG;IACH,sCAFU,OAAO,CAE8C;;CAN9D;sCA/sBqC,4BAA4B;8CAFpB,oCAAoC;6CAGrC,mCAAmC;yCAJvC,+BAA+B"}
+{"version":3,"file":"SoftwareGPUCommandEncoder.d.ts","sourceRoot":"","sources":["../../../../../src/shade/device/mock/SoftwareGPUCommandEncoder.js"],"names":[],"mappings":"AAgGA;;;;GAIG;AACH,gFAFgB,iBAAiB;IAiF7B;;;;OAIG;IACH,iFAIC;IA3ED;;;;OAIG;IACH,gBAFU,6BAA6B,EAAE,CAErB;IAEpB;;;;OAIG;IACH,eAFU,4BAA4B,EAAE,CAErB;IAEnB;;;;;;OAMG;IACH,QAFU,CAAC,6BAA6B,GAAC,4BAA4B,CAAC,EAAE,CAE5D;IAEZ;;;;;;;;;;;;;;;OAeG;IACH,YAFU,KAAQ,CAEF;IA0EhB,mCAiBC;IAqBD;;;;;OAKG;IACH,wBAHW,6BAA6B,GAAC,4BAA4B,GACxD,IAAI,CAMhB;IAED;;;;;OAKG;IACH,gCAEC;IAED;;;;;;;;;OASG;IACH,sCAHW,MAAM,GACJ,IAAI,CAIhB;IAED;;;;;;;OAOG;IACH,+EAgBC;IAED;;;;;;;;;;;;;OAaG;IACH,4BAHW,CAAC,sCAAoC,CAAC,EAAE,GACtC,IAAI,CAUhB;IAkBD;;;;;;;OAOG;IACH,4EAoCC;IAED;;;;;;;;OAQG;IACH,oHAFa,IAAI,CAyBhB;IAED;;;;;OAKG;IACH,kHAFa,IAAI,CAyBhB;IAED;;;;;OAKG;IACH,kHAFa,IAAI,CAyBhB;IAED;;;;;;;;;OASG;IACH,2DANW,MAAM,cACN,MAAM,qDAEN,MAAM,GACJ,IAAI,CAiChB;IAwCD;;;;OAIG;IACH,sBAFW,MAAM,QAIhB;IAED,sBAEC;IAED;;OAEG;IACH,yBAFW,MAAM,QAIhB;IAyED;;;;;;;;OAQG;IACH,4DANW,MAAM,qDAEN,MAAM,QACN,MAAM,GACJ,IAAI,CAyChB;IAED;;;;;;;OAOG;IACH,gDAJW,MAAM,SACN,MAAM,GACJ,IAAI,CA+BhB;IAGL;;;OAGG;IACH,sCAFU,OAAO,CAE8C;;CAN9D;sCA7vBqC,4BAA4B;8CAFpB,oCAAoC;6CAGrC,mCAAmC;yCAJvC,+BAA+B"}

package/src/shade/device/mock/SoftwareGPUCommandEncoder.js

@@ -135,6 +135,24 @@ export class SoftwareGPUCommandEncoder extends SoftwareGPUObjectBase {
      */
     passes = [];
 
+    /**
+     * Everything encoded on this encoder, in the order it was encoded: each pass begun and each copy,
+     * clear and query resolve the encoder accepted. A device runs them in this order, so what one
+     * command finds in a buffer depends on where it sits among the rest — which {@link passes} alone
+     * cannot show for a pass and a copy or clear around it.
+     *
+     * Each entry names its method and carries that call's arguments, with any size the caller left
+     * out filled in:
+     * - `{ method: 'beginComputePass' | 'beginRenderPass', pass }`
+     * - `{ method: 'copyBufferToBuffer', source, source_offset, destination, destination_offset, size }`
+     * - `{ method: 'clearBuffer', buffer, offset, size }`
+     * - `{ method: 'copyTextureToTexture' | 'copyBufferToTexture' | 'copyTextureToBuffer', source, destination, size }`
+     * - `{ method: 'resolveQuerySet', query_set, first_query, query_count, destination, destination_offset }`
+     *
+     * @type {Object[]}
+     */
+    operations = [];
+
     /**
      * The pass currently open on this encoder, `null` when none is.
      *
@@ -302,6 +320,7 @@ export class SoftwareGPUCommandEncoder extends SoftwareGPUObjectBase {
 
         this.compute_passes.push(pass);
         this.passes.push(pass);
+        this.operations.push({ method: 'beginComputePass', pass });
 
         return pass;
     }
@@ -387,6 +406,7 @@ export class SoftwareGPUCommandEncoder extends SoftwareGPUObjectBase {
 
         this.render_passes.push(pass);
         this.passes.push(pass);
+        this.operations.push({ method: 'beginRenderPass', pass });
 
         return pass;
     }
@@ -421,6 +441,8 @@ export class SoftwareGPUCommandEncoder extends SoftwareGPUObjectBase {
                 texture_copy_execute({ texture_source: source, texture_destination: destination, size: copySize });
             }
         });
+
+        this.operations.push({ method: 'copyTextureToTexture', source, destination, size: copySize });
     }
 
     /**
@@ -450,6 +472,8 @@ export class SoftwareGPUCommandEncoder extends SoftwareGPUObjectBase {
                 texture_copy_execute({ buffer_source: source, texture_destination: destination, size: copySize });
             }
         });
+
+        this.operations.push({ method: 'copyBufferToTexture', source, destination, size: copySize });
     }
 
     /**
@@ -479,6 +503,8 @@ export class SoftwareGPUCommandEncoder extends SoftwareGPUObjectBase {
                 texture_copy_execute({ texture_source: source, buffer_destination: destination, size: copySize });
             }
         });
+
+        this.operations.push({ method: 'copyTextureToBuffer', source, destination, size: copySize });
     }
 
     /**
@@ -513,6 +539,15 @@ export class SoftwareGPUCommandEncoder extends SoftwareGPUObjectBase {
                     .set(querySet.read(firstQuery, queryCount));
             }
         });
+
+        this.operations.push({
+            method: 'resolveQuerySet',
+            query_set: querySet,
+            first_query: firstQuery,
+            query_count: queryCount,
+            destination,
+            destination_offset: destinationOffset,
+        });
     }
 
     /**
@@ -683,6 +718,15 @@ export class SoftwareGPUCommandEncoder extends SoftwareGPUObjectBase {
                 array_buffer_copy(source.data, sourceOffset, destination.data, destinationOffset, _size);
             }
         });
+
+        this.operations.push({
+            method: 'copyBufferToBuffer',
+            source,
+            source_offset: sourceOffset,
+            destination,
+            destination_offset: destinationOffset,
+            size: _size,
+        });
     }
 
     /**
@@ -720,6 +764,8 @@ export class SoftwareGPUCommandEncoder extends SoftwareGPUObjectBase {
                 new Uint8Array(buffer.data, offset, clear_size).fill(0);
             }
         });
+
+        this.operations.push({ method: 'clearBuffer', buffer, offset, size: clear_size });
     }
 }
 

package/src/shade/playground/tonemap_sdr/README.md

@@ -1,14 +1,17 @@
 # Tone mapping: GT7 and PBR Neutral, SDR and HDR
 
-The renderer has four tone mapping modes, each one choice for every output (`ShadeToneMappingMode`):
+The renderer's `ToneMapper` has four built-in operators, each one choice for every output (`renderer.tone_mapper.operator`):
 
-- `ACES`, the default: Unreal Engine's look;
-- `GT7`;
-- `PBR_NEUTRAL`;
-- `NONE`.
+- `TONE_MAP_OPERATOR_ACES`, the default: Unreal Engine's look;
+- `TONE_MAP_OPERATOR_GT7`;
+- `TONE_MAP_OPERATOR_PBR_NEUTRAL`;
+- `TONE_MAP_OPERATOR_NONE`.
+
+The tone mapper bakes the operator into a 3D LUT per output and draws through it; this page evaluates the operators
+directly.
 
 This page compares GT7 and PBR Neutral, and shows each one's HDR form beside its SDR form. ACES is not one of its
-views; the engine's own canvas shows it, and `shader_tonemap_aces.spec.js` holds it to Unreal's and OpenColorIO's numbers.
+views; the engine's own canvas shows it, and `TONE_MAP_OPERATOR_ACES.spec.js` holds it to Unreal's and OpenColorIO's numbers.
 
 The engine renders and tonemaps each frame as usual. Two extensions then redraw the canvas from the HDR colour the
 tonemapper was given:
@@ -16,8 +19,8 @@ tonemapper was given:
 | | operator | source |
 |---|---|---|
 | 1 | GT7, Polyphony's sample | `chunk_tonemap_gt7_sdr_reference.js` beside this page: the sample code's `initializeAsSDR()`, SDR only |
-| 2 | GT7, engine | `tonemap_gt7_rec2020` at `PAPER_WHITE_NITS · peak` and `PAPER_WHITE_NITS`, back in Rec.709, what `ShadeToneMappingMode.GT7` runs |
-| 3 | PBR Neutral, engine | `tonemap_khronos_pbr(c, peak)`, what `ShadeToneMappingMode.PBR_NEUTRAL` runs; at peak 1 the Khronos specification |
+| 2 | GT7, engine | `tonemap_gt7_rec2020` at `PAPER_WHITE_NITS · peak` and `PAPER_WHITE_NITS`, back in Rec.709, what `TONE_MAP_OPERATOR_GT7` runs |
+| 3 | PBR Neutral, engine | `tonemap_khronos_pbr(c, peak)`, what `TONE_MAP_OPERATOR_PBR_NEUTRAL` runs; at peak 1 the Khronos specification |
 
 All of them see the same input. Exposure is the page's own and fixed per scene, with the engine's automatic exposure off.
 

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

@@ -35,11 +35,11 @@ export const CompareOperator = {
     GT7Reference: 0,
     /**
      * the engine's `tonemap_gt7` with the paper white at `PAPER_WHITE_NITS` and the peak at the headroom times that:
-     * what `ShadeToneMappingMode.GT7` runs
+     * what `TONE_MAP_OPERATOR_GT7` runs
      */
     GT7: 1,
     /**
-     * the engine's `tonemap_khronos_pbr` at the headroom: what `ShadeToneMappingMode.PBR_NEUTRAL` runs, and at
+     * the engine's `tonemap_khronos_pbr` at the headroom: what `TONE_MAP_OPERATOR_PBR_NEUTRAL` runs, and at
      * headroom 1 the Khronos specification
      */
     PBRNeutral: 2,

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

@@ -54,12 +54,11 @@ export class Renderer {
      */
     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}. ACES, Unreal's default look, unless set. 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}
+     * How the exposed scene colour becomes display colour, on every output: its operator, the resolution of its LUTs,
+     * and LUTs of the user's own. Made by {@link initialize}.
+     * @type {ToneMapper}
      */
-    tone_mapping_mode: ShadeToneMappingMode;
+    tone_mapper: ToneMapper;
     /**
      * Switches of the AVBOIT mode, read every frame while {@link transparency_mode} selects it.
      * @type {AVBOITSettings}
@@ -579,7 +578,7 @@ import { ShadeIndirectLightingMode } from "./ShadeIndirectLightingMode.js";
 import { MaterialDispatch } from "./material/dispatch/MaterialDispatch.js";
 import { ProbeClipmapSettings } from "./global_illumination/probe_clipmap/ProbeClipmapSettings.js";
 import { ShadeTransparencyMode } from "./ShadeTransparencyMode.js";
-import { ShadeToneMappingMode } from "./ShadeToneMappingMode.js";
+import { ToneMapper } from "./deferred/tonemap/ToneMapper.js";
 import { AVBOITSettings } from "./rasterize/native/avboit/AVBOITSettings.js";
 import { ShaderSwitchSet } from "./shader/compiler/ShaderSwitchSet.js";
 import { MotionBlur } from "./postprocess/motion_blur/MotionBlur.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

@@ -22,16 +22,7 @@ import { shader_composite_volumetrics } from "./deferred/shader_composite_volume
 import { shader_deferred_main } from "./deferred/shader_deferred_main.js";
 import { LOCAL_LIGHT_SHADING } from "./deferred/LOCAL_LIGHT_SHADING.js";
 import { LocalLightShading } from "./deferred/LocalLightShading.js";
-import { shader_tonemap_HDR } from "./deferred/tonemap/shader_tonemap_HDR.js";
-import { shader_tonemap_HDR_aces } from "./deferred/tonemap/shader_tonemap_HDR_aces.js";
-import { shader_tonemap_HDR_none } from "./deferred/tonemap/shader_tonemap_HDR_none.js";
-import { shader_tonemap_HDR_pbr_neutral } from "./deferred/tonemap/shader_tonemap_HDR_pbr_neutral.js";
-import { shader_tonemap_LDR } from "./deferred/tonemap/shader_tonemap_LDR.js";
-import { shader_tonemap_LDR_aces } from "./deferred/tonemap/shader_tonemap_LDR_aces.js";
-import { shader_tonemap_LDR_none } from "./deferred/tonemap/shader_tonemap_LDR_none.js";
-import { shader_tonemap_LDR_pbr_neutral } from "./deferred/tonemap/shader_tonemap_LDR_pbr_neutral.js";
-import { TonemapAces2Tables } from "./deferred/tonemap/TonemapAces2Tables.js";
-import { TonemapDisplaySettings } from "./deferred/tonemap/TonemapDisplaySettings.js";
+import { ToneMapper } from "./deferred/tonemap/ToneMapper.js";
 import { FrameContext } from "./extension/FrameContext.js";
 import { FramePhase } from "./extension/FramePhase.js";
 import { GBufferTextures } from "./extension/GBufferTextures.js";
@@ -102,7 +93,6 @@ import { GPUParticleSystem } from "./particles/GPUParticleSystem.js";
 import { SceneManager } from "./scene/SceneManager.js";
 import { ShadeIndirectLightingMode } from "./ShadeIndirectLightingMode.js";
 import { MaterialDispatch } from "./material/dispatch/MaterialDispatch.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";
@@ -264,12 +254,11 @@ 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}. ACES, Unreal's default look, unless set. 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}
+     * How the exposed scene colour becomes display colour, on every output: its operator, the resolution of its LUTs,
+     * and LUTs of the user's own. Made by {@link initialize}.
+     * @type {ToneMapper}
      */
-    tone_mapping_mode = ShadeToneMappingMode.ACES;
+    tone_mapper;
 
     /**
      * Switches of the AVBOIT mode, read every frame while {@link transparency_mode} selects it.
@@ -1651,21 +1640,6 @@ export class Renderer {
 
     #hdr_supported = false;
 
-    /**
-     * What every tonemap pass is told about the display: the primaries the canvas was actually configured with, and
-     * the peak brightness, which only the HDR passes read.
-     *
-     * @type {TonemapDisplaySettings}
-     */
-    #tonemap_settings = new TonemapDisplaySettings();
-
-    /**
-     * The ACES HDR pass's two output transforms, built for the display in {@link #tonemap_settings}.
-     *
-     * @type {TonemapAces2Tables}
-     */
-    #tonemap_aces2_tables = new TonemapAces2Tables();
-
     #update_presentation_format() {
 
         const format8bit = navigator.gpu.getPreferredCanvasFormat();
@@ -1690,16 +1664,9 @@ export class Renderer {
         const previous_value = this.#hdr_supported;
 
 
+        // the browser has no way to report the display's peak, so the tone mapper keeps its assumption
         this.#hdr_supported = isHDR;
 
-        if (isHDR) {
-            // Currently, there is no way to interrogate this from the browser, so going with an assumption
-            this.#tonemap_settings.peak_nits = 1000;
-        } else {
-            // Assume SDR nits
-            this.#tonemap_settings.peak_nits = 80;
-        }
-
         if (isHDR === previous_value) {
             // no change
             return;
@@ -1842,6 +1809,8 @@ export class Renderer {
         this.context = context;
         this.device = device;
 
+        this.tone_mapper = new ToneMapper(device);
+
         this.#pixel_ratio = pixelRatio;
 
         // clientWidth/clientHeight are 0 for a canvas that is not attached to the DOM,
@@ -2014,31 +1983,7 @@ export class Renderer {
 
         this.#extensions.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.ACES) {
-            return this.#hdr_supported ? shader_tonemap_HDR_aces : shader_tonemap_LDR_aces;
-        }
-
-        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;
+        this.tone_mapper.enquire_pipelines(enquiry, this.#hdr_supported, this.#presentation_format);
     }
 
     /**
@@ -2115,7 +2060,7 @@ export class Renderer {
         this.#scene_sdfs.clear();
 
         this.#autoexposure?.destroy();
-        this.#tonemap_aces2_tables.destroy();
+        this.tone_mapper?.destroy();
         this.#depth_of_field?.destroy();
         this.#depth_of_field_unreal?.destroy();
         this.#restir_di?.destroy();
@@ -2242,7 +2187,7 @@ export class Renderer {
             configured_color_space = configuration.colorSpace ?? 'srgb';
         }
 
-        this.#tonemap_settings.set_canvas_color_space(configured_color_space);
+        this.tone_mapper.display.set_canvas_color_space(configured_color_space);
     }
 
     #apply_size() {
@@ -3525,30 +3470,12 @@ export class Renderer {
 
         current_color_out = record_scene_color.color;
 
-        const tonemap_shader = this.#tonemap_shader();
-
-        // every pass reads from the settings only the members its immediate struct names: the canvas's primaries
-        // from its working space, and, on an HDR display, the peak
-        const tonemap_inputs = {
+        current_color_out = this.tone_mapper.render({
+            graph,
             input_color: current_color_out,
-            settings: this.#tonemap_settings,
             exposure,
-        };
-
-        if (tonemap_shader === shader_tonemap_HDR_aces) {
-            // the two ACES 2.0 transforms for this display, rebuilt only when the display changed
-            const display = this.#tonemap_settings;
-            const tables = this.#tonemap_aces2_tables;
-
-            tables.update(display.peak_nits);
-            tonemap_inputs.aces2_tables = graph_import_buffer(graph, tables.gpu_buffer(this.device), "tonemap/aces2 tables");
-        }
-
-        [current_color_out] = graph_image_pass({
-            graph,
-            shader: tonemap_shader,
-            inputs: tonemap_inputs,
-            output: [gr_texture_canvas]
+            hdr: this.#hdr_supported,
+            target: gr_texture_canvas,
         });
 
         /*

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

@@ -0,0 +1,14 @@
+/**
+ * `animation_curve_evaluate_keys(keys, first, count, time)`: one curve at `time`, as `AnimationCurve.evaluate`
+ * evaluates it, from a run of `count` keyframes of a plain storage array, `first` onwards, in ascending time order.
+ * `count` is at least 1.
+ *
+ * The same answer as {@link chunk_animation_curve_evaluate}, which reads its keyframes from the animation database:
+ * the first key's value at or before the first key, the last key's at or past the last, and between them the Hermite
+ * piece from the last key at or before `time`, so two keys at one time are a step there. ⌈log2(count - 1)⌉ probes.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_animation_curve_evaluate_keys: CodeChunk;
+import { CodeChunk } from "../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_animation_curve_evaluate_keys.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_animation_curve_evaluate_keys.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/animation/chunk_animation_curve_evaluate_keys.js"],"names":[],"mappings":"AAKA;;;;;;;;;;GAUG;AACH,kDAFU,SAAS,CA+CjB;0BA5DwB,iCAAiC"}

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

@@ -0,0 +1,62 @@
+import { chunk_inverse_lerp } from "../shader/chunk/math/chunk_inverse_lerp.js";
+import { CodeChunk } from "../shader/compiler/CodeChunk.js";
+import { ANIMATION_CURVE_KEYFRAME_STRUCT } from "./ANIMATION_CURVE_KEYFRAME_STRUCT.js";
+import { chunk_animation_curve_evaluate_piece } from "./chunk_animation_curve_evaluate_piece.js";
+
+/**
+ * `animation_curve_evaluate_keys(keys, first, count, time)`: one curve at `time`, as `AnimationCurve.evaluate`
+ * evaluates it, from a run of `count` keyframes of a plain storage array, `first` onwards, in ascending time order.
+ * `count` is at least 1.
+ *
+ * The same answer as {@link chunk_animation_curve_evaluate}, which reads its keyframes from the animation database:
+ * the first key's value at or before the first key, the last key's at or past the last, and between them the Hermite
+ * piece from the last key at or before `time`, so two keys at one time are a step there. ⌈log2(count - 1)⌉ probes.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_animation_curve_evaluate_keys = CodeChunk.from(
+    //language=WGSL
+    `
+fn animation_curve_evaluate_keys(
+    keys: ptr<storage, array<${ANIMATION_CURVE_KEYFRAME_STRUCT.wgsl_ref}>, read>,
+    first: u32,
+    count: u32,
+    time: f32,
+) -> f32 {
+    if (count <= 1u || time <= (*keys)[first].time) {
+        return (*keys)[first].value;
+    }
+
+    let last = first + count - 1u;
+
+    if (time >= (*keys)[last].time) {
+        return (*keys)[last].value;
+    }
+
+    // time(lo) <= time < time(hi), closed in until they are neighbours
+    var lo = first;
+    var hi = last;
+
+    loop {
+        if (hi - lo <= 1u) { break; }
+
+        let mid = lo + ((hi - lo) >> 1u);
+
+        if ((*keys)[mid].time <= time) {
+            lo = mid;
+        } else {
+            hi = mid;
+        }
+    }
+
+    let key0 = (*keys)[lo];
+    let key1 = (*keys)[hi];
+
+    return animation_curve_evaluate_piece(inverse_lerp(key0.time, key1.time, time), key0, key1);
+}
+    `, [
+        ANIMATION_CURVE_KEYFRAME_STRUCT.declaration_chunk,
+        chunk_animation_curve_evaluate_piece,
+        chunk_inverse_lerp,
+    ]
+);

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

@@ -7,6 +7,18 @@
  * Note: GPU and CPU-side states are allowed to diverge but must eventually be synchronized.
  * This means that a modification on one side must propagate to the other.
  * see "Rendering 'Assassin's Creed Shadows'" GDC 2025 by Nicolas Lopez
+ *
+ * **What a row nobody occupies reads as on the GPU.** A shader may read a row by its index without
+ * asking the page's occupancy bitmap. To GPU work encoded after {@link update} on the same encoder:
+ * - a row of a page that has no slot reads as a record of zeros: the generated readers refuse it;
+ * - a row nothing has written, on a page that has a slot, reads as zeros too: a page's records are
+ *   cleared when it is given a slot, whichever page of whichever table held that slot before;
+ * - a row freed with {@link GPUTypedTable#remove} reads as the freed record: zeros, with
+ *   `GPU_DATABASE_NULL` in its link words and in the first word of its ranges.
+ *
+ * So a link word of an unoccupied row holds 0 or NULL depending on the row's history, and a reader
+ * that skips occupancy must not follow one. {@link GPUTypedTable#clear} sends nothing, so the rows it
+ * frees keep their last record on a page that stays allocated.
  */
 export class GPUDatabase {
     /**

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":"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;IAkPD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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;8BAvpCY,OAAO,6CAA6C,EAAE,eAAe;qCACrE,OAAO,2CAA2C,EAAE,sBAAsB;oCAC1E,OAAO,4BAA4B,EAAE,qBAAqB;8BAPzC,oBAAoB;oCALd,0BAA0B"}
+{"version":3,"file":"GPUDatabase.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/buffer/table/GPUDatabase.js"],"names":[],"mappings":"AA4CA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH;IAEI;;;;OAIG;IACH,iCAFW,eAAe,QAKzB;IA8GD;;;;;;OAMG;IACH;QAL0C,UAAU,EAAzC,qBAAqB;QACF,MAAM;QACR,KAAK,GAAtB,MAAM;QACW,uBAAuB,GAAxC,MAAM;OAkJhB;IAlQD;;;OAGG;IACH,YAFU,qBAAqB,CAEpB;IAEX;;;;OAIG;IACH,QAFU,oBAAe,CAElB;IASP;;;OAGG;IACH,kBAAO;IAmEP;;OAEG;IACH,8BAEC;IAED;;;;OAIG;IACH,oBAEC;IA2JD;;;;;OAKG;IACH,UAHW,MAAM,GACJ,qBAAc,SAAS,CAUnC;IAGD;;;;;;;;;;;OAWG;IACH,oCAcC;IAED;;;;;OAKG;IACH,gCAEC;IA4PD;;;;;;;;;;;OAWG;IACH,kCAeC;IAED;;;OAGG;IACH,gBAFW,sBAAsB,QAgGhC;IAgSD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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;8BA5uCY,OAAO,6CAA6C,EAAE,eAAe;qCACrE,OAAO,2CAA2C,EAAE,sBAAsB;oCAC1E,OAAO,4BAA4B,EAAE,qBAAqB;8BAPzC,oBAAoB;oCALd,0BAA0B"}

package/src/shade/renderer/buffer/table/GPUDatabase.js

@@ -51,6 +51,18 @@ const UPLOAD_CHUNK_SIZE = 256 * KILOBYTE;
  * Note: GPU and CPU-side states are allowed to diverge but must eventually be synchronized.
  * This means that a modification on one side must propagate to the other.
  * see "Rendering 'Assassin's Creed Shadows'" GDC 2025 by Nicolas Lopez
+ *
+ * **What a row nobody occupies reads as on the GPU.** A shader may read a row by its index without
+ * asking the page's occupancy bitmap. To GPU work encoded after {@link update} on the same encoder:
+ * - a row of a page that has no slot reads as a record of zeros: the generated readers refuse it;
+ * - a row nothing has written, on a page that has a slot, reads as zeros too: a page's records are
+ *   cleared when it is given a slot, whichever page of whichever table held that slot before;
+ * - a row freed with {@link GPUTypedTable#remove} reads as the freed record: zeros, with
+ *   `GPU_DATABASE_NULL` in its link words and in the first word of its ranges.
+ *
+ * So a link word of an unoccupied row holds 0 or NULL depending on the row's history, and a reader
+ * that skips occupancy must not follow one. {@link GPUTypedTable#clear} sends nothing, so the rows it
+ * frees keep their last record on a page that stays allocated.
  */
 export class GPUDatabase {
 
@@ -130,6 +142,22 @@ export class GPUDatabase {
      */
     #page_buffer_pool;
 
+    /**
+     * The pages given a slot since {@link #clear_new_page_records} last ran, each after its table,
+     * flattened as `[table, page, table, page, …]` over the first {@link #pages_given_slots_length}
+     * entries. Entries past that are `null`. The array is never shortened, so it keeps its storage
+     * from one update to the next.
+     *
+     * @type {Array<GPUTypedTable|GPUPageMetadata|null>}
+     */
+    #pages_given_slots = [];
+
+    /**
+     * How many entries of {@link #pages_given_slots} are live: twice the number of pages.
+     * @type {number}
+     */
+    #pages_given_slots_length = 0;
+
     /**
      * Batched row readback, built on first use.
      *
@@ -557,6 +585,14 @@ export class GPUDatabase {
 
         page.slot_offset = slot_offset;
 
+        const given = this.#pages_given_slots;
+        const given_length = this.#pages_given_slots_length;
+
+        given[given_length] = table;
+        given[given_length + 1] = page;
+
+        this.#pages_given_slots_length = given_length + 2;
+
         const alloc_idx = table.descriptor.page_lookup_address + page_index;
 
         this.#allocation_table[alloc_idx] = slot_offset + this.#data_start_offset;
@@ -675,6 +711,9 @@ export class GPUDatabase {
             this.#deallocate_empty_pages(table);
         }
 
+        // after every page has its slot, and before the record uploads that land on top
+        this.#clear_new_page_records(encoder);
+
         // update allocation table — only the dirty range
         if (this.#alloc_table_dirty_min <= this.#alloc_table_dirty_max) {
             const min_byte = this.#alloc_table_dirty_min * Uint32Array.BYTES_PER_ELEMENT;
@@ -732,6 +771,52 @@ export class GPUDatabase {
         }
     }
 
+    /**
+     * Clear the records of every page given a slot since this last ran, so that a row nothing has
+     * written reads as a record of zeros and not as whatever the slot's previous page, of this table
+     * or any other, left there. See the class documentation for what an unoccupied row reads as.
+     *
+     * Called once every page has its slot: growing the buffer moves pages to new slots, so a clear
+     * encoded before the move would land in the buffer being replaced. The header is left alone
+     * because it goes up through the queue, and a queue write lands ahead of the whole submission —
+     * a clear over it would erase it. The record uploads, encoded after this, land on top.
+     *
+     * @param {ShadeGPUCommandContext} encoder
+     */
+    #clear_new_page_records(encoder) {
+        const pages = this.#pages_given_slots;
+        const length = this.#pages_given_slots_length;
+
+        if (length === 0) {
+            return;
+        }
+
+        const word_size = GPU_DATABASE_BUFFER_ELEMENT_TYPE.size;
+        const data_start = this.#data_start_offset;
+
+        for (let i = 0; i < length; i += 2) {
+            const descriptor = /** @type {GPUTypedTable} */ (pages[i]).descriptor;
+            const slot_offset = /** @type {GPUPageMetadata} */ (pages[i + 1]).slot_offset;
+
+            // let go of both, so a freed page is not kept alive by the list
+            pages[i] = null;
+            pages[i + 1] = null;
+
+            if (slot_offset === -1) {
+                // emptied in the same update, and its slot already given back
+                continue;
+            }
+
+            encoder.clearBuffer(
+                this.buffer,
+                (slot_offset + data_start + descriptor.page_header_words) * word_size,
+                descriptor.elements_per_page * descriptor.packed_element_size_bytes
+            );
+        }
+
+        this.#pages_given_slots_length = 0;
+    }
+
     /**
      * Dispatch a table's pending whole-record writes, chunked so no single transient buffer grows
      * past {@link UPLOAD_CHUNK_SIZE}. Rewinds the buffer.

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

@@ -48,7 +48,8 @@ export class GPUDatabaseDefinition {
      * it into every link word the row has, whatever `nullable` says, because a freed row points
      * nowhere; a new page starts with it in every link word too. So a link no write has touched names
      * no row, on a row never written as on one freed, and a value that leaves a link out leaves it
-     * naming nothing.
+     * naming nothing. That holds on the GPU for every occupied row and every freed one; a row the GPU
+     * has never been sent reads 0 there instead (see {@link GPUDatabase}).
      *
      * `owning` means one thing: removing the row that holds the link removes the row it names, and
      * that row's owned rows in turn ({@link GPUTypedTable#remove}). Nothing else follows it.