@woosh/meep-engine 3.51.0 → 3.52.0

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

@@ -1,12 +1,12 @@
-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_PEAK } from "./TonemapDisplaySettings.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_khronos_pbr } from "../shader/chunk/color/tonemap/chunk_tonemap_khronos_pbr.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 { chunk_PAPER_WHITE_NITS } from "../../shader/chunk/color/tonemap/chunk_PAPER_WHITE_NITS.js";
+import { chunk_tonemap_khronos_pbr } from "../../shader/chunk/color/tonemap/chunk_tonemap_khronos_pbr.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/{shader_tonemap_LDR.d.ts → tonemap/shader_tonemap_LDR.d.ts}

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

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

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

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

@@ -1,16 +1,16 @@
-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 } 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 { 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 {
     chunk_dither_color_8bit_triangle_noise
-} from "../shader/chunk/texture/dither/chunk_dither_color_8bit_triangle_noise.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";
+} from "../../shader/chunk/texture/dither/chunk_dither_color_8bit_triangle_noise.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_REC2020);

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

@@ -0,0 +1,10 @@
+/**
+ * The SDR output with {@link ShadeToneMappingMode.ACES}: exposure, Unreal Engine's default "Filmic" tone mapping, the
+ * canvas's primaries, the sRGB transfer curve and an 8-bit dither. {@link shader_tonemap_HDR_aces} expands the same
+ * picture into an HDR display's headroom.
+ *
+ * @type {ImageShader}
+ */
+export const shader_tonemap_LDR_aces: ImageShader;
+import { ImageShader } from "../../shader/ImageShader.js";
+//# sourceMappingURL=shader_tonemap_LDR_aces.d.ts.map

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

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

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

@@ -0,0 +1,77 @@
+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 { chunk_tonemap_ue_filmic } from "../../shader/chunk/color/tonemap/aces/chunk_tonemap_ue_filmic.js";
+import {
+    chunk_dither_color_8bit_triangle_noise
+} from "../../shader/chunk/texture/dither/chunk_dither_color_8bit_triangle_noise.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);
+resources.createGroup()
+    .addTexture("input_color", "float")
+    .addUniform("exposure", F32_CONTAINER_STRUCT)
+
+const body = CodeChunk.from(
+    //language=WGSL
+    `
+@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;
+
+    color *= exposure.value;
+
+    // Unreal's default SDR rendering, in Rec.709 and within it
+    color = tonemap_ue_filmic(color);
+
+    // into the primaries the canvas reports it was configured with (Renderer#configure_context): Display P3, or
+    // sRGB where the browser would not configure P3. A Rec.709 colour sits inside both.
+    let color_display = mat3x3<f32>(
+        settings.display_from_rec709_c0,
+        settings.display_from_rec709_c1,
+        settings.display_from_rec709_c2
+    ) * color;
+
+    // apply gamma. Note that gamma is the same for "Display P3" and "sRGB"
+    color = sRGBTransferOETF(color_display);
+
+    // apply dither to remove color banding
+    color += dither_color_8bit_triangle_noise(coord.xy);
+
+    return vec4(color, 1.0);
+}
+    `, [
+        chunk_tonemap_ue_filmic,
+        chunk_dither_color_8bit_triangle_noise,
+        chunk_sRGBTransferOETF,
+    ]
+);
+
+/**
+ * The SDR output with {@link ShadeToneMappingMode.ACES}: exposure, Unreal Engine's default "Filmic" tone mapping, the
+ * canvas's primaries, the sRGB transfer curve and an 8-bit dither. {@link shader_tonemap_HDR_aces} expands the same
+ * picture into an HDR display's headroom.
+ *
+ * @type {ImageShader}
+ */
+export const shader_tonemap_LDR_aces = new ImageShader({
+    descriptor: ShaderDescriptor.from({
+        label: "Tonemap/LDR/aces",
+        resources,
+        body
+    }),
+    targets: [
+        {
+            label: "tone-mapped",
+            format: "rgba8unorm"
+        }
+    ]
+});

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

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

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

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

package/src/shade/renderer/deferred/{shader_tonemap_LDR_none.js → tonemap/shader_tonemap_LDR_none.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_REC709 } from "./TonemapDisplaySettings.js";
-import { chunk_sRGBTransferOETF } from "../shader/chunk/color/sRGB/chunk_sRGBTransferOETF.js";
+import { chunk_sRGBTransferOETF } from "../../shader/chunk/color/sRGB/chunk_sRGBTransferOETF.js";
 import {
     chunk_dither_color_8bit_triangle_noise
-} from "../shader/chunk/texture/dither/chunk_dither_color_8bit_triangle_noise.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";
+} from "../../shader/chunk/texture/dither/chunk_dither_color_8bit_triangle_noise.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_LDR_pbr_neutral.d.ts → tonemap/shader_tonemap_LDR_pbr_neutral.d.ts}

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

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

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

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

@@ -1,14 +1,14 @@
-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 { chunk_tonemap_khronos_pbr } from "../shader/chunk/color/tonemap/chunk_tonemap_khronos_pbr.js";
+import { chunk_sRGBTransferOETF } from "../../shader/chunk/color/sRGB/chunk_sRGBTransferOETF.js";
+import { chunk_tonemap_khronos_pbr } from "../../shader/chunk/color/tonemap/chunk_tonemap_khronos_pbr.js";
 import {
     chunk_dither_color_8bit_triangle_noise
-} from "../shader/chunk/texture/dither/chunk_dither_color_8bit_triangle_noise.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";
+} from "../../shader/chunk/texture/dither/chunk_dither_color_8bit_triangle_noise.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/fluid/GPUFluidCascade.d.ts

@@ -136,7 +136,7 @@ export class GPUFluidCascade {
      * @param {*} _resources
      * @param {{encoder: ShadeGPUCommandContext}} context
      */
-    static "__#263@#execute_restrict"(record: object, _resources: any, context: {
+    static "__#264@#execute_restrict"(record: object, _resources: any, context: {
         encoder: ShadeGPUCommandContext;
     }): void;
     /**
@@ -144,7 +144,7 @@ export class GPUFluidCascade {
      * @param {*} _resources
      * @param {{encoder: ShadeGPUCommandContext}} context
      */
-    static "__#263@#execute_fill"(record: object, _resources: any, context: {
+    static "__#264@#execute_fill"(record: object, _resources: any, context: {
         encoder: ShadeGPUCommandContext;
     }): void;
     /**
@@ -152,7 +152,7 @@ export class GPUFluidCascade {
      * @param {import("../../../engine/graphics/render/frame_graph/FramePassResources.js").FramePassResources} resources
      * @param {{encoder: ShadeGPUCommandContext}} context
      */
-    static "__#263@#execute"(record: object, resources: import("../../../engine/graphics/render/frame_graph/FramePassResources.js").FramePassResources, context: {
+    static "__#264@#execute"(record: object, resources: import("../../../engine/graphics/render/frame_graph/FramePassResources.js").FramePassResources, context: {
         encoder: ShadeGPUCommandContext;
     }): void;
     /**

package/src/shade/renderer/fluid/GPUFluidCascadeStack.d.ts

@@ -56,7 +56,7 @@ export class GPUFluidCascadeStack {
      * @param {*} _resources
      * @param {{encoder: import("../../device/ShadeGPUCommandContext.js").ShadeGPUCommandContext}} context
      */
-    static "__#265@#execute_publish"(pass: object, _resources: any, context: {
+    static "__#266@#execute_publish"(pass: object, _resources: any, context: {
         encoder: import("../../device/ShadeGPUCommandContext.js").ShadeGPUCommandContext;
     }): void;
     /**

package/src/shade/renderer/fluid/forcing/GPUFluidForcing.d.ts

@@ -90,19 +90,19 @@ export class GPUFluidForcing {
      * @param {number} clear_size bytes cleared from 0 when the pool reuses the buffer
      * @returns {BufferResourceDescriptor}
      */
-    static "__#266@#descriptor"(kept: BufferResourceDescriptor[], role: number, size: number, usage: number, clear_size: number): BufferResourceDescriptor;
+    static "__#267@#descriptor"(kept: BufferResourceDescriptor[], role: number, size: number, usage: number, clear_size: number): BufferResourceDescriptor;
     /**
      * @param {object} record
      * @param {FramePassResources} resources
      * @param {{encoder: ShadeGPUCommandContext}} context
      */
-    static "__#266@#execute_extract"(record: object, resources: FramePassResources, context: {
+    static "__#267@#execute_extract"(record: object, resources: FramePassResources, context: {
         encoder: ShadeGPUCommandContext;
     }): void;
-    static "__#266@#execute_clear"(record: any, _resources: any, context: any): void;
-    static "__#266@#execute_query"(record: any, resources: any, context: any): void;
-    static "__#266@#execute_command"(record: any, resources: any, context: any): void;
-    static "__#266@#execute_apply"(record: any, resources: any, context: any): void;
+    static "__#267@#execute_clear"(record: any, _resources: any, context: any): void;
+    static "__#267@#execute_query"(record: any, resources: any, context: any): void;
+    static "__#267@#execute_command"(record: any, resources: any, context: any): void;
+    static "__#267@#execute_apply"(record: any, resources: any, context: any): void;
     /**
      * @param {object} options
      * @param {GPUDevice} options.device

package/src/shade/renderer/fluid/pressure/GPUFluidPressureSolve.d.ts

@@ -34,7 +34,7 @@ export class GPUFluidPressureSolve {
      * @param {*} _resources
      * @param {{encoder: ShadeGPUCommandContext}} context
      */
-    static "__#262@#execute"(data: {
+    static "__#263@#execute"(data: {
         solve: GPUFluidPressureSolve;
         arm: number;
         count: number;

package/src/shade/renderer/fluid/query/GPUFluidQueries.d.ts

@@ -49,7 +49,7 @@ export class GPUFluidQueries {
      * @param {import("../../../../engine/graphics/render/frame_graph/FramePassResources.js").FramePassResources} resources
      * @param {{encoder: import("../../../device/ShadeGPUCommandContext.js").ShadeGPUCommandContext}} context
      */
-    static "__#267@#execute"(pass: object, resources: import("../../../../engine/graphics/render/frame_graph/FramePassResources.js").FramePassResources, context: {
+    static "__#268@#execute"(pass: object, resources: import("../../../../engine/graphics/render/frame_graph/FramePassResources.js").FramePassResources, context: {
         encoder: import("../../../device/ShadeGPUCommandContext.js").ShadeGPUCommandContext;
     }): void;
     /**

package/src/shade/renderer/loader/gltf/tiny-gltf.d.ts

@@ -13,7 +13,7 @@ export class TinyGltf {
      * @readonly
      * @type {TextureFormat}
      */
-    static readonly "__#286@#UNCOMPRESSED_TARGET": TextureFormat;
+    static readonly "__#287@#UNCOMPRESSED_TARGET": TextureFormat;
     /**
      * @param {AssetManager} assetManager
      * @param {AssetRequestScope} [scope]

package/src/shade/renderer/postprocess/nss/NSS.d.ts

@@ -53,7 +53,7 @@ export class NSS {
      * @returns {number}
      */
     static recommended_jitter_sequence_size(upscale_ratio: number): number;
-    static "__#200@#preprocess_tensor_descriptor"(render_w: any, render_h: any): TextureResourceDescriptor;
+    static "__#201@#preprocess_tensor_descriptor"(render_w: any, render_h: any): TextureResourceDescriptor;
     /**
      * @param {GraphicsContext} graphics
      */

package/src/shade/renderer/shader/chunk/color/tonemap/ACES_TONE_MAPPING_BRIEF_2026_10_17.md

@@ -0,0 +1,160 @@
+# ACES tone mapping, Unreal's default look: a brief (2026-10-17)
+
+**Status: built.** `ShadeToneMappingMode.ACES` is the default. It is added beside GT7, PBR Neutral and NONE, and
+replaces none of them. Alex asked for a close match to Unreal Engine's current default look, on SDR and HDR alike,
+as fixed-function tone mapping: no settings and no LUTs.
+
+## 1. What it is
+
+- **SDR is Unreal's "Filmic" tone mapper at its default settings.** It is a line-for-line port of UE 5.4's
+  `CombineLUTsCommon` (PostProcessCombineLUTs.usf, the sRGB output device) and `FilmToneMap` (TonemapCommon.ush), in
+  `chunk_tonemap_ue_filmic`, evaluated per pixel where UE bakes it into a 32³ LUT:
+  1. ACEScg from UE's default sRGB working space;
+  2. Expand Gamut at 1.0;
+  3. the colour corrections at their defaults, which only clamp at zero;
+  4. Blue Correction at 0.6;
+  5. the curve at Slope 0.88, Toe 0.55, Shoulder 0.26, Black Clip 0 and White Clip 0.04 (`FPostProcessSettings`,
+     Scene.cpp);
+  6. the inverse blue correction, then Rec.709 clipped to [0, 1].
+- **HDR is what Unreal 5.8 does with Filmic on a display past 100 cd/m²:** the SDR picture, taken back to the scene
+  through the inverse ACES 2.0 output transform for a 100 cd/m² display, and rendered again with the ACES 2.0 output
+  transform for this display's headroom, both limited to Rec.709. The ACES 2.0 part is OpenColorIO 2.6.0's
+  implementation, in `chunk_aces2_output_transform`, with three limits on its inverse (D5). Its per-display parameters
+  and gamut tables are built on the CPU in `aces2_transform_block.js` and owned by `TonemapAces2Tables`.
+
+| | SDR | HDR, 1000 cd/m² | HDR, 2000 cd/m² | HDR, 4000 cd/m² |
+|---|---|---|---|---|
+| exposed 0.18 shows at, × SDR white | 0.180 | 0.257 | 0.287 | 0.313 |
+| white reaches, × SDR white | 1.0 at +6 EV | 4.90 | 9.62 | 18.64 |
+
+HDR columns are 1015, 2030 and 4060 cd/m² displays, whose headroom over the 203 cd/m² paper white puts ACES 2.0 at
+500, 1000 and 2000 cd/m². The values are OpenColorIO's.
+
+Mid-grey rises with the display's peak. That is ACES 2.0's design, and Unreal 5.8 keeps it: 10 cd/m² at a 100 cd/m²
+display, plus 14% of that for every doubling of the peak. A display with no headroom shows the SDR picture exactly.
+
+## 2. Sources
+
+- **UE 5.4 source, installed** (H:/Program Files/Epic Games/UE_5.4): PostProcessCombineLUTs.usf, TonemapCommon.ush,
+  ACES.ush, GammaCorrectionCommon.ush, PostProcessCommon.ush, PostProcessTonemap.usf; PostProcessCombineLUTs.cpp,
+  PostProcessTonemap.cpp, RenderCore.cpp, HDRHelper.h, Scene.cpp. Every default above was read there.
+- **UE after 5.4, release notes** (Epic, verified):
+  - 5.6 adds ACES 2.0 for HDR as an option (`r.HDR.Aces.Version=2`).
+  - 5.8 adds "support for ACES 2.0 in SDR", moves ACES into a secondary LUT, and drops the HDR UI paper white from 300
+    to 203 cd/m² to match BT.2408.
+  - 5.8's `TonemappingMethod` is FILMIC = 0 or STANDARD_ACES = 1.
+- **UE 5.8's behaviour, Epic staff** (Yutaro Sawada, forums.unrealengine.com/t/tonemappingmethod/2747218, 2026-07-30,
+  in Japanese):
+  - `r.HDR.Aces.Version` now defaults to 2.
+  - Filmic, the default, aims at one look on SDR and HDR. Past 100 cd/m² it is "applied, converted back to linear
+    through the inverse ACES 2.0, then output again through ACES 2.0 at the target luminance".
+  - `r.HDR.Aces.SceneColorMultiplier` applies to Standard ACES only.
+  - The peak comes from the hardware, and mid and minimum luminance derive from it.
+- **ACES 2.0:**
+  - ampas/aces-core, Lib.Academy.OutputTransform.ctl and Lib.Academy.Tonescale.ctl;
+  - OpenColorIO v2.6.0, ops/fixedfunction/ACES2/Transform.cpp, FixedFunctionOpCPU.cpp and transforms/builtins/ACES.cpp,
+    which this ports.
+- **The UE 5.8 source is not public**, so the glue between Filmic and ACES 2.0 (§3, D2) is inferred from the staff
+  description, not read.
+
+The state of the art elsewhere, for context:
+
+- Godot defaults to Linear, three.js to none, and Unity HDRP to none; Filament defaults to a legacy ACES fit.
+- Blender added ACES 1.3 and 2.0 views in 5.0, with AgX the default since 4.0.
+- No real-time engine but Unreal ships ACES 2.0 by default.
+
+## 3. Decisions
+
+- **D1. SDR is Filmic exactly, Unreal's pass excepted.** Left out because they are not tone mapping:
+  - vignette (UE's default intensity 0.4), grain, sharpening and bloom;
+  - the LUT itself: UE interpolates a 32³ table, where this evaluates the function;
+  - the LUT's input range: UE's log encoding stops at 43.7, so it shades anything brighter as 43.7. This does not,
+    which moves saturated highlights past 43.7 by a few codes.
+- **D2. HDR, the glue I inferred:**
+  - The inverse runs at 100 cd/m² with Rec.709 limiting primaries, because Filmic's output is a Rec.709 SDR picture.
+  - The forward runs at 100 × the display's peak over the paper white, also limited to Rec.709. So both transforms
+    take SDR white for 100 cd/m², and SDR white lands on the paper white, as in every other mode.
+  - Rec.709 rather than the canvas's Display P3, because the review measured what P3 does: just past the paper white
+    (203.01 cd/m²) saturated colours jumped up to 67 codes from the SDR picture, 213 of 512 by more than 2. Limited
+    to the SDR picture's own gamut, the HDR picture becomes the SDR one as the headroom shrinks to none. HDR gives up
+    colours outside Rec.709, which the SDR picture never had either. Unreal may limit to the display's gamut; its
+    source would say.
+  - A display at or under the paper white shows the SDR picture, Unreal's "past 100 cd/m²" rule in this engine's
+    units.
+  - Unreal sets the HDR level with `HDRPaperWhiteNits` and runs the forward transform at the display's absolute
+    peak. If its paper white scales the SDR picture onto the paper white, which its default of 203, BT.2408 and ours
+    suggest, the two agree.
+- **D3. No scene colour multiplier.** UE applies its 1.5 to Standard ACES only.
+- **D4. Tables are built on the CPU, per display.** ACES 2.0 needs a reach table, a hue table and a gamut-cusp
+  table with an upper-hull gamma per hue. They are found by searches no pixel can afford.
+  - Built in 7–13 ms in JS, on the first HDR frame and then on a change of peak, not every frame and not with the
+    renderer.
+  - Bound as one 15 KB storage buffer: two blocks of 1,893 floats.
+  - These are the algorithm's own data, not a grading LUT.
+- **D5. The inverse is limited where OCIO's is ill-conditioned.** Filmic clips channels onto the Rec.709 cube's
+  surface, and ACES 2.0's estimate of the gamut boundary lies a hair inside that surface. So a bright tinted highlight,
+  SDR (0.981, 1, 1) say, sits on or past the boundary, where OCIO's inverse extrapolates. The review measured it as a
+  jump of 0.24 × SDR white between neighbouring scene values on a smooth ramp, which a picture shows as speckle or a
+  ring. Three limits, only in the inverse, and only where it is ill-conditioned:
+  - colourfulness past the estimated boundary is clamped to it, so it comes back as the reach boundary, which the
+    forward transform takes back to the boundary;
+  - the decompression's gain is held to 5. Below the last unit of J it stays under 4.9 for 3,000 Filmic outputs, and
+    within that unit it reaches 600 to 11,700, which multiplies float32 rounding by as much;
+  - over that last unit of J the decompression fades to none, so a near-white colour meets the neutral that white,
+    past J_max, is sent to.
+
+  A colour whose SDR picture is not in that region is untouched and matches OCIO. Two more departures are where OCIO
+  gives NaN: the gamut boundary's power takes a base clamped at zero, and an achromatic response at or under zero
+  tone-maps to zero, which is where OCIO's `max(0, NaN)` lands it.
+
+## 4. Measured
+
+**Against the references**, in `shader_tonemap_aces.spec.js`, under the WGSL emulator, in Display P3:
+
+- SDR is within the dither of a float64 Python port of UE's HLSL, at 29 colours from black to 1000.
+- HDR is within 1e-4 (encoded) of OpenColorIO 2.6.0 at four display peaks: its builtin inverse at 100 cd/m², then its
+  ACES 2.0 fixed function limited to Rec.709 between its builtins' clamps.
+  - The exceptions are three bright saturated colours whose SDR picture is near white, where D5's limits apply, and
+    a grey at +4 EV on 8120 cd/m², where OCIO's float32 inverse drifts by more than that. These four are held to a
+    float64 Python port with the same limits instead.
+- A tinted highlight's HDR picture moves continuously: the largest step along a ramp shrinks when the interval is cut
+  ten times finer. Without D5's clamp and gain limit it does not, nor with P3 limiting at 203.01 cd/m² is an HDR
+  display within 2 codes of SDR; both tests failed before the change.
+- Mutation testing: 110 mutants by an adversarial reviewer, then the survivors and every limit in D5 again. Three
+  survive, each unreachable or under the tolerance (the inverse's nd ≥ 1 branch, which the clamp makes unreachable;
+  the gain ≥ 1 escape; a looser cusp-search tolerance).
+- The JS table builder matches a float64 Python port to 6e-8.
+- That Python port matches OCIO's builtins to 2e-5, forward and inverse, at 100, 500 and 1000 cd/m².
+
+**On the device** (RTX 4090, headless Chrome, volumetrics_froxel, 1258×646, exposure fixed). OKLab lightness and HSV
+saturation are on the displayed frame:
+
+| view | mode | L mean | L p05 | L p95 | saturation |
+|---|---|---|---|---|---|
+| overview | ACES | 0.434 | 0.141 | 0.655 | 0.323 |
+| overview | GT7 | 0.445 | 0.180 | 0.635 | 0.281 |
+| broadside | ACES | 0.512 | 0.224 | 0.868 | 0.263 |
+| broadside | GT7 | 0.522 | 0.258 | 0.891 | 0.241 |
+| volume edge | ACES | 0.472 | 0.256 | 0.725 | 0.342 |
+| volume edge | GT7 | 0.480 | 0.288 | 0.699 | 0.300 |
+
+- Mid-grey is where GT7 puts it, 0.18 in and 0.18 out.
+- The mid-tone contrast is 1.36 against GT7's 1.05. Shadows sit deeper and highlights brighter, and saturation rises
+  12–15%.
+
+The pass's cost, three interleaved rounds of 24 frames:
+
+| pass | ACES | GT7 |
+|---|---|---|
+| SDR | 12–13 µs | 14–21 µs |
+| HDR | 55–102 µs | 16–33 µs |
+
+The HDR pass was forced through `matchMedia` and ran on the device with no validation errors and no non-finite output.
+It has not been looked at on an HDR display.
+
+## 5. Open, measured
+
+- **The HDR pass costs three to four times GT7's**: two ACES 2.0 transforms a pixel, 55–102 µs at 0.8 MP on a 4090.
+  Unreal pays this once into a LUT, which was ruled out here.
+- **The glue to Filmic is inferred** (D2, D5). Unreal evaluates this composite into a LUT, whose interpolation smooths
+  what D5 limits; its 5.8 source is the way to check.

package/src/shade/renderer/shader/chunk/color/tonemap/HDR_TONE_MAPPING_FORMS_BRIEF_2026_10_16.md

@@ -4,6 +4,10 @@
 `ShadeToneMappingMode.PBR_NEUTRAL` runs `tonemap_khronos_pbr` with the peak form. The prototypes this brief measured
 are gone from the playground `src/shade/playground/tonemap_sdr/`, which now compares GT7 and PBR Neutral.
 
+**The paper white is 203 cd/m² since `5549db81f` (2026-10-17),** BT.2408's graphics white, not GT7's 250. Every
+measurement below was taken at 250, so peak ×4 was a 1000 cd/m² display; at 203 it is 812 cd/m², and a 1000 cd/m²
+display is ×4.93.
+
 ## 1. Recommendation
 
 The question: does each operator have one form, parameterised by the display's peak, that serves an SDR peak and an HDR
@@ -249,7 +253,7 @@ SDR white, the means at ×4 are 0.2–9.2 codes for GT7, 0.8–14.2 for Neutral
 - `chunk_tonemap_khronos_pbr` takes the peak. Its WGSL signature changes from `tonemap_khronos_pbr(c)` to
   `tonemap_khronos_pbr(c, peak)`, a break for any WGSL caller outside the repo. The import path stays.
 - **The paper white becomes a canvas convention, not GT7's.** Neutral's HDR pass divides the display's peak by the same
-  250 cd/m² that puts SDR white at the canvas's 1.0. So `chunk_GT7_PAPER_WHITE_NITS` moves out of `gt7/` under a
+  paper white that puts SDR white at the canvas's 1.0: 250 cd/m² then, 203 since `5549db81f`. So `chunk_GT7_PAPER_WHITE_NITS` moves out of `gt7/` under a
   name of its own, which is an import-path change too.
 - **Mid-grey sits lower.** Neutral puts an exposed 0.18 at 0.140 (the 0.04 Fresnel offset), where GT7 puts it at 0.179.
   Switching modes darkens mid-grey by 0.36 EV. Auto-exposure meters the scene, not the output, so it will not

package/src/shade/renderer/shader/chunk/color/tonemap/SDR_TONE_MAPPING_BRIEF_2026_10_16.md

@@ -5,6 +5,14 @@ F3 landed with `ShadeToneMappingMode`, whose modes were then `GT7` and `NONE`. T
 then added `PBR_NEUTRAL` and removed the ACES and AgX chunks. The playground `src/shade/playground/tonemap_sdr/`
 compares GT7 and PBR Neutral.
 
+**The paper white is 203 cd/m² since `5549db81f` (2026-10-17),** BT.2408's graphics white, where this brief chose the
+sample code's 250. Every measurement below was taken at 250. At 203 the SDR pass is the sample code's SDR mode with
+`GRAN_TURISMO_SDR_PAPER_WHITE` at 203, under the 250 its parameters were tuned on, so it is no longer the sample code
+exactly. The curve's toe sits at a fixed 53.8 cd/m², so the change is not a scale: an exposed 0.18 comes out 0.176
+(116) instead of 0.179 (117). Against the compiled sample code at 203, over the same 648 inputs, the ICtCp blend differs
+by up to 0.33 codes in the mid-tones and 14.7 in saturated highlights, against 0.30 and 14.4 at 250.
+`shader_tonemap_LDR.spec.js` pins the sample code's output at 203.
+
 ## 1. Recommendation
 
 **Make GT7's SDR mode the SDR default, exactly as Polyphony's sample code defines it.** The curve's peak is the
@@ -205,13 +213,15 @@ renderer.tone_mapping_mode = ShadeToneMappingMode.NONE;  // exposure only; SDR c
 
   Each module lists its own chunks, so a mode's dependencies are visible. No `override`, no runtime branch on a
   setting. If shader switches land, each pair can become one pass with a choice.
-- **The paper white is a convention, not a setting.** `chunk_GT7_PAPER_WHITE_NITS` (250) is the paper white on both
-  outputs, and SDR also uses it as the peak. Below the SDR shoulder the two outputs therefore write the same colour:
-  pinned in `shader_tonemap_HDR.spec.js`. The HDR pass's only setting is the display's peak.
+- **The paper white is a convention, not a setting.** `chunk_GT7_PAPER_WHITE_NITS` (250; since the HDR forms brief
+  `chunk_PAPER_WHITE_NITS`, and 203 since `5549db81f`) is the paper white on both outputs, and SDR also uses it as the
+  peak. Below the SDR shoulder the two outputs therefore write the same colour: pinned in `shader_tonemap_HDR.spec.js`.
+  The HDR pass's only setting is the display's peak.
 - **`tonemap_gt7` follows the sample code** in the curve, the relative chroma fade, the 0.6 untwisted weight and the
   clamp at the target, and keeps the ICtCp blend (F2). Against the compiled sample code over 648 inputs it differs by up
-  to 0.3 sRGB codes in the mid-tones and up to 14 in saturated highlights. An earlier draft of this brief said "at most
-  8", from four hand-picked cases; the full sweep says 14.
+  to 0.3 sRGB codes in the mid-tones and up to 14 in saturated highlights, at 250; at 203, against the sample code at
+  203, by 0.33 and 14.7. An earlier draft of this brief said "at most 8", from four hand-picked cases; the full sweep
+  says 14.
 - **ACES, AgX and Neutral were unwired** here, kept for a look at HDR-aware variants of each.
   `HDR_TONE_MAPPING_FORMS_BRIEF_2026_10_16.md` took that look: ACES and AgX are removed, and Neutral is
   `ShadeToneMappingMode.PBR_NEUTRAL`, with the display's peak in place of the specification's 1 on HDR.

package/src/shade/renderer/shader/chunk/color/tonemap/aces/aces2_transform_block.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Fill one block of the ACES 2.0 output transform for a display: its peak and the primaries it limits to.
+ *
+ * Matches OpenColorIO's `ACES_OUTPUT_TRANSFORM_20` set up with the same two values, and the builtin transforms' AP1
+ * clamp before it and clamp at the peak after it. Takes a few tens of milliseconds, so it is for a display that
+ * changed, not for a frame.
+ *
+ * @param {Float32Array} out
+ * @param {number} offset first float of the block
+ * @param {number} peak_nits the display's peak, cd/m², where 100 is what an exposed 1.0 shows at
+ * @param {number[]} limiting red, green, blue and white xy
+ */
+export function aces2_transform_block_write(out: Float32Array, offset: number, peak_nits: number, limiting: number[]): void;
+/**
+ * Rec.709's red, green, blue and white xy: the limiting primaries the ACES tone mapping uses.
+ * @type {number[]}
+ */
+export const ACES2_LIMITING_REC709: number[];
+/** limiting primaries to the CAM16 cone space, white-adapted */
+export const ACES2_OUT_RGB_TO_CAM: 0;
+export const ACES2_OUT_CAM_TO_RGB: 9;
+/** ACES2065-1 (AP0) to the cone space and back */
+export const ACES2_IN_RGB_TO_CAM: 18;
+export const ACES2_IN_CAM_TO_RGB: 27;
+/** compressed cone response to achromatic and opponent (A, a, b) and back; the same for every set of primaries */
+export const ACES2_CONE_TO_AAB: 36;
+export const ACES2_AAB_TO_CONE: 45;
+/**
+ * scalars, in this order: limit_J_max, model_gamma_inv, mid_J, focus_dist, lower_hull_gamma_inv, s_2, m_2, g, t_1,
+ * n_r, inverse_limit, AP1 upper bound, sat, sat_thr, compr, chroma_compress_scale, peak / 100, F_L_n, cz, inv_cz,
+ * A_w_J, inv_A_w_J, the hue search range's lower and upper offsets
+ */
+export const ACES2_SCALARS: 54;
+export const ACES2_SCALAR_COUNT: 24;
+/** TOTAL entries of (hue, cusp J, cusp M, upper hull inverse gamma) */
+export const ACES2_CUSP_TABLE: number;
+/** TOTAL entries of the reach gamut's M at limit_J_max, one per degree from the first nominal entry */
+export const ACES2_REACH_TABLE: number;
+/** floats in one block */
+export const ACES2_BLOCK_FLOATS: number;
+//# sourceMappingURL=aces2_transform_block.d.ts.map

package/src/shade/renderer/shader/chunk/color/tonemap/aces/aces2_transform_block.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"aces2_transform_block.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/shade/renderer/shader/chunk/color/tonemap/aces/aces2_transform_block.js"],"names":[],"mappings":"AA6hBA;;;;;;;;;;;GAWG;AACH,iDALW,YAAY,UACZ,MAAM,aACN,MAAM,YACN,MAAM,EAAE,QA4IlB;AA7nBD;;;GAGG;AACH,oCAFU,MAAM,EAAE,CAEwE;AAK1F,gEAAgE;AAChE,qCAAsC;AACtC,qCAAsC;AACtC,kDAAkD;AAClD,qCAAsC;AACtC,qCAAsC;AACtC,kHAAkH;AAClH,mCAAoC;AACpC,mCAAoC;AACpC;;;;GAIG;AACH,+BAAgC;AAChC,oCAAqC;AACrC,uEAAuE;AACvE,sCAAmE;AACnE,uGAAuG;AACvG,uCAA8D;AAC9D,0BAA0B;AAC1B,wCAA4D"}