@woosh/meep-engine 3.64.1 → 3.67.0

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

@@ -9,6 +9,10 @@
  * - `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.
+ * - `luma_curve_counts`: the keys of the red, green, blue and all-channel saturation-against-luma curves. They follow
+ *   the hue curves' keys in `grade_keys`, in that order.
+ * - `luma_gain_counts`: the keys of the red, green and blue gain-against-luma curves and the exposure-against-luma
+ *   curve. They follow the saturation-against-luma curves' keys in `grade_keys`, in that order.
  */
 export const COLOR_GRADE_STRUCT: WebGPUStruct;
 /**
@@ -64,8 +68,20 @@ export class ColorGradeZone {
  * 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
+ *    settings give the same result.
+ * 3. **Gain against luma**, in AP1 after the primaries: each channel multiplied by its gain at the colour's AP1 luma's
+ *    stops from middle grey — {@link luma_gain_red}, {@link luma_gain_green}, {@link luma_gain_blue} — and every channel
+ *    by 2 to the power of {@link luma_exposure} there. Grading by tonal range at any luma, with any blend between ranges:
+ *    a range that fades in and out over spans of stops, as a smoothstep does, is a cubic between its edges, so ranges
+ *    sum exactly into curves keyed at their edges. A curve with no keys is a gain of 1, or an exposure of 0. Clamped at
+ *    zero.
+ * 4. **Saturation against luma**, after the gain against luma: each channel drawn away from the colour's AP1 luma by its
+ *    factor at that luma's stops from middle grey, `log2(luma / 0.18)`: {@link luma_saturation} times the channel's
+ *    own curve — {@link luma_saturation_red}, {@link luma_saturation_green}, {@link luma_saturation_blue}. Unreal's
+ *    saturation and per-channel saturation, varying across the tonal range. Each curve is evaluated as
+ *    {@link AnimationCurve#evaluate} would and holds its end keys' values beyond them; a curve with no keys is a factor
+ *    of 1, and a colour with no luma is left as it is. Clamped at zero, as the primaries' saturation is. The colour is clamped at zero in Rec.709 after it, as the operator takes it.
+ * 5. **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.
@@ -143,8 +159,61 @@ export class ColorGrade {
      */
     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
+     * Saturation of every channel against the colour's AP1 luma in stops from middle grey: 1 leaves it, 0 draws it to
+     * the luma. Each channel's own curve multiplies it.
+     * @readonly
+     * @type {AnimationCurve}
+     */
+    readonly luma_saturation: AnimationCurve;
+    /**
+     * Saturation of the red channel against the colour's AP1 luma in stops from middle grey, times
+     * {@link luma_saturation}.
+     * @readonly
+     * @type {AnimationCurve}
+     */
+    readonly luma_saturation_red: AnimationCurve;
+    /**
+     * Saturation of the green channel against the colour's AP1 luma in stops from middle grey, times
+     * {@link luma_saturation}.
+     * @readonly
+     * @type {AnimationCurve}
+     */
+    readonly luma_saturation_green: AnimationCurve;
+    /**
+     * Saturation of the blue channel against the colour's AP1 luma in stops from middle grey, times
+     * {@link luma_saturation}.
+     * @readonly
+     * @type {AnimationCurve}
+     */
+    readonly luma_saturation_blue: AnimationCurve;
+    /**
+     * Gain of the red channel against the colour's AP1 luma in stops from middle grey: 1 leaves it.
+     * @readonly
+     * @type {AnimationCurve}
+     */
+    readonly luma_gain_red: AnimationCurve;
+    /**
+     * Gain of the green channel against the colour's AP1 luma in stops from middle grey: 1 leaves it.
+     * @readonly
+     * @type {AnimationCurve}
+     */
+    readonly luma_gain_green: AnimationCurve;
+    /**
+     * Gain of the blue channel against the colour's AP1 luma in stops from middle grey: 1 leaves it.
+     * @readonly
+     * @type {AnimationCurve}
+     */
+    readonly luma_gain_blue: AnimationCurve;
+    /**
+     * Exposure of every channel against the colour's AP1 luma in stops from middle grey, in stops: 0 leaves it.
+     * @readonly
+     * @type {AnimationCurve}
+     */
+    readonly luma_exposure: AnimationCurve;
+    /**
+     * The grade as the bake reads it: {@link COLOR_GRADE_STRUCT}, then the three hue curves' keys, the four
+     * saturation-against-luma curves' keys (red, green, blue, all) and the four gain-against-luma curves' keys (red,
+     * green, blue, exposure), 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}

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

@@ -1 +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"}
+{"version":3,"file":"ColorGrade.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/deferred/tonemap/ColorGrade.js"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;;GAeG;AACH,8CA2BG;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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;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;IAErC;;;;;OAKG;IACH,0BAFU,cAAc,CAEe;IAEvC;;;;;OAKG;IACH,8BAFU,cAAc,CAEmB;IAE3C;;;;;OAKG;IACH,gCAFU,cAAc,CAEqB;IAE7C;;;;;OAKG;IACH,+BAFU,cAAc,CAEoB;IAE5C;;;;OAIG;IACH,wBAFU,cAAc,CAEa;IAErC;;;;OAIG;IACH,0BAFU,cAAc,CAEe;IAEvC;;;;OAIG;IACH,yBAFU,cAAc,CAEc;IAEtC;;;;OAIG;IACH,wBAFU,cAAc,CAEa;IAarC;;;;;;;OAOG;IACH,QAFa,YAAY,CAgFxB;;CACJ;6BAtb4B,mCAAmC;wBAHxC,kCAAkC;+BAC3B,sDAAsD"}

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

@@ -16,6 +16,10 @@ import { m3_white_balance_rec709, WHITE_BALANCE_NEUTRAL_TEMPERATURE, WHITE_BALAN
  * - `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.
+ * - `luma_curve_counts`: the keys of the red, green, blue and all-channel saturation-against-luma curves. They follow
+ *   the hue curves' keys in `grade_keys`, in that order.
+ * - `luma_gain_counts`: the keys of the red, green and blue gain-against-luma curves and the exposure-against-luma
+ *   curve. They follow the saturation-against-luma curves' keys in `grade_keys`, in that order.
  */
 export const COLOR_GRADE_STRUCT = WebGPUStruct.from({
     white_balance_c0: vec4f,
@@ -42,13 +46,15 @@ export const COLOR_GRADE_STRUCT = WebGPUStruct.from({
 
     zone_bounds: vec4f,
     curve_counts: vec4u,
+    luma_curve_counts: vec4u,
+    luma_gain_counts: vec4u,
 });
 
 /**
  * Floats of {@link COLOR_GRADE_STRUCT} at the head of {@link ColorGrade#pack}'s data.
  * @type {number}
  */
-export const COLOR_GRADE_HEADER_FLOATS = 80;
+export const COLOR_GRADE_HEADER_FLOATS = 88;
 
 /**
  * Floats of one keyframe in `grade_keys`: time, value, in tangent, out tangent.
@@ -174,8 +180,20 @@ function write_keys(out, at, curve) {
  * 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
+ *    settings give the same result.
+ * 3. **Gain against luma**, in AP1 after the primaries: each channel multiplied by its gain at the colour's AP1 luma's
+ *    stops from middle grey — {@link luma_gain_red}, {@link luma_gain_green}, {@link luma_gain_blue} — and every channel
+ *    by 2 to the power of {@link luma_exposure} there. Grading by tonal range at any luma, with any blend between ranges:
+ *    a range that fades in and out over spans of stops, as a smoothstep does, is a cubic between its edges, so ranges
+ *    sum exactly into curves keyed at their edges. A curve with no keys is a gain of 1, or an exposure of 0. Clamped at
+ *    zero.
+ * 4. **Saturation against luma**, after the gain against luma: each channel drawn away from the colour's AP1 luma by its
+ *    factor at that luma's stops from middle grey, `log2(luma / 0.18)`: {@link luma_saturation} times the channel's
+ *    own curve — {@link luma_saturation_red}, {@link luma_saturation_green}, {@link luma_saturation_blue}. Unreal's
+ *    saturation and per-channel saturation, varying across the tonal range. Each curve is evaluated as
+ *    {@link AnimationCurve#evaluate} would and holds its end keys' values beyond them; a curve with no keys is a factor
+ *    of 1, and a colour with no luma is left as it is. Clamped at zero, as the primaries' saturation is. The colour is clamped at zero in Rec.709 after it, as the operator takes it.
+ * 5. **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.
@@ -264,6 +282,66 @@ export class ColorGrade {
      */
     hue_lightness = new AnimationCurve();
 
+    /**
+     * Saturation of every channel against the colour's AP1 luma in stops from middle grey: 1 leaves it, 0 draws it to
+     * the luma. Each channel's own curve multiplies it.
+     * @readonly
+     * @type {AnimationCurve}
+     */
+    luma_saturation = new AnimationCurve();
+
+    /**
+     * Saturation of the red channel against the colour's AP1 luma in stops from middle grey, times
+     * {@link luma_saturation}.
+     * @readonly
+     * @type {AnimationCurve}
+     */
+    luma_saturation_red = new AnimationCurve();
+
+    /**
+     * Saturation of the green channel against the colour's AP1 luma in stops from middle grey, times
+     * {@link luma_saturation}.
+     * @readonly
+     * @type {AnimationCurve}
+     */
+    luma_saturation_green = new AnimationCurve();
+
+    /**
+     * Saturation of the blue channel against the colour's AP1 luma in stops from middle grey, times
+     * {@link luma_saturation}.
+     * @readonly
+     * @type {AnimationCurve}
+     */
+    luma_saturation_blue = new AnimationCurve();
+
+    /**
+     * Gain of the red channel against the colour's AP1 luma in stops from middle grey: 1 leaves it.
+     * @readonly
+     * @type {AnimationCurve}
+     */
+    luma_gain_red = new AnimationCurve();
+
+    /**
+     * Gain of the green channel against the colour's AP1 luma in stops from middle grey: 1 leaves it.
+     * @readonly
+     * @type {AnimationCurve}
+     */
+    luma_gain_green = new AnimationCurve();
+
+    /**
+     * Gain of the blue channel against the colour's AP1 luma in stops from middle grey: 1 leaves it.
+     * @readonly
+     * @type {AnimationCurve}
+     */
+    luma_gain_blue = new AnimationCurve();
+
+    /**
+     * Exposure of every channel against the colour's AP1 luma in stops from middle grey, in stops: 0 leaves it.
+     * @readonly
+     * @type {AnimationCurve}
+     */
+    luma_exposure = new AnimationCurve();
+
     /**
      * @type {Float32Array}
      */
@@ -276,8 +354,9 @@ export class ColorGrade {
     #words = new Uint32Array(this.#data.buffer);
 
     /**
-     * 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
+     * The grade as the bake reads it: {@link COLOR_GRADE_STRUCT}, then the three hue curves' keys, the four
+     * saturation-against-luma curves' keys (red, green, blue, all) and the four gain-against-luma curves' keys (red,
+     * green, blue, exposure), 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}
@@ -290,9 +369,20 @@ export class ColorGrade {
         const hue_count = this.hue_shift.keys.length;
         const saturation_count = this.hue_saturation.keys.length;
         const lightness_count = this.hue_lightness.keys.length;
+        const red_count = this.luma_saturation_red.keys.length;
+        const green_count = this.luma_saturation_green.keys.length;
+        const blue_count = this.luma_saturation_blue.keys.length;
+        const all_count = this.luma_saturation.keys.length;
+        const gain_red_count = this.luma_gain_red.keys.length;
+        const gain_green_count = this.luma_gain_green.keys.length;
+        const gain_blue_count = this.luma_gain_blue.keys.length;
+        const exposure_count = this.luma_exposure.keys.length;
+
+        const key_count = hue_count + saturation_count + lightness_count
+            + red_count + green_count + blue_count + all_count
+            + gain_red_count + gain_green_count + gain_blue_count + exposure_count;
 
-        const length = COLOR_GRADE_HEADER_FLOATS
-            + COLOR_GRADE_KEY_FLOATS * Math.max(1, hue_count + saturation_count + lightness_count);
+        const length = COLOR_GRADE_HEADER_FLOATS + COLOR_GRADE_KEY_FLOATS * Math.max(1, key_count);
 
         if (this.#data.length !== length) {
             this.#data = new Float32Array(length);
@@ -324,11 +414,27 @@ export class ColorGrade {
         words[77] = saturation_count;
         words[78] = lightness_count;
         words[79] = 0;
+        words[80] = red_count;
+        words[81] = green_count;
+        words[82] = blue_count;
+        words[83] = all_count;
+        words[84] = gain_red_count;
+        words[85] = gain_green_count;
+        words[86] = gain_blue_count;
+        words[87] = exposure_count;
 
         let at = COLOR_GRADE_HEADER_FLOATS;
         at = write_keys(out, at, this.hue_shift);
         at = write_keys(out, at, this.hue_saturation);
         at = write_keys(out, at, this.hue_lightness);
+        at = write_keys(out, at, this.luma_saturation_red);
+        at = write_keys(out, at, this.luma_saturation_green);
+        at = write_keys(out, at, this.luma_saturation_blue);
+        at = write_keys(out, at, this.luma_saturation);
+        at = write_keys(out, at, this.luma_gain_red);
+        at = write_keys(out, at, this.luma_gain_green);
+        at = write_keys(out, at, this.luma_gain_blue);
+        at = write_keys(out, at, this.luma_exposure);
 
         out.fill(0, at);
 

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

@@ -0,0 +1,12 @@
+/**
+ * Whether the tone mapper applies the Purkinje shift to the scene colour ahead of its LUT. Decided by
+ * `chunk_tonemap_purkinje`, whose `false` alternative, the default, is the colour as it is and binds nothing more, so
+ * a pass that never sets it draws exactly as it would without the shift.
+ *
+ * `ToneMapper` sets it from `ToneMapper#purkinje_shift` the frame it records the pass.
+ *
+ * @type {ShaderSwitch}
+ */
+export const TONEMAP_PURKINJE_SHIFT: ShaderSwitch;
+import { ShaderSwitch } from "../../shader/compiler/ShaderSwitch.js";
+//# sourceMappingURL=TONEMAP_PURKINJE_SHIFT.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"TONEMAP_PURKINJE_SHIFT.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/deferred/tonemap/TONEMAP_PURKINJE_SHIFT.js"],"names":[],"mappings":"AAEA;;;;;;;;GAQG;AACH,qCAFU,YAAY,CAE4D;6BAXrD,uCAAuC"}

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

@@ -0,0 +1,12 @@
+import { ShaderSwitch } from "../../shader/compiler/ShaderSwitch.js";
+
+/**
+ * Whether the tone mapper applies the Purkinje shift to the scene colour ahead of its LUT. Decided by
+ * `chunk_tonemap_purkinje`, whose `false` alternative, the default, is the colour as it is and binds nothing more, so
+ * a pass that never sets it draws exactly as it would without the shift.
+ *
+ * `ToneMapper` sets it from `ToneMapper#purkinje_shift` the frame it records the pass.
+ *
+ * @type {ShaderSwitch}
+ */
+export const TONEMAP_PURKINJE_SHIFT = ShaderSwitch.bool('tonemap purkinje shift');

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

@@ -9,6 +9,9 @@
  * A LUT comes from {@link grade} and {@link operator}, baked at {@link lut_resolution} and baked again when any of them
  * changes or, for the HDR LUT, when the display's peak does; or from the user, by {@link set_lut_sdr} and
  * {@link set_lut_hdr}, which takes the place of the bake for that output until cleared. A user's LUT is not graded.
+ *
+ * Ahead of the LUT, the scene colour goes through the Purkinje shift where {@link purkinje_shift} is on, at the
+ * luminance the view is adapted to. The shift is not baked into the LUT, so it applies to a user's LUT as well.
  */
 export class ToneMapper {
     /**
@@ -32,6 +35,13 @@ export class ToneMapper {
      * @type {ColorGrade}
      */
     readonly grade: ColorGrade;
+    /**
+     * Whether the scene colour goes through the Purkinje shift ahead of the LUT: below 5 cd/m² of adaptation the colour
+     * moves towards the rods' response, carried by a blue tint, and below 0.005 cd/m² it is that alone; see
+     * `chunk_apply_purkinje_shift`. Off unless set. Read every frame.
+     * @type {boolean}
+     */
+    purkinje_shift: boolean;
     /**
      * The canvas's primaries and the display's peak, which the Renderer writes.
      * @readonly
@@ -84,14 +94,17 @@ export class ToneMapper {
      * @param {FrameGraph} options.graph
      * @param {number} options.input_color the scene colour, linear Rec.709
      * @param {number} options.exposure the exposure multiplier, a uniform
+     * @param {number} options.adaptation the luminance the view is adapted to, cd/m², a uniform; read where
+     *        {@link purkinje_shift} is on
      * @param {boolean} options.hdr whether the output is HDR
      * @param {number} options.target the texture to write
      * @returns {number} `target`, written
      */
-    render({ graph, input_color, exposure, hdr, target }: {
+    render({ graph, input_color, exposure, adaptation, hdr, target }: {
         graph: FrameGraph;
         input_color: number;
         exposure: number;
+        adaptation: number;
         hdr: boolean;
         target: number;
     }): number;
@@ -99,6 +112,7 @@ export class ToneMapper {
     #private;
 }
 export type ToneMapOperator = import("./ToneMapOperator.js").ToneMapOperator;
+export type ImageShader = import("../../shader/ImageShader.js").ImageShader;
 export type PipelineEnquiry = import("../../../device/pipeline/PipelineEnquiry.js").PipelineEnquiry;
 export type FrameGraph = import("../../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph;
 import { ColorGrade } from "./ColorGrade.js";

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

@@ -1 +1 @@
-{"version":3,"file":"ToneMapper.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/deferred/tonemap/ToneMapper.js"],"names":[],"mappings":"AA6FA;;;;;;;;;;;GAWG;AACH;IAmEI;;OAEG;IACH,+BAMC;IA3ED;;;OAGG;IACH,UAFU,eAAe,CAES;IAElC;;;;OAIG;IACH,gBAFU,MAAM,CAEI;IAEpB;;;;OAIG;IACH,gBAFU,UAAU,CAEK;IAEzB;;;;OAIG;IACH,kBAFU,sBAAsB,CAEO;IAoDvC;;;;;OAKG;IACH,wBAHW,MAAM,QACN,YAAY,QAKtB;IAED;;;;;;;OAOG;IACH,wBAJW,MAAM,QACN,YAAY,aACZ,MAAM,QAQhB;IAED;;OAEG;IACH,sBAIC;IAED;;OAEG;IACH,sBAGC;IAED;;;;;OAKG;IACH,+BASC;IAED;;;;;;OAMG;IACH,2BAJW,eAAe,OACf,OAAO,kCAMjB;IAED;;;;;;;;;;OAUG;IACH;QAP+B,KAAK,EAAzB,UAAU;QACM,WAAW,EAA3B,MAAM;QACU,QAAQ,EAAxB,MAAM;QACW,GAAG,EAApB,OAAO;QACS,MAAM,EAAtB,MAAM;QACJ,MAAM,CAyElB;IAED,gBAGC;;CAkIJ;8BAzcY,OAAO,sBAAsB,EAAE,eAAe;8BAC9C,OAAO,6CAA6C,EAAE,eAAe;yBACrE,OAAO,8DAA8D,EAAE,UAAU;2BAXxC,iBAAiB;uCAMhC,6BAA6B"}
+{"version":3,"file":"ToneMapper.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/deferred/tonemap/ToneMapper.js"],"names":[],"mappings":"AAgGA;;;;;;;;;;;;;;GAcG;AACH;IA2EI;;OAEG;IACH,+BAMC;IAnFD;;;OAGG;IACH,UAFU,eAAe,CAES;IAElC;;;;OAIG;IACH,gBAFU,MAAM,CAEI;IAEpB;;;;OAIG;IACH,gBAFU,UAAU,CAEK;IAEzB;;;;;OAKG;IACH,gBAFU,OAAO,CAEM;IAEvB;;;;OAIG;IACH,kBAFU,sBAAsB,CAEO;IAoDvC;;;;;OAKG;IACH,wBAHW,MAAM,QACN,YAAY,QAKtB;IAED;;;;;;;OAOG;IACH,wBAJW,MAAM,QACN,YAAY,aACZ,MAAM,QAQhB;IAED;;OAEG;IACH,sBAIC;IAED;;OAEG;IACH,sBAGC;IAED;;;;;OAKG;IACH,+BASC;IAED;;;;;;OAMG;IACH,2BAJW,eAAe,OACf,OAAO,kCAMjB;IAED;;;;;;;;;;;;OAYG;IACH;QAT+B,KAAK,EAAzB,UAAU;QACM,WAAW,EAA3B,MAAM;QACU,QAAQ,EAAxB,MAAM;QACU,UAAU,EAA1B,MAAM;QAEW,GAAG,EAApB,OAAO;QACS,MAAM,EAAtB,MAAM;QACJ,MAAM,CA2ElB;IAYD,gBAGC;;CAkIJ;8BAneY,OAAO,sBAAsB,EAAE,eAAe;0BAC9C,OAAO,6BAA6B,EAAE,WAAW;8BACjD,OAAO,6CAA6C,EAAE,eAAe;yBACrE,OAAO,8DAA8D,EAAE,UAAU;2BAbxC,iBAAiB;uCAOhC,6BAA6B"}

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

@@ -1,5 +1,6 @@
 import { assert } from "../../../../core/assert.js";
 import { PAPER_WHITE_NITS } from "../../shader/chunk/color/tonemap/chunk_PAPER_WHITE_NITS.js";
+import { ShaderSwitchSet } from "../../shader/compiler/ShaderSwitchSet.js";
 import { graph_compute_pass } from "../../shader/graph/compute/graph_compute_pass.js";
 import { graph_image_pass } from "../../shader/graph/graph_image_pass.js";
 import { graph_import_raw_buffer } from "../../shader/graph/graph_import_raw_buffer.js";
@@ -11,10 +12,12 @@ import { shader_tonemap_LDR_lut } from "./shader_tonemap_LDR_lut.js";
 import { shader_tonemap_lut_bake, TONEMAP_LUT_BAKE_GROUP } from "./shader_tonemap_lut_bake.js";
 import { shader_tonemap_lut_sdr_from_hdr } from "./shader_tonemap_lut_sdr_from_hdr.js";
 import { TONE_MAP_OPERATOR_ACES } from "./TONE_MAP_OPERATOR_ACES.js";
+import { TONEMAP_PURKINJE_SHIFT } from "./TONEMAP_PURKINJE_SHIFT.js";
 import { TonemapDisplaySettings } from "./TonemapDisplaySettings.js";
 
 /**
  * @typedef {import("./ToneMapOperator.js").ToneMapOperator} ToneMapOperator
+ * @typedef {import("../../shader/ImageShader.js").ImageShader} ImageShader
  * @typedef {import("../../../device/pipeline/PipelineEnquiry.js").PipelineEnquiry} PipelineEnquiry
  * @typedef {import("../../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph} FrameGraph
  */
@@ -102,6 +105,9 @@ function same_words(a, b) {
  * A LUT comes from {@link grade} and {@link operator}, baked at {@link lut_resolution} and baked again when any of them
  * changes or, for the HDR LUT, when the display's peak does; or from the user, by {@link set_lut_sdr} and
  * {@link set_lut_hdr}, which takes the place of the bake for that output until cleared. A user's LUT is not graded.
+ *
+ * Ahead of the LUT, the scene colour goes through the Purkinje shift where {@link purkinje_shift} is on, at the
+ * luminance the view is adapted to. The shift is not baked into the LUT, so it applies to a user's LUT as well.
  */
 export class ToneMapper {
     /**
@@ -124,6 +130,14 @@ export class ToneMapper {
      */
     grade = new ColorGrade();
 
+    /**
+     * Whether the scene colour goes through the Purkinje shift ahead of the LUT: below 5 cd/m² of adaptation the colour
+     * moves towards the rods' response, carried by a blue tint, and below 0.005 cd/m² it is that alone; see
+     * `chunk_apply_purkinje_shift`. Off unless set. Read every frame.
+     * @type {boolean}
+     */
+    purkinje_shift = false;
+
     /**
      * The canvas's primaries and the display's peak, which the Renderer writes.
      * @readonly
@@ -250,7 +264,7 @@ export class ToneMapper {
      * @param {GPUTextureFormat} format the canvas's
      */
     enquire_pipelines(enquiry, hdr, format) {
-        enquiry.render.push(apply_shader(hdr).pipeline_for([format]));
+        enquiry.render.push(this.#apply_shader(hdr).pipeline_for([format]));
         enquiry.compute.push(shader_tonemap_lut_bake(this.operator).pipeline);
     }
 
@@ -261,12 +275,15 @@ export class ToneMapper {
      * @param {FrameGraph} options.graph
      * @param {number} options.input_color the scene colour, linear Rec.709
      * @param {number} options.exposure the exposure multiplier, a uniform
+     * @param {number} options.adaptation the luminance the view is adapted to, cd/m², a uniform; read where
+     *        {@link purkinje_shift} is on
      * @param {boolean} options.hdr whether the output is HDR
      * @param {number} options.target the texture to write
      * @returns {number} `target`, written
      */
-    render({ graph, input_color, exposure, hdr, target }) {
+    render({ graph, input_color, exposure, adaptation, hdr, target }) {
         assert.isBoolean(hdr, 'hdr');
+        assert.isNonNegativeInteger(adaptation, 'adaptation');
 
         const lut = hdr ? this.#hdr : this.#sdr;
         const peak_nits = hdr ? this.display.peak_nits : PAPER_WHITE_NITS;
@@ -325,10 +342,11 @@ export class ToneMapper {
 
         const [written] = graph_image_pass({
             graph,
-            shader: apply_shader(hdr),
+            shader: this.#apply_shader(hdr),
             inputs: {
                 input_color,
                 exposure,
+                adaptation,
                 settings: this.display,
                 lut: gr_lut,
             },
@@ -338,6 +356,16 @@ export class ToneMapper {
         return written;
     }
 
+    /**
+     * The pass that writes the canvas for this output, as {@link purkinje_shift} makes it.
+     *
+     * @param {boolean} hdr
+     * @returns {ImageShader}
+     */
+    #apply_shader(hdr) {
+        return apply_shader(hdr).variant(ShaderSwitchSet.EMPTY.with(TONEMAP_PURKINJE_SHIFT, this.purkinje_shift));
+    }
+
     destroy() {
         this.#sdr.texture.destroy();
         this.#hdr.texture.destroy();

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

@@ -0,0 +1,25 @@
+/**
+ * `adaptation`, {@link F32_CONTAINER_STRUCT}: the luminance the view is adapted to, cd/m² —
+ * `GPUCameraExposureManager#adaptation`.
+ *
+ * @type {ShaderResourceDescriptor}
+ */
+export const TONEMAP_ADAPTATION_RESOURCE: ShaderResourceDescriptor;
+/**
+ * The scene colour as the tone mapper's LUT takes it, by {@link TONEMAP_PURKINJE_SHIFT}:
+ *
+ * ```wgsl
+ * fn tonemap_purkinje(color: vec3<f32>) -> vec3<f32> // color: scene-linear Rec.709
+ * ```
+ *
+ * - `false`, the default: the colour as it is.
+ * - `true`: the colour through `apply_purkinje_shift` at the view's adaptation, {@link TONEMAP_ADAPTATION_RESOURCE}.
+ *
+ * The shift is linear in the colour, so the function may be applied ahead of the exposure or after it.
+ *
+ * @type {CodeChunkChoice}
+ */
+export const chunk_tonemap_purkinje: CodeChunkChoice;
+import { ShaderResourceDescriptor } from "../../shader/resource/ShaderResourceDescriptor.js";
+import { CodeChunkChoice } from "../../shader/compiler/CodeChunkChoice.js";
+//# sourceMappingURL=chunk_tonemap_purkinje.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_tonemap_purkinje.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/deferred/tonemap/chunk_tonemap_purkinje.js"],"names":[],"mappings":"AAOA;;;;;GAKG;AACH,0CAFU,wBAAwB,CAE8E;AAEhH;;;;;;;;;;;;;GAaG;AACH,qCAFU,eAAe,CAE0D;yCA1B1C,mDAAmD;gCAD5D,0CAA0C"}

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

@@ -0,0 +1,51 @@
+import { chunk_apply_purkinje_shift } from "../../shader/chunk/color/tonemap/purkinje/chunk_apply_purkinje_shift.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { CodeChunkChoice } from "../../shader/compiler/CodeChunkChoice.js";
+import { ShaderResourceDescriptor } from "../../shader/resource/ShaderResourceDescriptor.js";
+import { F32_CONTAINER_STRUCT } from "../../shader/type/F32_CONTAINER_STRUCT.js";
+import { TONEMAP_PURKINJE_SHIFT } from "./TONEMAP_PURKINJE_SHIFT.js";
+
+/**
+ * `adaptation`, {@link F32_CONTAINER_STRUCT}: the luminance the view is adapted to, cd/m² —
+ * `GPUCameraExposureManager#adaptation`.
+ *
+ * @type {ShaderResourceDescriptor}
+ */
+export const TONEMAP_ADAPTATION_RESOURCE = ShaderResourceDescriptor.uniform("adaptation", F32_CONTAINER_STRUCT);
+
+/**
+ * The scene colour as the tone mapper's LUT takes it, by {@link TONEMAP_PURKINJE_SHIFT}:
+ *
+ * ```wgsl
+ * fn tonemap_purkinje(color: vec3<f32>) -> vec3<f32> // color: scene-linear Rec.709
+ * ```
+ *
+ * - `false`, the default: the colour as it is.
+ * - `true`: the colour through `apply_purkinje_shift` at the view's adaptation, {@link TONEMAP_ADAPTATION_RESOURCE}.
+ *
+ * The shift is linear in the colour, so the function may be applied ahead of the exposure or after it.
+ *
+ * @type {CodeChunkChoice}
+ */
+export const chunk_tonemap_purkinje = CodeChunkChoice.from(TONEMAP_PURKINJE_SHIFT);
+
+const unshifted = CodeChunk.from(
+    //language=WGSL
+    `
+fn tonemap_purkinje(color: vec3<f32>) -> vec3<f32> {
+    return color;
+}
+`);
+
+const shifted = CodeChunk.from(
+    //language=WGSL
+    `
+fn tonemap_purkinje(color: vec3<f32>) -> vec3<f32> {
+    return apply_purkinje_shift(color, adaptation.value);
+}
+`, [chunk_apply_purkinje_shift]);
+
+shifted.requireResource(TONEMAP_ADAPTATION_RESOURCE);
+
+chunk_tonemap_purkinje.add(false, unshifted);
+chunk_tonemap_purkinje.add(true, shifted);

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

@@ -1,6 +1,6 @@
 /**
- * The HDR output of {@link ToneMapper}: exposure, then the HDR LUT, written in the canvas's primaries, extended, where
- * 1.0 is SDR white.
+ * The HDR output of {@link ToneMapper}: the Purkinje shift where `TONEMAP_PURKINJE_SHIFT` is on, exposure, then the
+ * HDR LUT, written in the canvas's primaries, extended, where 1.0 is SDR white.
  *
  * @type {ImageShader}
  */

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

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

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

@@ -6,6 +6,7 @@ import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourc
 import { ShaderDescriptor } from "../../shader/ShaderDescriptor.js";
 import { F32_CONTAINER_STRUCT } from "../../shader/type/F32_CONTAINER_STRUCT.js";
 import { SAMPLER_TONEMAP_LUT } from "./SAMPLER_TONEMAP_LUT.js";
+import { chunk_tonemap_purkinje, TONEMAP_ADAPTATION_RESOURCE } from "./chunk_tonemap_purkinje.js";
 import { TONEMAP_SETTINGS } from "./TonemapDisplaySettings.js";
 
 const resources = new ShaderResourceSetDescriptor();
@@ -14,6 +15,7 @@ resources.setImmediate("settings", TONEMAP_SETTINGS);
 resources.createGroup()
     .addTexture("input_color", "float")
     .addUniform("exposure", F32_CONTAINER_STRUCT)
+    .add(TONEMAP_ADAPTATION_RESOURCE)
     .addTexture("lut", "float", "3d")
     .addSampler("lut_sampler", "filtering", SAMPLER_TONEMAP_LUT)
 
@@ -26,7 +28,7 @@ fn main(
 ) -> @location(0) vec4<f32> {
 
     // scene color in linear Rec. 709
-    let color = textureLoad(input_color, vec2i(coord.xy), 0).rgb * exposure.value;
+    let color = tonemap_purkinje(textureLoad(input_color, vec2i(coord.xy), 0).rgb) * exposure.value;
 
     let uvw = tonemap_lut_coordinate(color, f32(textureDimensions(lut).x));
     let color_2020 = tonemap_lut_pq_decode(textureSampleLevel(lut, lut_sampler, uvw, 0.0).rgb);
@@ -44,14 +46,15 @@ fn main(
     return vec4(sRGBTransferOETF(color_display), 1.0);
 }
     `, [
+        chunk_tonemap_purkinje,
         chunk_tonemap_lut,
         chunk_sRGBTransferOETF,
     ]
 );
 
 /**
- * The HDR output of {@link ToneMapper}: exposure, then the HDR LUT, written in the canvas's primaries, extended, where
- * 1.0 is SDR white.
+ * The HDR output of {@link ToneMapper}: the Purkinje shift where `TONEMAP_PURKINJE_SHIFT` is on, exposure, then the
+ * HDR LUT, written in the canvas's primaries, extended, where 1.0 is SDR white.
  *
  * @type {ImageShader}
  */

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

@@ -1,6 +1,7 @@
 /**
- * The SDR output of {@link ToneMapper}: exposure, then the SDR LUT, the canvas's primaries, the sRGB transfer curve
- * and an 8-bit dither. The 8-bit target clips anything the LUT puts past SDR white.
+ * The SDR output of {@link ToneMapper}: the Purkinje shift where `TONEMAP_PURKINJE_SHIFT` is on, exposure, then the
+ * SDR LUT, the canvas's primaries, the sRGB transfer curve and an 8-bit dither. The 8-bit target clips anything the
+ * LUT puts past SDR white.
  *
  * @type {ImageShader}
  */

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

@@ -1 +1 @@
-{"version":3,"file":"shader_tonemap_LDR_lut.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/deferred/tonemap/shader_tonemap_LDR_lut.js"],"names":[],"mappings":"AA0DA;;;;;GAKG;AACH,qCAFU,WAAW,CAclB;4BAtEyB,6BAA6B"}
+{"version":3,"file":"shader_tonemap_LDR_lut.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/deferred/tonemap/shader_tonemap_LDR_lut.js"],"names":[],"mappings":"AA6DA;;;;;;GAMG;AACH,qCAFU,WAAW,CAclB;4BA1EyB,6BAA6B"}