@woosh/meep-engine 3.51.0 → 3.52.0

package/package.json

@@ -6,7 +6,7 @@
   "description": "Advanced 3D game engine",
   "type": "module",
   "author": "Alexander Goldring",
-  "version": "3.51.0",
+  "version": "3.52.0",
   "exports": {
     "./build/*": "./build/*",
     "./src/*": "./src/*",

package/src/engine/physics/fluid/ecs/FluidObstacleSystem.d.ts

@@ -66,11 +66,11 @@ export class FluidObstacleSystem extends System<any> {
     /**
      * @param {FluidComponent} fluid
      */
-    static "__#461@#refresh_masks"(fluid: FluidComponent): void;
+    static "__#462@#refresh_masks"(fluid: FluidComponent): void;
     /**
      * @param {FluidComponent} fluid
      */
-    static "__#461@#clear_field"(fluid: FluidComponent): void;
+    static "__#462@#clear_field"(fluid: FluidComponent): void;
     /**
      * Mark every cell of `fluid` whose centre lies within `inflation` of the
      * posed shape as solid. Iteration is clipped to the shape's world AABB
@@ -82,7 +82,7 @@ export class FluidObstacleSystem extends System<any> {
      * @param {number} inflation       world-units SDF threshold
      * @param {Float64Array} point     length-3 scratch
      */
-    static "__#461@#voxelize"(fluid: FluidComponent, posed: PosedShape3D, aabb: Float64Array, inflation: number, point: Float64Array): void;
+    static "__#462@#voxelize"(fluid: FluidComponent, posed: PosedShape3D, aabb: Float64Array, inflation: number, point: Float64Array): void;
     /**
      * Write the obstacle's translation velocity onto every face of every cell
      * it voxelized — the moving-wall boundary condition. Runs AFTER the mask
@@ -102,7 +102,7 @@ export class FluidObstacleSystem extends System<any> {
      * @param {number} wvy
      * @param {number} wvz
      */
-    static "__#461@#stamp_wall_velocity"(fluid: FluidComponent, posed: PosedShape3D, aabb: Float64Array, inflation: number, point: Float64Array, wvx: number, wvy: number, wvz: number): void;
+    static "__#462@#stamp_wall_velocity"(fluid: FluidComponent, posed: PosedShape3D, aabb: Float64Array, inflation: number, point: Float64Array, wvx: number, wvy: number, wvz: number): void;
     constructor();
     dependencies: (typeof FluidObstacle)[];
     components_used: (ResourceAccessSpecification<typeof Transform64> | ResourceAccessSpecification<typeof FluidObstacle> | ResourceAccessSpecification<typeof Collider> | ResourceAccessSpecification<typeof RigidBody> | ResourceAccessSpecification<typeof FluidComponent>)[];

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

@@ -1,12 +1,14 @@
 # Tone mapping: GT7 and PBR Neutral, SDR and HDR
 
-The renderer has three tone mapping modes, each one operator on every output (`ShadeToneMappingMode`):
+The renderer has four tone mapping modes, each one choice for every output (`ShadeToneMappingMode`):
 
-- `GT7`, the default;
+- `ACES`, the default: Unreal Engine's look;
+- `GT7`;
 - `PBR_NEUTRAL`;
 - `NONE`.
 
-This page compares the two operators, and shows each one's HDR form beside its SDR form.
+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.
 
 The engine renders and tonemaps each frame as usual. Two extensions then redraw the canvas from the HDR colour the
 tonemapper was given:

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

@@ -40,7 +40,7 @@ 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}. Read every frame, so it can be flipped
+     * 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}
      */

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":"AA6IA;IAOI,0BAEC;IAED;;OAEG;IACH,0BAAQ;IAER;;;;;;OAMG;IACH,kDAEC;IAED;;OAEG;IACH,kBAAO;IAYP;;;OAGG;IACH,2BAEC;IAaD,wCAGC;IAED,uCAEC;IAED;;;;OAIG;IACH,wBAFU,yBAAyB,CAEoB;IAEvD;;;;;;;OAOG;IACH,mBAFU,qBAAqB,CAEkB;IAEjD;;;;;OAKG;IACH,mBAFU,oBAAoB,CAEgB;IAE9C;;;OAGG;IACH,QAFU,cAAc,CAEM;IAE9B;;;;;;;;;OASG;IACH,2BAFU,OAAO,CAEiB;IAElC,6BAA4B;IAC5B,8BAA4B;IAC5B;;;;OAIG;IACH,mCAAkC;IAClC;;;;;;;OAOG;IACH,mCAFU,OAAO,CAEyB;IAW1C,oCAIC;IAED,mCAEC;IAYD,oCAIC;IAED,mCAEC;IAED;;;;;;OAMG;IACH,6BAFU,OAAO,CAEmB;IAcpC;;OAEG;IACH,uCAEC;IAyBD,0CAIC;IAED,yCAEC;IAED;;;;;OAKG;IACH,yBAFU,MAAM,CAEY;IAS5B,+CAKC;IAED,8CAEC;IAED,+BAA6B;IAC7B,4CAA0C;IAkB1C,qCAKC;IArBD;;;;;;;;;;OAUG;IACH,oCAGC;IASD;;;;;;;OAOG;IACH,0BAFU,OAAO,CAEe;IAQhC;;;;;OAKG;IACH,oCAOC;IAjBD,mCAEC;IAiBD;;;;;;;;;OASG;IACH,6BAFU,OAAO,CAEmB;IAWpC;;;;;OAKG;IACH,8BAA+C;IAE/C;;;;;;;;OAQG;IACH,6BAFU,OAAO,CAEmB;IAEpC;;;;;;;;;;;;;;OAcG;IACH,8BAFU,OAAO,CAEoB;IAErC;;;;;;;;;;OAUG;IACH,qBAFU,OAAO,CAEW;IAU5B;;;;;OAKG;IACH,wBAA0C;IAE1C;;;;;;;;OAQG;IACH,eAFU,UAAU,GAAC,QAAQ,CAEF;IAU3B;;;;OAIG;IACH,gCAAwD;IAExD;;;OAGG;IACH,4BAFU,OAAO,CAEiB;IAKlC;;;OAGG;IACH,yBAEC;IAOD;;;OAGG;IACH,gCAEC;IAcD;;;;;;;;;OASG;IACH,qBAA+B;IAE/B;;;;;;;;;;OAUG;IACH,qBAA+B;IAgB/B;;;OAGG;IACH,yCAeC;IAED;;;OAGG;IACH,wCAEC;IA0BD;;;OAGG;IACH,iCAEC;IAED;;;;OAIG;IACH,2BAEC;IAQD;;;OAGG;IACH,+CAIC;IAED;;;OAGG;IACH,gDAIC;IAwCD;;;OAGG;IACH,+BAcC;IA1BD;;;OAGG;IACH,0BAEC;IAsBD;;;;;;;;;;;;;;;;;;;OAmBG;IACH,iBAFU,iBAAiB,GAAC,IAAI,CAET;IAEvB;;OAEG;IACH;;;;;;;;;;;;;;OAcG;IACH,yBAHW,eAAe,GACb,eAAe,CAI3B;IAED;;;;;OAKG;IACH,4BAHW,eAAe,GACb,OAAO,CAInB;IAED;;;OAGG;IACH,uBAHW,UAAU,GACR,MAAM,CAIlB;IAUD;;;;;;;;;;;;;;;;;OAiBG;IACH,kCAHW,iBAAiB,GACf,iBAAiB,CAsB7B;IAED;;;;;OAKG;IACH,qCAHW,iBAAiB,GACf,OAAO,CAYnB;IAED;;OAEG;IACH,8BAFa,MAAM,CAIlB;IAgBD;;;;OAIG;IACH,yBAHW,KAAK,GACJ,gBAAgB,CAW3B;IAED;;;OAGG;IACH,6BAYC;IAED;;;;OAIG;IACH,gCAHW,KAAK,GACH,2BAA2B,CAcvC;IAGD;;;OAGG;IACH,kBAFW,KAAK,QAyBf;IAiPD,oGAAoG;IACpG,kDAA2C;IAO3C;;;;OAIG;IACH,0BAEC;IAiBD;;;;;;OAMG;IACH,qBAHW,eAAe,GACb,iBAAiB,CAW7B;IAgBD;;;;;;OAMG;IACH,cAFU,iBAAiB,CAEU;IAErC;;;;;;OAMG;IACH,eAgBC;IAwFD;;;;;;;;OAQG;IACH;QAJsC,OAAO;QACd,MAAM;QACT,UAAU,GAA3B,MAAM;sBAuMhB;IAED;;;;;;;;;;;;;;OAcG;IACH,0BAFW,eAAe,QA4DzB;IAyDD;;;;;;;;;;;;;;;;;OAiBG;IACH,WAFa,IAAI,CAwChB;IAgCD,4BAwBC;IAkJD;;;;;OAKG;IACH,UAHW,MAAM,KACN,MAAM,QAgBhB;IAoFD,0CAMC;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH,eAZW,iBAAiB,SACjB,KAAK,uBACL,MAAM,GAIJ,OAAO,CAuCnB;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH,yBARW,iBAAiB,SACjB,KAAK,sBACL,MAAM,UACN,iBAAiB,GACf,OAAO,CAiBnB;;CAuiCJ;+BA1nGY,OAAO,8CAA8C,EAAE,gBAAgB;gCACvE,OAAO,+CAA+C,EAAE,iBAAiB;gCACzE,OAAO,+BAA+B,EAAE,iBAAiB;8BACzD,OAAO,gCAAgC,EAAE,eAAe;gCACxD,OAAO,gDAAgD,EAAE,iBAAiB;8BAC1E,OAAO,4BAA4B,EAAE,eAAe;oBACpD,OAAO,kBAAkB,EAAE,KAAK;6BA/BhB,yBAAyB;0CACZ,gCAAgC;sCAEpC,4BAA4B;qCAD7B,2BAA2B;+BAEjC,6CAA6C;gCAC5C,sCAAsC;2BAhC3C,yCAAyC;6BAFvC,4CAA4C;8BAD3C,2CAA2C;4BAoD7C,uBAAuB;gCA/DnB,sBAAsB;oBAjDlC,4BAA4B;kCA6Gd,gCAAgC;2BA7EvC,2BAA2B;iCA2ErB,0CAA0C;4CA7D/B,+DAA+D;yBA0ClF,yBAAyB;kCAChB,kCAAkC;kCAUlC,wBAAwB;oBAnCtC,0BAA0B;gCAnDd,uCAAuC;uCAyChC,sDAAsD"}

package/src/shade/renderer/Renderer.js

@@ -22,13 +22,16 @@ 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/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 { TonemapDisplaySettings } from "./deferred/TonemapDisplaySettings.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 { FrameContext } from "./extension/FrameContext.js";
 import { FramePhase } from "./extension/FramePhase.js";
 import { GBufferTextures } from "./extension/GBufferTextures.js";
@@ -225,11 +228,11 @@ export class Renderer {
 
     /**
      * 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
+     * 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}
      */
-    tone_mapping_mode = ShadeToneMappingMode.GT7;
+    tone_mapping_mode = ShadeToneMappingMode.ACES;
 
     /**
      * Switches of the AVBOIT mode, read every frame while {@link transparency_mode} selects it.
@@ -1399,6 +1402,13 @@ export class Renderer {
      */
     #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();
@@ -1741,6 +1751,10 @@ export class Renderer {
             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;
         }
@@ -1822,6 +1836,7 @@ export class Renderer {
         this.#scene_sdfs.clear();
 
         this.#autoexposure?.destroy();
+        this.#tonemap_aces2_tables.destroy();
         this.#depth_of_field?.destroy();
         this.#depth_of_field_unreal?.destroy();
         this.#restir_di?.destroy();
@@ -3177,16 +3192,29 @@ 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 = {
+            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: this.#tonemap_shader(),
-            inputs: {
-                input_color: current_color_out,
-                settings: this.#tonemap_settings,
-                exposure
-            },
+            shader: tonemap_shader,
+            inputs: tonemap_inputs,
             output: [gr_texture_canvas]
         });
 

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

@@ -2,13 +2,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.
+ * to the SDR display's limits. That is the reason Polyphony give for GT7's operator, and Epic's for how Unreal 5.8
+ * takes its Filmic picture to HDR, 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;
+    let ACES: number;
 }
 //# sourceMappingURL=ShadeToneMappingMode.d.ts.map

package/src/shade/renderer/ShadeToneMappingMode.js

@@ -2,15 +2,15 @@
  * 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.
+ * to the SDR display's limits. That is the reason Polyphony give for GT7's operator, and Epic's for how Unreal 5.8
+ * takes its Filmic picture to HDR, 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 tone mapping (Polyphony Digital, SIGGRAPH 2025). An exposed 1.0 shows at the 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,
     /**
@@ -27,4 +27,15 @@ export const ShadeToneMappingMode = {
      * An exposed 0.18 shows at 0.14 of SDR white, where {@link GT7} shows it at 0.179.
      */
     PBR_NEUTRAL: 2,
+    /**
+     * Unreal Engine's default look, the default here too. SDR is UE's "Filmic" tone mapper at its default settings,
+     * the ACES-derived curve every Unreal title ships with unless it chose otherwise. HDR is what Unreal 5.8 does with
+     * the same method: the SDR picture, taken back to the scene through the inverse ACES 2.0 output transform for an
+     * SDR display, and rendered again with the ACES 2.0 output transform for the display's headroom.
+     *
+     * An exposed 0.18 shows at 0.18 of SDR white, as with {@link GT7}, with a mid-tone contrast of 1.36 against GT7's
+     * 1.05. On HDR the picture expands into the headroom and mid-grey rises with it, by ACES 2.0's design: 0.26 of SDR
+     * white at a 1000 cd/m² display.
+     */
+    ACES: 3,
 };

package/src/shade/renderer/deferred/tonemap/TonemapAces2Tables.d.ts

@@ -0,0 +1,38 @@
+/**
+ * What {@link shader_tonemap_HDR_aces} binds as `aces2_tables`: two ACES 2.0 output transforms, each its parameters and
+ * gamut tables, both limited to Rec.709, the gamut of the SDR picture they expand.
+ *
+ * 1. An SDR display, 100 cd/m². The pass runs it backwards, from the SDR picture to the scene.
+ * 2. This display: the peak over the paper white, times 100 cd/m². A display at or under the paper white gets
+ *    100 cd/m², which the pass does not read.
+ *
+ * Both take SDR white for 100 cd/m², ACES 2.0's reference, so an SDR picture expanded for a display keeps SDR white
+ * where the paper white puts it.
+ *
+ * Building one transform takes 7 to 13 ms, so the tables are built on the first {@link update} rather than with the
+ * renderer, and again only when the display's peak changes.
+ */
+export class TonemapAces2Tables {
+    /**
+     * Both blocks, the SDR one first. Zero until the first {@link update}.
+     * @type {Float32Array}
+     */
+    data: Float32Array;
+    /**
+     * Build the tables for a display, if they are not built for it already.
+     *
+     * @param {number} peak_nits the display's peak, cd/m²
+     * @returns {boolean} whether {@link data} changed
+     */
+    update(peak_nits: number): boolean;
+    /**
+     * The tables on the device, written if they changed since the last call.
+     *
+     * @param {GPUDevice} device
+     * @returns {GPUBuffer}
+     */
+    gpu_buffer(device: GPUDevice): GPUBuffer;
+    destroy(): void;
+    #private;
+}
+//# sourceMappingURL=TonemapAces2Tables.d.ts.map

package/src/shade/renderer/deferred/tonemap/TonemapAces2Tables.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TonemapAces2Tables.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/deferred/tonemap/TonemapAces2Tables.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;GAaG;AACH;IACI;;;OAGG;IACH,MAFU,YAAY,CAE0B;IAWhD;;;;;OAKG;IACH,kBAHW,MAAM,GACJ,OAAO,CAsBnB;IAED;;;;;OAKG;IACH,yCAgBC;IAED,gBAKC;;CACJ"}

package/src/shade/renderer/deferred/tonemap/TonemapAces2Tables.js

@@ -0,0 +1,97 @@
+import { assert } from "../../../../core/assert.js";
+import {
+    ACES2_BLOCK_FLOATS,
+    ACES2_LIMITING_REC709,
+    aces2_transform_block_write
+} from "../../shader/chunk/color/tonemap/aces/aces2_transform_block.js";
+import { PAPER_WHITE_NITS } from "../../shader/chunk/color/tonemap/chunk_PAPER_WHITE_NITS.js";
+
+/**
+ * What {@link shader_tonemap_HDR_aces} binds as `aces2_tables`: two ACES 2.0 output transforms, each its parameters and
+ * gamut tables, both limited to Rec.709, the gamut of the SDR picture they expand.
+ *
+ * 1. An SDR display, 100 cd/m². The pass runs it backwards, from the SDR picture to the scene.
+ * 2. This display: the peak over the paper white, times 100 cd/m². A display at or under the paper white gets
+ *    100 cd/m², which the pass does not read.
+ *
+ * Both take SDR white for 100 cd/m², ACES 2.0's reference, so an SDR picture expanded for a display keeps SDR white
+ * where the paper white puts it.
+ *
+ * Building one transform takes 7 to 13 ms, so the tables are built on the first {@link update} rather than with the
+ * renderer, and again only when the display's peak changes.
+ */
+export class TonemapAces2Tables {
+    /**
+     * Both blocks, the SDR one first. Zero until the first {@link update}.
+     * @type {Float32Array}
+     */
+    data = new Float32Array(2 * ACES2_BLOCK_FLOATS);
+
+    #peak_nits = NaN;
+
+    /**
+     * @type {GPUBuffer|null}
+     */
+    #buffer = null;
+
+    #uploaded = false;
+
+    /**
+     * Build the tables for a display, if they are not built for it already.
+     *
+     * @param {number} peak_nits the display's peak, cd/m²
+     * @returns {boolean} whether {@link data} changed
+     */
+    update(peak_nits) {
+        assert.isNumber(peak_nits, 'peak_nits');
+        assert.greaterThan(peak_nits, 0, 'peak_nits');
+
+        if (peak_nits === this.#peak_nits) {
+            return false;
+        }
+
+        if (Number.isNaN(this.#peak_nits)) {
+            aces2_transform_block_write(this.data, 0, 100, ACES2_LIMITING_REC709);
+        }
+
+        const headroom = Math.max(peak_nits / PAPER_WHITE_NITS, 1);
+
+        aces2_transform_block_write(this.data, ACES2_BLOCK_FLOATS, 100 * headroom, ACES2_LIMITING_REC709);
+
+        this.#peak_nits = peak_nits;
+        this.#uploaded = false;
+
+        return true;
+    }
+
+    /**
+     * The tables on the device, written if they changed since the last call.
+     *
+     * @param {GPUDevice} device
+     * @returns {GPUBuffer}
+     */
+    gpu_buffer(device) {
+        if (this.#buffer === null) {
+            this.#buffer = device.createBuffer({
+                label: "tonemap/aces2 tables",
+                size: this.data.byteLength,
+                usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST,
+            });
+            this.#uploaded = false;
+        }
+
+        if (!this.#uploaded) {
+            device.queue.writeBuffer(this.#buffer, 0, this.data);
+            this.#uploaded = true;
+        }
+
+        return this.#buffer;
+    }
+
+    destroy() {
+        if (this.#buffer !== null) {
+            this.#buffer.destroy();
+            this.#buffer = null;
+        }
+    }
+}

package/src/shade/renderer/deferred/{TonemapDisplaySettings.d.ts → tonemap/TonemapDisplaySettings.d.ts}

@@ -46,5 +46,5 @@ export const TONEMAP_SETTINGS_REC2020: WebGPUStruct;
  * TonemapDisplaySettings}.
  */
 export const TONEMAP_SETTINGS_REC2020_PEAK: WebGPUStruct;
-import { WebGPUStruct } from "../shader/type/WebGPUStruct.js";
+import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
 //# sourceMappingURL=TonemapDisplaySettings.d.ts.map

package/src/shade/renderer/deferred/tonemap/TonemapDisplaySettings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TonemapDisplaySettings.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/deferred/tonemap/TonemapDisplaySettings.js"],"names":[],"mappings":"AAiDA;;;;;;;;;GASG;AACH;IACI,qCAAqD;IACrD,qCAAqD;IACrD,qCAAqD;IAErD,sCAA8C;IAC9C,sCAA8C;IAC9C,sCAA8C;IAE9C;;;OAGG;IACH,WAFU,MAAM,CAEC;IAMjB;;;;;OAKG;IACH,oCAHW,oBAAoB,GAAC,MAAM,QAkBrC;CACJ;AAqBD;;GAEG;AACH,mDAAqF;AAErF;;;GAGG;AACH,wDAAmG;AAEnG;;GAEG;AACH,oDAAuF;AAEvF;;;GAGG;AACH,yDAAqG;6BAzIxE,mCAAmC"}

package/src/shade/renderer/deferred/{TonemapDisplaySettings.js → tonemap/TonemapDisplaySettings.js}

@@ -1,8 +1,8 @@
-import { m3_rgb_to_xyz_from_primaries } from "../../../core/color/xyz/m3_rgb_to_xyz_from_primaries.js";
-import { m3_invert } from "../../../core/geom/mat3/m3_invert.js";
-import { m3_multiply } from "../../../core/geom/mat3/m3_multiply.js";
-import { f32, vec3f } from "../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
-import { WebGPUStruct } from "../shader/type/WebGPUStruct.js";
+import { m3_rgb_to_xyz_from_primaries } from "../../../../core/color/xyz/m3_rgb_to_xyz_from_primaries.js";
+import { m3_invert } from "../../../../core/geom/mat3/m3_invert.js";
+import { m3_multiply } from "../../../../core/geom/mat3/m3_multiply.js";
+import { f32, vec3f } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
 
 // chromaticities of red, green and blue; every space here has a D65 white, so none needs chromatic adaptation
 const PRIMARIES_REC709 = [0.640, 0.330, 0.300, 0.600, 0.150, 0.060];

package/src/shade/renderer/deferred/{shader_tonemap_HDR.d.ts → tonemap/shader_tonemap_HDR.d.ts}

@@ -5,5 +5,5 @@
  * @type {ImageShader}
  */
 export const shader_tonemap_HDR: ImageShader;
-import { ImageShader } from "../shader/ImageShader.js";
+import { ImageShader } from "../../shader/ImageShader.js";
 //# sourceMappingURL=shader_tonemap_HDR.d.ts.map

package/src/shade/renderer/deferred/tonemap/shader_tonemap_HDR.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shader_tonemap_HDR.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/deferred/tonemap/shader_tonemap_HDR.js"],"names":[],"mappings":"AA4DA;;;;;GAKG;AACH,iCAFU,WAAW,CAclB;4BAvEyB,6BAA6B"}

package/src/shade/renderer/deferred/{shader_tonemap_HDR.js → tonemap/shader_tonemap_HDR.js}

@@ -1,13 +1,13 @@
-import { F32_CONTAINER_STRUCT } from "../shader/type/F32_CONTAINER_STRUCT.js";
+import { F32_CONTAINER_STRUCT } from "../../shader/type/F32_CONTAINER_STRUCT.js";
 import { TONEMAP_SETTINGS_REC2020_PEAK } from "./TonemapDisplaySettings.js";
-import { chunk_CRM_FROM_REC709_TO_REC2020 } from "../shader/chunk/color/conversion/chunk_CRM_FROM_REC709_TO_REC2020.js";
-import { chunk_sRGBTransferOETF } from "../shader/chunk/color/sRGB/chunk_sRGBTransferOETF.js";
-import { chunk_PAPER_WHITE_NITS } from "../shader/chunk/color/tonemap/chunk_PAPER_WHITE_NITS.js";
-import { chunk_tonemap_gt7 } from "../shader/chunk/color/tonemap/gt7/chunk_tonemap_gt7.js";
-import { CodeChunk } from "../shader/compiler/CodeChunk.js";
-import { ImageShader } from "../shader/ImageShader.js";
-import { ShaderResourceSetDescriptor } from "../shader/resource/ShaderResourceSetDescriptor.js";
-import { ShaderDescriptor } from "../shader/ShaderDescriptor.js";
+import { chunk_CRM_FROM_REC709_TO_REC2020 } from "../../shader/chunk/color/conversion/chunk_CRM_FROM_REC709_TO_REC2020.js";
+import { chunk_sRGBTransferOETF } from "../../shader/chunk/color/sRGB/chunk_sRGBTransferOETF.js";
+import { chunk_PAPER_WHITE_NITS } from "../../shader/chunk/color/tonemap/chunk_PAPER_WHITE_NITS.js";
+import { chunk_tonemap_gt7 } from "../../shader/chunk/color/tonemap/gt7/chunk_tonemap_gt7.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { ImageShader } from "../../shader/ImageShader.js";
+import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
+import { ShaderDescriptor } from "../../shader/ShaderDescriptor.js";
 
 const resources = new ShaderResourceSetDescriptor();
 

package/src/shade/renderer/deferred/tonemap/shader_tonemap_HDR_aces.d.ts

@@ -0,0 +1,17 @@
+/**
+ * The HDR output with {@link ShadeToneMappingMode.ACES}, as Unreal Engine 5.8 does it with its default "Filmic" method
+ * on a display past 100 cd/m²: the SDR picture of {@link shader_tonemap_LDR_aces}, taken back to the scene through the
+ * inverse ACES 2.0 output transform for an SDR display, and rendered again with the ACES 2.0 output transform for this
+ * display, limited to Rec.709 as the SDR picture is. Written in the canvas's primaries, extended, where 1.0 is SDR
+ * white.
+ *
+ * A display at or under the paper white shows the SDR picture.
+ *
+ * Binds `aces2_tables`, the two transforms' parameters and gamut tables, which {@link TonemapAces2Tables} builds for
+ * the display.
+ *
+ * @type {ImageShader}
+ */
+export const shader_tonemap_HDR_aces: ImageShader;
+import { ImageShader } from "../../shader/ImageShader.js";
+//# sourceMappingURL=shader_tonemap_HDR_aces.d.ts.map

package/src/shade/renderer/deferred/tonemap/shader_tonemap_HDR_aces.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shader_tonemap_HDR_aces.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/deferred/tonemap/shader_tonemap_HDR_aces.js"],"names":[],"mappings":"AA0EA;;;;;;;;;;;;;GAaG;AACH,sCAFU,WAAW,CAclB;4BA1FyB,6BAA6B"}

package/src/shade/renderer/deferred/tonemap/shader_tonemap_HDR_aces.js

@@ -0,0 +1,101 @@
+import { F32_CONTAINER_STRUCT } from "../../shader/type/F32_CONTAINER_STRUCT.js";
+import { f32 } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
+import { TONEMAP_SETTINGS_REC709_PEAK } from "./TonemapDisplaySettings.js";
+import { chunk_sRGBTransferOETF } from "../../shader/chunk/color/sRGB/chunk_sRGBTransferOETF.js";
+import { ACES2_BLOCK_FLOATS } from "../../shader/chunk/color/tonemap/aces/aces2_transform_block.js";
+import { chunk_aces2_output_transform } from "../../shader/chunk/color/tonemap/aces/chunk_aces2_output_transform.js";
+import { chunk_tonemap_ue_filmic } from "../../shader/chunk/color/tonemap/aces/chunk_tonemap_ue_filmic.js";
+import { chunk_PAPER_WHITE_NITS } from "../../shader/chunk/color/tonemap/chunk_PAPER_WHITE_NITS.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { ImageShader } from "../../shader/ImageShader.js";
+import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
+import { ShaderDescriptor } from "../../shader/ShaderDescriptor.js";
+
+const resources = new ShaderResourceSetDescriptor();
+
+resources.setImmediate("settings", TONEMAP_SETTINGS_REC709_PEAK);
+resources.createGroup()
+    .addTexture("input_color", "float")
+    .addUniform("exposure", F32_CONTAINER_STRUCT)
+    // two ACES 2.0 output transforms, TonemapAces2Tables: 100 cd/m² first, then the display's headroom
+    .addStorageBuffer("aces2_tables", WebGPUArray.from(f32))
+
+const body = CodeChunk.from(
+    //language=WGSL
+    `
+const ACES2_SDR_BLOCK: u32 = 0u;
+const ACES2_DISPLAY_BLOCK: u32 = ${ACES2_BLOCK_FLOATS}u;
+
+@fragment
+fn main(
+  @builtin(position) coord : vec4<f32>,
+) -> @location(0) vec4<f32> {
+
+    // scene color in linear Rec. 709
+    var color = textureLoad(input_color, vec2i(coord.xy), 0).rgb;
+
+    // Apply exposure
+    color *= exposure.value;
+
+    // the SDR picture first, which is what Unreal 5.8 does with Filmic on any display
+    let film = tonemap_ue_filmic(color);
+
+    var picture = film;
+
+    if (settings.peak_nits > PAPER_WHITE_NITS) {
+        // back to the scene through ACES 2.0 at SDR white, then out again through ACES 2.0 at the display's peak over
+        // the paper white. Both transforms take SDR white for 100 cd/m² and both are limited to Rec.709, the SDR
+        // picture's own gamut, so as the headroom shrinks to none the picture becomes the SDR one.
+        let aces = aces2_inverse(ACES2_SDR_BLOCK, film);
+        picture = aces2_forward(ACES2_DISPLAY_BLOCK, aces);
+    }
+
+    // into the primaries the canvas reports it was configured with (Renderer#configure_context): Display P3, or
+    // sRGB where the browser would not configure P3
+    let color_display = mat3x3<f32>(
+        settings.display_from_rec709_c0,
+        settings.display_from_rec709_c1,
+        settings.display_from_rec709_c2
+    ) * picture;
+
+    // NOTE: no dithering, colorspace is wide
+
+    // apply gamma. Note that gamma is the same for "Display P3" and "sRGB"
+    return vec4(sRGBTransferOETF(color_display), 1.0);
+}
+    `, [
+        chunk_tonemap_ue_filmic,
+        chunk_aces2_output_transform,
+        chunk_PAPER_WHITE_NITS,
+        chunk_sRGBTransferOETF,
+    ]
+);
+
+/**
+ * The HDR output with {@link ShadeToneMappingMode.ACES}, as Unreal Engine 5.8 does it with its default "Filmic" method
+ * on a display past 100 cd/m²: the SDR picture of {@link shader_tonemap_LDR_aces}, taken back to the scene through the
+ * inverse ACES 2.0 output transform for an SDR display, and rendered again with the ACES 2.0 output transform for this
+ * display, limited to Rec.709 as the SDR picture is. Written in the canvas's primaries, extended, where 1.0 is SDR
+ * white.
+ *
+ * A display at or under the paper white shows the SDR picture.
+ *
+ * Binds `aces2_tables`, the two transforms' parameters and gamut tables, which {@link TonemapAces2Tables} builds for
+ * the display.
+ *
+ * @type {ImageShader}
+ */
+export const shader_tonemap_HDR_aces = new ImageShader({
+    descriptor: ShaderDescriptor.from({
+        label: "Tonemap/HDR/aces",
+        resources,
+        body
+    }),
+    targets: [
+        {
+            label: "tone-mapped",
+            format: "rgba16float"
+        }
+    ]
+});

package/src/shade/renderer/deferred/{shader_tonemap_HDR_none.d.ts → tonemap/shader_tonemap_HDR_none.d.ts}

@@ -5,5 +5,5 @@
  * @type {ImageShader}
  */
 export const shader_tonemap_HDR_none: ImageShader;
-import { ImageShader } from "../shader/ImageShader.js";
+import { ImageShader } from "../../shader/ImageShader.js";
 //# sourceMappingURL=shader_tonemap_HDR_none.d.ts.map

package/src/shade/renderer/deferred/tonemap/shader_tonemap_HDR_none.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shader_tonemap_HDR_none.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/deferred/tonemap/shader_tonemap_HDR_none.js"],"names":[],"mappings":"AA+CA;;;;;GAKG;AACH,sCAFU,WAAW,CAclB;4BA7DyB,6BAA6B"}

package/src/shade/renderer/deferred/{shader_tonemap_HDR_none.js → tonemap/shader_tonemap_HDR_none.js}

@@ -1,10 +1,10 @@
-import { F32_CONTAINER_STRUCT } from "../shader/type/F32_CONTAINER_STRUCT.js";
+import { F32_CONTAINER_STRUCT } from "../../shader/type/F32_CONTAINER_STRUCT.js";
 import { TONEMAP_SETTINGS_REC709 } from "./TonemapDisplaySettings.js";
-import { chunk_sRGBTransferOETF } from "../shader/chunk/color/sRGB/chunk_sRGBTransferOETF.js";
-import { CodeChunk } from "../shader/compiler/CodeChunk.js";
-import { ImageShader } from "../shader/ImageShader.js";
-import { ShaderResourceSetDescriptor } from "../shader/resource/ShaderResourceSetDescriptor.js";
-import { ShaderDescriptor } from "../shader/ShaderDescriptor.js";
+import { chunk_sRGBTransferOETF } from "../../shader/chunk/color/sRGB/chunk_sRGBTransferOETF.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { ImageShader } from "../../shader/ImageShader.js";
+import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
+import { ShaderDescriptor } from "../../shader/ShaderDescriptor.js";
 
 const resources = new ShaderResourceSetDescriptor();
 resources.setImmediate("settings", TONEMAP_SETTINGS_REC709);

package/src/shade/renderer/deferred/{shader_tonemap_HDR_pbr_neutral.d.ts → tonemap/shader_tonemap_HDR_pbr_neutral.d.ts}

@@ -6,5 +6,5 @@
  * @type {ImageShader}
  */
 export const shader_tonemap_HDR_pbr_neutral: ImageShader;
-import { ImageShader } from "../shader/ImageShader.js";
+import { ImageShader } from "../../shader/ImageShader.js";
 //# sourceMappingURL=shader_tonemap_HDR_pbr_neutral.d.ts.map

package/src/shade/renderer/deferred/tonemap/shader_tonemap_HDR_pbr_neutral.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shader_tonemap_HDR_pbr_neutral.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/deferred/tonemap/shader_tonemap_HDR_pbr_neutral.js"],"names":[],"mappings":"AA4DA;;;;;;GAMG;AACH,6CAFU,WAAW,CAclB;4BAzEyB,6BAA6B"}