@woosh/meep-engine 3.63.3 → 3.64.1

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

@@ -0,0 +1,16 @@
+/**
+ * The encoding of a tone-mapping LUT, on both of its sides.
+ *
+ * - `tonemap_lut_pq_encode`: linear light with 1 at the paper white to its ST 2084 (PQ) signal, per channel. A
+ *   negative component reads as zero. 10000 cd/m², 49.3 × the paper white, encodes to 1.
+ * - `tonemap_lut_pq_decode`: the inverse, clamping the signal to [0, 1].
+ * - `tonemap_lut_coordinate`: where a LUT of `resolution`³ texels holds exposed scene colour `scene`, as a texture
+ *   coordinate. Texel i holds the signal i / (resolution - 1); a colour past 10000 cd/m² lands on the last texel.
+ *
+ * A LUT maps the PQ signal of exposed scene-linear Rec.709 to the PQ signal of linear Rec.2020 display light.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_tonemap_lut: CodeChunk;
+import { CodeChunk } from "../../../compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_tonemap_lut.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_tonemap_lut.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/color/tonemap/chunk_tonemap_lut.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;GAYG;AACH,gCAFU,SAAS,CAwBjB;0BAxCwB,gCAAgC"}

package/src/shade/renderer/shader/chunk/color/tonemap/chunk_tonemap_lut.js

@@ -0,0 +1,41 @@
+import { CodeChunk } from "../../../compiler/CodeChunk.js";
+import { chunk_eotfSt2084 } from "../iCtCp/chunk_eotf_st2084.js";
+import { chunk_inverseEotfSt2084 } from "../iCtCp/chunk_inverse_eotf_st2084.js";
+import { chunk_PAPER_WHITE_NITS } from "./chunk_PAPER_WHITE_NITS.js";
+
+/**
+ * The encoding of a tone-mapping LUT, on both of its sides.
+ *
+ * - `tonemap_lut_pq_encode`: linear light with 1 at the paper white to its ST 2084 (PQ) signal, per channel. A
+ *   negative component reads as zero. 10000 cd/m², 49.3 × the paper white, encodes to 1.
+ * - `tonemap_lut_pq_decode`: the inverse, clamping the signal to [0, 1].
+ * - `tonemap_lut_coordinate`: where a LUT of `resolution`³ texels holds exposed scene colour `scene`, as a texture
+ *   coordinate. Texel i holds the signal i / (resolution - 1); a colour past 10000 cd/m² lands on the last texel.
+ *
+ * A LUT maps the PQ signal of exposed scene-linear Rec.709 to the PQ signal of linear Rec.2020 display light.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_tonemap_lut = CodeChunk.from(
+    //language=WGSL
+    `
+fn tonemap_lut_pq_encode(v: vec3<f32>) -> vec3<f32> {
+    // the ST 2084 chunks count in units of 100 cd/m²
+    let n = max(v, vec3<f32>(0.0)) * (PAPER_WHITE_NITS / 100.0);
+    return vec3<f32>(inverseEotfSt2084(n.x), inverseEotfSt2084(n.y), inverseEotfSt2084(n.z));
+}
+
+fn tonemap_lut_pq_decode(e: vec3<f32>) -> vec3<f32> {
+    return vec3<f32>(eotfSt2084(e.x), eotfSt2084(e.y), eotfSt2084(e.z)) * (100.0 / PAPER_WHITE_NITS);
+}
+
+fn tonemap_lut_coordinate(scene: vec3<f32>, resolution: f32) -> vec3<f32> {
+    let e = min(tonemap_lut_pq_encode(scene), vec3<f32>(1.0));
+    return e * ((resolution - 1.0) / resolution) + 0.5 / resolution;
+}
+    `, [
+        chunk_eotfSt2084,
+        chunk_inverseEotfSt2084,
+        chunk_PAPER_WHITE_NITS,
+    ]
+);

package/src/shade/renderer/shader/chunk/filter/chunk_multiscale_mean.d.ts

@@ -8,8 +8,16 @@
  * fn multiscale_mean_seed(sample: vec3f) -> MultiscaleMean
  * fn multiscale_mean_add(e: MultiscaleMean, sample: vec3f, short_blend: f32, variance_blend: f32, mean_blend_min: f32, clip: bool, exposure: f32) -> MultiscaleMean
  * fn multiscale_mean_deviation_floor(short_mean: vec3f, exposure: f32) -> vec3f
+ * fn multiscale_mean_catch_up(relative: f32, inconsistency: f32, reduction: f32) -> f32
+ * fn multiscale_mean_blend_reduction(level: f32) -> f32
+ * const MULTISCALE_MEAN_REDUCTION_BLEND: f32
  * ```
  *
+ * `multiscale_mean_catch_up` and `multiscale_mean_blend_reduction` are the long mean's decision alone, for an
+ * estimator over a quantity the caller keeps the means of itself: `relative` the means' gap over the deviation,
+ * `inconsistency` its smoothed history, `reduction` the blend reduction as it stood before this sample, and `level`
+ * the short mean over the deviation. The reduction follows `level`'s by `MULTISCALE_MEAN_REDUCTION_BLEND` a sample.
+ *
  * `MultiscaleMean` is {@link MULTISCALE_MEAN_STRUCT}.
  *
  * - **Exposure**: the factor the display multiplies the samples by ahead of its tone curve, Unreal Engine's

package/src/shade/renderer/shader/chunk/filter/chunk_multiscale_mean.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_multiscale_mean.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/filter/chunk_multiscale_mean.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkDG;AACH,oCAFU,SAAS,CAuDZ;0BAhHmB,6BAA6B"}
+{"version":3,"file":"chunk_multiscale_mean.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/filter/chunk_multiscale_mean.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0DG;AACH,oCAFU,SAAS,CAiEZ;0BAlImB,6BAA6B"}

package/src/shade/renderer/shader/chunk/filter/chunk_multiscale_mean.js

@@ -16,8 +16,16 @@ const EXPOSURE_MAX = '1.70141183e38';
  * fn multiscale_mean_seed(sample: vec3f) -> MultiscaleMean
  * fn multiscale_mean_add(e: MultiscaleMean, sample: vec3f, short_blend: f32, variance_blend: f32, mean_blend_min: f32, clip: bool, exposure: f32) -> MultiscaleMean
  * fn multiscale_mean_deviation_floor(short_mean: vec3f, exposure: f32) -> vec3f
+ * fn multiscale_mean_catch_up(relative: f32, inconsistency: f32, reduction: f32) -> f32
+ * fn multiscale_mean_blend_reduction(level: f32) -> f32
+ * const MULTISCALE_MEAN_REDUCTION_BLEND: f32
  * ```
  *
+ * `multiscale_mean_catch_up` and `multiscale_mean_blend_reduction` are the long mean's decision alone, for an
+ * estimator over a quantity the caller keeps the means of itself: `relative` the means' gap over the deviation,
+ * `inconsistency` its smoothed history, `reduction` the blend reduction as it stood before this sample, and `level`
+ * the short mean over the deviation. The reduction follows `level`'s by `MULTISCALE_MEAN_REDUCTION_BLEND` a sample.
+ *
  * `MultiscaleMean` is {@link MULTISCALE_MEAN_STRUCT}.
  *
  * - **Exposure**: the factor the display multiplies the samples by ahead of its tone curve, Unreal Engine's
@@ -79,6 +87,16 @@ fn multiscale_mean_deviation_floor(short_mean: vec3f, exposure: f32) -> vec3f {
     return max(vec3f(sqrt(1e-5) / multiscale_mean_exposure(exposure)), max(abs(short_mean) * exp2(-10.0), vec3f(exp2(-24.0))));
 }
 
+const MULTISCALE_MEAN_REDUCTION_BLEND: f32 = 0.1;
+
+fn multiscale_mean_catch_up(relative: f32, inconsistency: f32, reduction: f32) -> f32 {
+    return clamp(smoothstep(0.0, 1.0, relative * max(0.02, inconsistency - 0.2)), 1.0 / 256.0, 1.0) * reduction;
+}
+
+fn multiscale_mean_blend_reduction(level: f32) -> f32 {
+    return clamp(0.5 * level, 1.0 / 32.0, 1.0);
+}
+
 fn multiscale_mean_add(e: ${MULTISCALE_MEAN_STRUCT.wgsl_ref}, sample: vec3f, short_blend: f32, variance_blend: f32, mean_blend_min: f32, clip: bool, exposure: f32) -> ${MULTISCALE_MEAN_STRUCT.wgsl_ref} {
     var y = sample;
 
@@ -95,15 +113,15 @@ fn multiscale_mean_add(e: ${MULTISCALE_MEAN_STRUCT.wgsl_ref}, sample: vec3f, sho
 
     let relative = rgb_to_luminance(abs(e.mean - short_mean) / deviation);
     let inconsistency = mix(e.inconsistency, relative, short_blend);
-    let reduction = clamp(rgb_to_luminance(0.5 * short_mean / deviation), 1.0 / 32.0, 1.0);
+    let reduction = multiscale_mean_blend_reduction(rgb_to_luminance(short_mean / deviation));
 
-    let catch_up = clamp(smoothstep(0.0, 1.0, relative * max(0.02, inconsistency - 0.2)), 1.0 / 256.0, 1.0) * e.reduction;
+    let catch_up = multiscale_mean_catch_up(relative, inconsistency, e.reduction);
 
     return ${MULTISCALE_MEAN_STRUCT.make({
         mean: 'mix(e.mean, y, max(saturate(catch_up), mean_blend_min))',
         short_mean: 'short_mean',
         variance: 'variance',
-        reduction: 'mix(e.reduction, reduction, 0.1)',
+        reduction: 'mix(e.reduction, reduction, MULTISCALE_MEAN_REDUCTION_BLEND)',
         inconsistency: 'inconsistency',
     })};
 }

package/src/shade/renderer/water/query/GPUWaterQueries.d.ts

@@ -24,7 +24,7 @@ export class GPUWaterQueries {
      * @param {PipelineEnquiry} enquiry
      */
     static enquirePipelines(enquiry: PipelineEnquiry): void;
-    static "__#282@#execute"(pass: any, resources: any, context: any): void;
+    static "__#285@#execute"(pass: any, resources: any, context: any): void;
     /**
      * @param {object} options
      * @param {GPUDevice} options.device

package/src/shade/wgsl/emulator/WGSLJavaScriptCompiler.js

@@ -3141,7 +3141,7 @@ const INTEGER_TYPED_BUILTIN = new Set(['abs', 'firstLeadingBit', 'firstTrailingB
  */
 const ELEMENT_WISE_BUILTIN = new Set([
     'abs', 'sign', 'floor', 'ceil', 'round', 'trunc', 'fract', 'sqrt', 'inverseSqrt',
-    'exp', 'exp2', 'log', 'log2', 'sin', 'cos', 'tan', 'asin', 'acos', 'atan',
+    'exp', 'exp2', 'log', 'log2', 'sin', 'cos', 'tan', 'asin', 'acos', 'atan', 'degrees', 'radians',
     'pow', 'atan2', 'min', 'max', 'step', 'clamp', 'saturate', 'mix', 'smoothstep',
     'normalize', 'reflect', 'fma', 'quantizeToF16',
     'subgroupBroadcastFirst', 'subgroupAdd', 'subgroupMul', 'subgroupMin', 'subgroupMax',
@@ -3232,13 +3232,13 @@ function inferBuiltinReturnType(name, args) {
     // Both gathers return the four texels of a 2x2 footprint. Saying so here matters more than
     // for most builtins: the shadow chunks immediately swizzle the result (`samples.wzxy`), and
     // an unknown type degrades swizzle codegen downstream.
-    if (name === 'textureGather') {
-        const first = args[0] !== undefined ? args[0].type : null;
-        const texture = first !== null && first.kind === 'texture' ? first : (args[1] !== undefined ? args[1].type : null);
-        const scalar = texture !== null && texture.kind === 'texture' ? texture.scalar : 'f32';
-        return { kind: 'vec', size: 4, scalar: scalar === 'u32' || /uint$/.test(scalar) ? 'u32'
-            : scalar === 'i32' || /sint$/.test(scalar) ? 'i32' : 'f32' };
-    }
+    if (name === 'textureGather') {
+        const first = args[0] !== undefined ? args[0].type : null;
+        const texture = first !== null && first.kind === 'texture' ? first : (args[1] !== undefined ? args[1].type : null);
+        const scalar = texture !== null && texture.kind === 'texture' ? texture.scalar : 'f32';
+        return { kind: 'vec', size: 4, scalar: scalar === 'u32' || /uint$/.test(scalar) ? 'u32'
+            : scalar === 'i32' || /sint$/.test(scalar) ? 'i32' : 'f32' };
+    }
     if (name === 'textureGatherCompare') {
         return { kind: 'vec', size: 4, scalar: 'f32' };
     }

package/src/shade/wgsl/emulator/WGSLLanguageCore.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"WGSLLanguageCore.d.ts","sourceRoot":"","sources":["../../../../../src/shade/wgsl/emulator/WGSLLanguageCore.js"],"names":[],"mappings":";IAk6DA;;;;;;;;;;;;;OAaG;IACH,+DAyFC"}
+{"version":3,"file":"WGSLLanguageCore.d.ts","sourceRoot":"","sources":["../../../../../src/shade/wgsl/emulator/WGSLLanguageCore.js"],"names":[],"mappings":";IAo6DA;;;;;;;;;;;;;OAaG;IACH,+DAyFC"}

package/src/shade/wgsl/emulator/WGSLLanguageCore.js

@@ -883,6 +883,8 @@ export const WGSLLanguageCore = {
     asin: (a) => unop(a, Math.asin),
     acos: (a) => unop(a, Math.acos),
     atan: (a) => unop(a, Math.atan),
+    degrees: (a) => unop(a, x => x * (180 / Math.PI)),
+    radians: (a) => unop(a, x => x * (Math.PI / 180)),
 
     pow: (a, b) => binop(a, b, Math.pow),
     atan2: (a, b) => binop(a, b, Math.atan2),

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

@@ -1,15 +0,0 @@
-/**
- * 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 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.d.ts.map

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

package/src/shade/renderer/ShadeToneMappingMode.js

@@ -1,41 +0,0 @@
-/**
- * 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 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 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,
-    /**
-     * No tone mapping: the exposed colour as it is, with 1.0 at SDR white. An SDR output clips everything above 1.0,
-     * and an HDR output shows it as far as the display reaches.
-     */
-    NONE: 1,
-    /**
-     * Khronos PBR Neutral (Lalish, 2024). Base colours under 0.8 come out as they are, less a 0.04 Fresnel offset, and
-     * hues never shift: made for showing products. SDR is the specification, which rolls highlights off to SDR white
-     * and toward white. HDR puts the display's peak in place of the specification's 1, so everything below the
-     * compression start looks the same on both outputs, and a highlight rolls off to the display's peak instead.
-     *
-     * An exposed 0.18 shows at 0.14 of SDR white, where {@link GT7} shows it at 0.179.
-     */
-    PBR_NEUTRAL: 2,
-    /**
-     * 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/shader_tonemap_HDR.d.ts

@@ -1,9 +0,0 @@
-/**
- * The HDR output with {@link ShadeToneMappingMode.GT7}: GT7 at the display's peak, with the same paper white as
- * {@link shader_tonemap_LDR}, written in the canvas's primaries, extended, where 1.0 is SDR white.
- *
- * @type {ImageShader}
- */
-export const shader_tonemap_HDR: ImageShader;
-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

@@ -1 +0,0 @@
-{"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/tonemap/shader_tonemap_HDR.js

@@ -1,79 +0,0 @@
-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";
-
-const resources = new ShaderResourceSetDescriptor();
-
-// per-pass, four bytes, read-only: immediate data rather than a uniform buffer. exposure stays
-// bound - it is computed on the GPU, so there is no CPU value to write.
-resources.setImmediate("settings", TONEMAP_SETTINGS_REC2020_PEAK);
-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;
-    
-    // Apply exposure
-    color *= exposure.value;
-    
-    // Finally tonemap, in the operator's own Rec.2020
-    let color_2020 = tonemap_gt7_rec2020(CRM_FROM_REC709_TO_REC2020 * color, settings.peak_nits, PAPER_WHITE_NITS);
-    
-    // NOTE: no dithering, colorspace is wide
-    
-    // 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_rec2020_c0,
-        settings.display_from_rec2020_c1,
-        settings.display_from_rec2020_c2
-    ) * color_2020;
-    
-    // apply gamma. Note that gamma is the same for "Display P3" and "sRGB"
-    let color_gamma = sRGBTransferOETF(color_display);
-    
-    return vec4(color_gamma, 1.0);
-}
-    `, [
-        chunk_tonemap_gt7,
-        chunk_PAPER_WHITE_NITS,
-        chunk_CRM_FROM_REC709_TO_REC2020,
-        chunk_sRGBTransferOETF,
-    ]
-);
-
-/**
- * The HDR output with {@link ShadeToneMappingMode.GT7}: GT7 at the display's peak, with the same paper white as
- * {@link shader_tonemap_LDR}, written in the canvas's primaries, extended, where 1.0 is SDR white.
- *
- * @type {ImageShader}
- */
-export const shader_tonemap_HDR = new ImageShader({
-    descriptor: ShaderDescriptor.from({
-        label: "Tonemap/HDR",
-        resources,
-        body
-    }),
-    targets: [
-        {
-            label: "tone-mapped",
-            format: "rgba16float"
-        }
-    ]
-});

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

@@ -1,17 +0,0 @@
-/**
- * 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

@@ -1 +0,0 @@
-{"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

@@ -1,101 +0,0 @@
-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/tonemap/shader_tonemap_HDR_none.d.ts

@@ -1,9 +0,0 @@
-/**
- * The HDR output with {@link ShadeToneMappingMode.NONE}: exposure and the canvas's primaries, extended, where 1.0 is
- * SDR white, and nothing in between.
- *
- * @type {ImageShader}
- */
-export const shader_tonemap_HDR_none: ImageShader;
-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

@@ -1 +0,0 @@
-{"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/tonemap/shader_tonemap_HDR_pbr_neutral.d.ts

@@ -1,10 +0,0 @@
-/**
- * The HDR output with {@link ShadeToneMappingMode.PBR_NEUTRAL}: Khronos PBR Neutral with the display's peak over the
- * paper white in place of the specification's 1, written in the canvas's primaries, extended, where 1.0 is SDR white.
- * Below the compression start it writes what {@link shader_tonemap_LDR_pbr_neutral} writes.
- *
- * @type {ImageShader}
- */
-export const shader_tonemap_HDR_pbr_neutral: ImageShader;
-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

@@ -1 +0,0 @@
-{"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"}

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

@@ -1,80 +0,0 @@
-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";
-
-const resources = new ShaderResourceSetDescriptor();
-
-// per-pass, four bytes, read-only: immediate data rather than a uniform buffer. exposure stays
-// bound - it is computed on the GPU, so there is no CPU value to write.
-resources.setImmediate("settings", TONEMAP_SETTINGS_REC709_PEAK);
-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;
-
-    // Apply exposure
-    color *= exposure.value;
-
-    // the display's peak in units of SDR white. A display under the paper white gets the SDR form, which is where
-    // the operator is defined.
-    let peak = max(settings.peak_nits / PAPER_WHITE_NITS, 1.0);
-
-    // It takes non-negative input.
-    color = tonemap_khronos_pbr(max(color, vec3<f32>(0.0)), peak);
-
-    // NOTE: no dithering, colorspace is wide
-
-    // 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
-    ) * color;
-
-    // apply gamma. Note that gamma is the same for "Display P3" and "sRGB"
-    return vec4(sRGBTransferOETF(color_display), 1.0);
-}
-    `, [
-        chunk_tonemap_khronos_pbr,
-        chunk_PAPER_WHITE_NITS,
-        chunk_sRGBTransferOETF,
-    ]
-);
-
-/**
- * The HDR output with {@link ShadeToneMappingMode.PBR_NEUTRAL}: Khronos PBR Neutral with the display's peak over the
- * paper white in place of the specification's 1, written in the canvas's primaries, extended, where 1.0 is SDR white.
- * Below the compression start it writes what {@link shader_tonemap_LDR_pbr_neutral} writes.
- *
- * @type {ImageShader}
- */
-export const shader_tonemap_HDR_pbr_neutral = new ImageShader({
-    descriptor: ShaderDescriptor.from({
-        label: "Tonemap/HDR/pbr_neutral",
-        resources,
-        body
-    }),
-    targets: [
-        {
-            label: "tone-mapped",
-            format: "rgba16float"
-        }
-    ]
-});

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

@@ -1,9 +0,0 @@
-/**
- * The SDR output with {@link ShadeToneMappingMode.GT7}: exposure, GT7 in its SDR mode, the canvas's primaries, the sRGB
- * transfer curve and an 8-bit dither. {@link shader_tonemap_HDR} is the same operator for an HDR display.
- *
- * @type {ImageShader}
- */
-export const shader_tonemap_LDR: ImageShader;
-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

@@ -1 +0,0 @@
-{"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"}