@woosh/meep-engine 3.63.3 → 3.64.1

package/src/shade/renderer/Renderer.js

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

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

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

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

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

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

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

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

@@ -0,0 +1,158 @@
+/**
+ * The grade as the bake reads it, a uniform. Every field is 16 bytes, in this order, never packed: field i is at byte
+ * 16 · i, which is how {@link ColorGrade#pack} writes it.
+ *
+ * - `white_balance_c0..c2`: the white-balance matrix on linear Rec.709, by column.
+ * - per zone, `{zone}_saturation`, `_contrast`, `_gamma`, `_gain`, `_offset`: the zone's values with the global ones
+ *   folded in and each vector's fourth component applied to the first three, as Unreal's `ColorCorrectAll` combines
+ *   them.
+ * - `zone_bounds`: `shadows_max`, `highlights_min`, `highlights_max`.
+ * - `curve_counts`: the keys of the hue, saturation and lightness curves. They follow the uniform in `grade_keys`, in
+ *   that order.
+ */
+export const COLOR_GRADE_STRUCT: WebGPUStruct;
+/**
+ * Floats of {@link COLOR_GRADE_STRUCT} at the head of {@link ColorGrade#pack}'s data.
+ * @type {number}
+ */
+export const COLOR_GRADE_HEADER_FLOATS: number;
+/**
+ * Floats of one keyframe in `grade_keys`: time, value, in tangent, out tangent.
+ * @type {number}
+ */
+export const COLOR_GRADE_KEY_FLOATS: number;
+/**
+ * One zone of Unreal's primary grade: shadows, midtones, highlights, or all of them. Each vector is RGB and a master
+ * value that scales (or, for the offset, adds to) all three.
+ */
+export class ColorGradeZone {
+    /**
+     * Blend between the luma and the colour; 0 is grey, 1 leaves it.
+     * @readonly
+     * @type {Vector4}
+     */
+    readonly saturation: Vector4;
+    /**
+     * Power about 0.18.
+     * @readonly
+     * @type {Vector4}
+     */
+    readonly contrast: Vector4;
+    /**
+     * The colour is raised to 1 / gamma.
+     * @readonly
+     * @type {Vector4}
+     */
+    readonly gamma: Vector4;
+    /**
+     * @readonly
+     * @type {Vector4}
+     */
+    readonly gain: Vector4;
+    /**
+     * Added last.
+     * @readonly
+     * @type {Vector4}
+     */
+    readonly offset: Vector4;
+}
+/**
+ * A colour grade on the exposed scene colour, ahead of the tone-mapping operator, baked into the tone mapper's LUTs.
+ * Neutral as constructed. In order:
+ *
+ * 1. **White balance**, Unreal's temperature white balance on linear Rec.709; see `m3_white_balance_rec709`.
+ * 2. **Primaries**, Unreal's `ColorCorrectAll` in AP1: saturation, contrast, gamma, gain and offset for {@link global},
+ *    {@link shadows}, {@link midtones} and {@link highlights}, the zones blended by AP1 luma between
+ *    {@link shadows_max}, {@link highlights_min} and {@link highlights_max}. Values from an Unreal project's post-process
+ *    settings give the same result. The colour is clamped at zero in Rec.709 after it, as the operator takes it.
+ * 3. **Hue curves**, in OkLCh. Each curve's time is the colour's OkLCh hue in degrees, 0 to 360, and is evaluated as
+ *    {@link AnimationCurve#evaluate} would; a curve with no keys does nothing. The curve holds its end keys' values
+ *    outside them, so for a seamless circle key 0 and 360 with the same value and tangent.
+ *    - {@link hue_shift}: degrees added to the hue.
+ *    - {@link hue_saturation}: a multiplier on the chroma.
+ *    - {@link hue_lightness}: stops of exposure, the light multiplied by 2^stops at the same chromaticity, weighted by
+ *      the colour's saturation relative to the most saturated Rec.709 colour of its hue. A grey never moves, and a
+ *      colour on the gamut's edge takes the full value.
+ *    All three are read at the colour's hue before any of them applies.
+ *
+ * Read by the tone mapper every frame; any change bakes the LUTs again. A LUT the user supplies is not graded.
+ */
+export class ColorGrade {
+    /**
+     * Colour temperature of the white the grade makes neutral, K. 6500 does nothing.
+     * @type {number}
+     */
+    white_temperature: number;
+    /**
+     * Offset of that white along its isotherm, -1 to 1 as in Unreal. 0 does nothing.
+     * @type {number}
+     */
+    white_tint: number;
+    /**
+     * Applies in every zone, under the zone's own values.
+     * @readonly
+     * @type {ColorGradeZone}
+     */
+    readonly global: ColorGradeZone;
+    /**
+     * @readonly
+     * @type {ColorGradeZone}
+     */
+    readonly shadows: ColorGradeZone;
+    /**
+     * @readonly
+     * @type {ColorGradeZone}
+     */
+    readonly midtones: ColorGradeZone;
+    /**
+     * @readonly
+     * @type {ColorGradeZone}
+     */
+    readonly highlights: ColorGradeZone;
+    /**
+     * AP1 luma at which the shadows' weight reaches 0. Unreal's default.
+     * @type {number}
+     */
+    shadows_max: number;
+    /**
+     * AP1 luma at which the highlights' weight starts to rise from 0. Unreal's default.
+     * @type {number}
+     */
+    highlights_min: number;
+    /**
+     * AP1 luma at which the highlights' weight reaches 1. Unreal's default.
+     * @type {number}
+     */
+    highlights_max: number;
+    /**
+     * Degrees added to the OkLCh hue, against the hue in degrees.
+     * @readonly
+     * @type {AnimationCurve}
+     */
+    readonly hue_shift: AnimationCurve;
+    /**
+     * Multiplier on the OkLCh chroma, against the hue in degrees.
+     * @readonly
+     * @type {AnimationCurve}
+     */
+    readonly hue_saturation: AnimationCurve;
+    /**
+     * Stops of exposure, against the hue in degrees.
+     * @readonly
+     * @type {AnimationCurve}
+     */
+    readonly hue_lightness: AnimationCurve;
+    /**
+     * The grade as the bake reads it: {@link COLOR_GRADE_STRUCT}, then the three curves' keys, each
+     * {@link COLOR_GRADE_KEY_FLOATS} floats, with room for one key when there are none. The array is reused while the
+     * key count stays the same.
+     *
+     * @returns {Float32Array}
+     */
+    pack(): Float32Array;
+    #private;
+}
+import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
+import { Vector4 } from "../../../../core/geom/Vector4.js";
+import { AnimationCurve } from "../../../../engine/animation/curve/AnimationCurve.js";
+//# sourceMappingURL=ColorGrade.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ColorGrade.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/deferred/tonemap/ColorGrade.js"],"names":[],"mappings":"AAOA;;;;;;;;;;;GAWG;AACH,8CAyBG;AAEH;;;GAGG;AACH,wCAFU,MAAM,CAE4B;AAE5C;;;GAGG;AACH,qCAFU,MAAM,CAEwB;AAExC;;;GAGG;AACH;IACI;;;;OAIG;IACH,qBAFU,OAAO,CAEoB;IAErC;;;;OAIG;IACH,mBAFU,OAAO,CAEkB;IAEnC;;;;OAIG;IACH,gBAFU,OAAO,CAEe;IAEhC;;;OAGG;IACH,eAFU,OAAO,CAEc;IAE/B;;;;OAIG;IACH,iBAFU,OAAO,CAEgB;CACpC;AAwED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH;IACI;;;OAGG;IACH,mBAFU,MAAM,CAEsC;IAEtD;;;OAGG;IACH,YAFU,MAAM,CAEwB;IAExC;;;;OAIG;IACH,iBAFU,cAAc,CAEM;IAE9B;;;OAGG;IACH,kBAFU,cAAc,CAEO;IAE/B;;;OAGG;IACH,mBAFU,cAAc,CAEQ;IAEhC;;;OAGG;IACH,qBAFU,cAAc,CAEU;IAElC;;;OAGG;IACH,aAFU,MAAM,CAEG;IAEnB;;;OAGG;IACH,gBAFU,MAAM,CAEK;IAErB;;;OAGG;IACH,gBAFU,MAAM,CAEG;IAEnB;;;;OAIG;IACH,oBAFU,cAAc,CAES;IAEjC;;;;OAIG;IACH,yBAFU,cAAc,CAEc;IAEtC;;;;OAIG;IACH,wBAFU,cAAc,CAEa;IAarC;;;;;;OAMG;IACH,QAFa,YAAY,CAqDxB;;CACJ;6BA5U4B,mCAAmC;wBAHxC,kCAAkC;+BAC3B,sDAAsD"}