@woosh/meep-engine 3.65.0 → 3.68.0

package/src/shade/renderer/atmosphere/shader_sky_view_lut.js

@@ -0,0 +1,111 @@
+import { CAMERA_UNIFORM_STRUCT } from "../camera/CAMERA_UNIFORM_STRUCT.js";
+import { chunk_mat4_extract_position } from "../shader/chunk/geometry/mat4/chunk_mat4_extract_position.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 { u32, vec3f } from "../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUStruct } from "../shader/type/WebGPUStruct.js";
+import { ATMOSPHERE_PARAMETERS_STRUCT } from "./ATMOSPHERE_PARAMETERS_STRUCT.js";
+import { chunk_raymarch_sky_scattering } from "./chunk_raymarch_sky_scattering.js";
+import { chunk_sky_irradiance_lut_encode_uv } from "./chunk_sky_irradiance_lut_encode_uv.js";
+import {
+    SKY_LUT_MULTISCATTER_RESOURCE,
+    SKY_LUT_SAMPLER_RESOURCE,
+    SKY_LUT_TRANSMITTANCE_RESOURCE
+} from "./SAMPLER_SKY_LUT.js";
+
+export const SKY_VIEW_LUT_WIDTH = 192;
+export const SKY_VIEW_LUT_HEIGHT = 108;
+
+export const SKY_VIEW_LUT_SETTINGS_STRUCT = WebGPUStruct.from({
+    sun_direction: vec3f,
+    resolution_x: u32,
+    sun_irradiance: vec3f,
+    resolution_y: u32,
+}, "SkyViewLutSettings");
+
+const resources = new ShaderResourceSetDescriptor();
+
+resources.setImmediate("settings", SKY_VIEW_LUT_SETTINGS_STRUCT);
+
+resources.createGroup()
+    .addUniform("camera", CAMERA_UNIFORM_STRUCT)
+    .addUniform("atmosphere", ATMOSPHERE_PARAMETERS_STRUCT)
+    .add(SKY_LUT_TRANSMITTANCE_RESOURCE)
+    .add(SKY_LUT_MULTISCATTER_RESOURCE)
+    .add(SKY_LUT_SAMPLER_RESOURCE);
+
+/**
+ * Per-view $192 \times 108$ horizon-warped Sky-View LUT generator (Hillaire 2020, §5.3).
+ *
+ * Evaluates scattering in the camera's local planet-up frame where `up = +Y` and the sun lies in
+ * the `+X/+Y` half-plane, matching {@link chunk_sky_irradiance_lut_encode_uv}.
+ *
+ * @type {CodeChunk}
+ */
+const body = CodeChunk.from(
+    //language=WGSL
+    `
+@fragment
+fn main(
+    @builtin(position) coord: vec4<f32>,
+) -> @location(0) vec4<f32> {
+    let sun_len_sq = dot(settings.sun_direction, settings.sun_direction);
+    if (sun_len_sq <= 1e-12 || all(settings.sun_irradiance <= vec3<f32>(0.0))) {
+        return vec4<f32>(0.0, 0.0, 0.0, 1.0);
+    }
+
+    let sun_dir_world = settings.sun_direction * inverseSqrt(sun_len_sq);
+
+    let view_pos = mat4_extract_position(camera.transform);
+    let view_rel_world = atmosphere_clamped_observer_relative(atmosphere, view_pos);
+    let observer_radius = length(view_rel_world);
+    let up_world = view_rel_world / observer_radius;
+
+    let resolution = vec2<f32>(f32(settings.resolution_x), f32(settings.resolution_y));
+    let decoded = sky_view_lut_decode_texel(
+        atmosphere.planet_radius,
+        observer_radius,
+        floor(coord.xy),
+        resolution
+    );
+
+    let sun_cos_zenith = clamp(dot(sun_dir_world, up_world), -1.0, 1.0);
+    let sun_sin_zenith = sqrt(max(1.0 - sun_cos_zenith * sun_cos_zenith, 0.0));
+    let sun_local = vec3<f32>(sun_sin_zenith, sun_cos_zenith, 0.0);
+
+    let view_rel_local = vec3<f32>(0.0, observer_radius, 0.0);
+    let bounds = atmosphere_ray_bounds_for(atmosphere, view_rel_local, decoded.ray_local);
+
+    let lum = raymarch_sky_scattering(
+        atmosphere,
+        view_rel_local,
+        decoded.ray_local,
+        sun_local,
+        bounds.t_max,
+        decoded.hits_ground && bounds.hits_ground
+    );
+
+    return vec4<f32>(lum * settings.sun_irradiance, 1.0);
+}
+    `, [
+        chunk_mat4_extract_position,
+        chunk_sky_irradiance_lut_encode_uv,
+        chunk_raymarch_sky_scattering,
+    ]
+);
+
+export const shader_sky_view_lut = new ImageShader({
+    descriptor: ShaderDescriptor.from({
+        label: "Sky / sky-view LUT",
+        resources,
+        body,
+    }),
+    targets: [
+        {
+            label: "sky_view_lut",
+            format: "rgba16float",
+        }
+    ]
+});

package/src/shade/renderer/atmosphere/shader_transmittance_lut.d.ts

@@ -1,5 +1,4 @@
 /**
- * @see https://www.shadertoy.com/view/slSXRW
  * @type {ImageShader}
  */
 export const shader_transmittance_lut: ImageShader;

package/src/shade/renderer/atmosphere/shader_transmittance_lut.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_transmittance_lut.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/atmosphere/shader_transmittance_lut.js"],"names":[],"mappings":"AAgEA;;;GAGG;AACH,uCAFU,WAAW,CAWlB;4BAtEyB,0BAA0B"}
+{"version":3,"file":"shader_transmittance_lut.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/atmosphere/shader_transmittance_lut.js"],"names":[],"mappings":"AAuDA;;GAEG;AACH,uCAFU,WAAW,CAWlB;4BAhEyB,0BAA0B"}

package/src/shade/renderer/atmosphere/shader_transmittance_lut.js

@@ -1,79 +1,68 @@
-import { u32, vec2u } from "../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
-import { WebGPUStruct } from "../shader/type/WebGPUStruct.js";
-import { ATMOSPHERE_HEIGHT_DECLARATION } from "../shader/chunk/atmosphere/ATMOSPHERE_HEIGHT_DECLARATION.js";
-import { chunk_get_sun_transmittance } from "../shader/chunk/atmosphere/chunk_get_sun_transmittance.js";
-import { chunk_safe_acos } from "../shader/chunk/math/chunk_safe_acos.js";
-import { chunk_sky_lut_texel_to_unit } from "./chunk_sky_lut_texel_to_unit.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 TRANSMITTANCE_LUT_SETTINGS_STRUCT = WebGPUStruct.from({
-    // how many ray-marching steps to take per pixel of LUT, more steps = higher accuracy but lower performance
-    steps: u32,
-    // size of the target being written, which a fragment shader cannot ask for. Needed to
-    // know which point of the parameter range each texel stands for -- see
-    // chunk_sky_lut_texel_to_unit. Pass the dimensions of the texture actually being drawn
-    // into: a mismatch silently skews the whole LUT.
-    resolution: vec2u,
-});
-
-const resources = new ShaderResourceSetDescriptor();
-
-// per-pass, 16 bytes, read-only: immediate data rather than a uniform buffer
-resources.setImmediate("settings", TRANSMITTANCE_LUT_SETTINGS_STRUCT);
-
-/**
- * @see https://www.shadertoy.com/view/slSXRW
- * @type {CodeChunk}
- */
-const body = CodeChunk.from(
-    //language=WGSL
-    `
-
-@fragment
-fn main(
-    @builtin(position) coord: vec4<f32>,
-) -> @location(0) vec4<f32> {
-
-    // coord.xy is the fragment centre, so flooring it gives this texel's index. The point of
-    // each range the texel stands for then comes from sky_lut_texel_to_unit, whose inverse
-    // sky_lut_uv every lookup goes through -- a generator that skipped it would write a LUT
-    // addressed half a texel off at both ends.
-    let unit = sky_lut_texel_to_unit(floor(coord.xy), vec2<f32>(settings.resolution));
-
-    let sunCosTheta = 2.0*unit.x - 1.0;
-    let sunTheta = safe_acos(sunCosTheta);
-
-    let height = ATMOSPHERE_HEIGHT*unit.y;
-    
-    let pos = vec3(0.0, height, 0.0); 
-    let sunDir = normalize(vec3(0.0, sunCosTheta, -sin(sunTheta)));
-    
-    return vec4(get_sun_transmittance(pos, sunDir, f32(settings.steps)), 1.0);
-
-}
-    `, [
-        chunk_get_sun_transmittance,
-        chunk_safe_acos,
-        chunk_sky_lut_texel_to_unit,
-        ATMOSPHERE_HEIGHT_DECLARATION,
-    ]
-);
-
-/**
- * @see https://www.shadertoy.com/view/slSXRW
- * @type {ImageShader}
- */
-export const shader_transmittance_lut = new ImageShader({
-    descriptor: ShaderDescriptor.from({
-        label: "Sky / transmittance LUT",
-        resources,
-        body
-    }),
-    targets: [{
-        format: "rgba16float",
-    }]
-});
-
+import { chunk_get_sun_transmittance } from "../shader/chunk/atmosphere/chunk_get_sun_transmittance.js";
+import { chunk_safe_acos } from "../shader/chunk/math/chunk_safe_acos.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 { u32, vec2u } from "../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUStruct } from "../shader/type/WebGPUStruct.js";
+import { ATMOSPHERE_PARAMETERS_STRUCT } from "./ATMOSPHERE_PARAMETERS_STRUCT.js";
+import { chunk_sky_lut_texel_to_unit } from "./chunk_sky_lut_texel_to_unit.js";
+
+const TRANSMITTANCE_LUT_SETTINGS_STRUCT = WebGPUStruct.from({
+    steps: u32,
+    resolution: vec2u,
+}, "TransmittanceLutSettings");
+
+const resources = new ShaderResourceSetDescriptor();
+
+resources.setImmediate("settings", TRANSMITTANCE_LUT_SETTINGS_STRUCT);
+resources.createGroup()
+    .addUniform("atmosphere", ATMOSPHERE_PARAMETERS_STRUCT);
+
+/**
+ * Transmittance LUT generator (`256×64` `rgba16float`), parameterised by `(sunCosTheta, altitude)`
+ * and driven by the scene's {@link ATMOSPHERE_PARAMETERS_STRUCT} uniform.
+ *
+ * @see "A Scalable and Production Ready Sky and Atmosphere Rendering Technique", Hillaire (2020)
+ * @type {CodeChunk}
+ */
+const body = CodeChunk.from(
+    //language=WGSL
+    `
+@fragment
+fn main(
+    @builtin(position) coord: vec4<f32>,
+) -> @location(0) vec4<f32> {
+    let unit = sky_lut_texel_to_unit(floor(coord.xy), vec2<f32>(settings.resolution));
+
+    let sunCosTheta = 2.0 * unit.x - 1.0;
+    let sunTheta = safe_acos(sunCosTheta);
+
+    let height = atmosphere.atmosphere_height * unit.y;
+
+    let origin_rel = vec3<f32>(0.0, atmosphere.planet_radius + height, 0.0);
+    let sunDir = normalize(vec3<f32>(0.0, sunCosTheta, -sin(sunTheta)));
+
+    return vec4<f32>(get_sun_transmittance_rel_for(atmosphere, origin_rel, sunDir, f32(settings.steps)), 1.0);
+}
+    `, [
+        chunk_get_sun_transmittance,
+        chunk_safe_acos,
+        chunk_sky_lut_texel_to_unit,
+    ]
+);
+
+/**
+ * @type {ImageShader}
+ */
+export const shader_transmittance_lut = new ImageShader({
+    descriptor: ShaderDescriptor.from({
+        label: "Sky / transmittance LUT",
+        resources,
+        body
+    }),
+    targets: [{
+        format: "rgba16float",
+    }]
+});

package/src/shade/renderer/deferred/shader_background.js

@@ -1,6 +1,6 @@
 import { SamplerDescriptor } from "../../descriptor/texture/SamplerDescriptor.js";
 import { CAMERA_UNIFORM_STRUCT } from "../camera/CAMERA_UNIFORM_STRUCT.js";
-import { chunk_sample_environment_color } from "../atmosphere/chunk_sample_environment_color.js";
+import { chunk_sample_environment_color } from "../light/environment/chunk_sample_environment_color.js";
 import { chunk_uv_to_ndc } from "../shader/chunk/texture/chunk_uv_to_ndc.js";
 import { CodeChunk } from "../shader/compiler/CodeChunk.js";
 import { ImageShader } from "../shader/ImageShader.js";

package/src/shade/renderer/deferred/shader_background_sky.d.ts

@@ -0,0 +1,5 @@
+export const SKY_BACKGROUND_SETTINGS_STRUCT: WebGPUStruct;
+export const shader_background_sky: ImageShader;
+import { WebGPUStruct } from "../shader/type/WebGPUStruct.js";
+import { ImageShader } from "../shader/ImageShader.js";
+//# sourceMappingURL=shader_background_sky.d.ts.map

package/src/shade/renderer/deferred/shader_background_sky.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shader_background_sky.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/deferred/shader_background_sky.js"],"names":[],"mappings":"AAeA,0DAK4B;AA6F5B,gDAgBG;6BApH0B,gCAAgC;4BAJjC,0BAA0B"}

package/src/shade/renderer/deferred/shader_background_sky.js

@@ -0,0 +1,130 @@
+import { ATMOSPHERE_PARAMETERS_STRUCT } from "../atmosphere/ATMOSPHERE_PARAMETERS_STRUCT.js";
+import { chunk_sample_transmittance_lut_params_for } from "../atmosphere/chunk_sample_transmittance_lut.js";
+import { chunk_sky_irradiance_lut_encode_uv } from "../atmosphere/chunk_sky_irradiance_lut_encode_uv.js";
+import { SKY_LUT_SAMPLER_RESOURCE, SKY_LUT_TRANSMITTANCE_RESOURCE } from "../atmosphere/SAMPLER_SKY_LUT.js";
+import { CAMERA_UNIFORM_STRUCT } from "../camera/CAMERA_UNIFORM_STRUCT.js";
+import { chunk_mat4_extract_position } from "../shader/chunk/geometry/mat4/chunk_mat4_extract_position.js";
+import { PI_DECLARATION } from "../shader/chunk/math/PI_DECLARATION.js";
+import { chunk_uv_to_ndc } from "../shader/chunk/texture/chunk_uv_to_ndc.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 { f32, u32, vec3f } from "../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUStruct } from "../shader/type/WebGPUStruct.js";
+
+export const SKY_BACKGROUND_SETTINGS_STRUCT = WebGPUStruct.from({
+    sun_direction: vec3f,
+    sun_disk_radius: f32,
+    sun_irradiance: vec3f,
+    sun_has_disc: u32,
+}, "SkyBackgroundSettings");
+
+const resources = new ShaderResourceSetDescriptor();
+
+resources.setImmediate("settings", SKY_BACKGROUND_SETTINGS_STRUCT);
+
+resources.createGroup()
+    .addUniform("camera", CAMERA_UNIFORM_STRUCT)
+    .addUniform("atmosphere", ATMOSPHERE_PARAMETERS_STRUCT)
+    .addTexture("tSkyViewLut", "float")
+    .add(SKY_LUT_TRANSMITTANCE_RESOURCE)
+    .add(SKY_LUT_SAMPLER_RESOURCE);
+
+/**
+ * Full-screen atmospheric sky background shader sampling Hillaire's $192 \times 108$ Sky-View LUT
+ * and compositing a transmittance-attenuated, limb-darkened solar disc when the ray misses the
+ * planet sphere.
+ *
+ * @type {CodeChunk}
+ */
+const body = CodeChunk.from(
+    //language=WGSL
+    `
+// Clamp pre-bloom f16 sky-disc radiance well inside rgba16float range (max 65504) to prevent Inf/NaN.
+const MAX_SOLAR_DISC_RADIANCE = 16384.0;
+
+@fragment
+fn main(
+    @builtin(position) coord: vec4<f32>,
+    @location(0) uv: vec2<f32>,
+) -> @location(0) vec4<f32> {
+    let clip_pos = vec4<f32>(uv_to_ndc(uv), 0.0, 1.0);
+    let world_dir_h = camera.view_projection_matrix_inverse * clip_pos;
+    let view_direction = normalize(world_dir_h.xyz);
+    let view_position = mat4_extract_position(camera.transform);
+
+    let sun_len_sq = dot(settings.sun_direction, settings.sun_direction);
+    if (sun_len_sq <= 1e-12 || all(settings.sun_irradiance <= vec3<f32>(0.0))) {
+        return vec4<f32>(0.0, 0.0, 0.0, 1.0);
+    }
+    let sun_dir = settings.sun_direction * inverseSqrt(sun_len_sq);
+
+    let lut_res = vec2<f32>(textureDimensions(tSkyViewLut));
+    let sky_uv = sky_view_lut_uv_for(atmosphere, view_position, view_direction, sun_dir, lut_res);
+    var result = textureSampleLevel(tSkyViewLut, sSkyLut, sky_uv, 0.0).rgb;
+
+    if (settings.sun_has_disc != 0u && settings.sun_disk_radius > 0.0) {
+        let view_rel = atmosphere_clamped_observer_relative(atmosphere, view_position);
+        let bounds = atmosphere_ray_bounds_for(atmosphere, view_rel, view_direction);
+
+        if (!bounds.hits_ground) {
+            let angular_radius = max(settings.sun_disk_radius, 0.0045);
+            let cos_outer = cos(angular_radius * 1.06);
+            let cos_inner = cos(angular_radius * 0.88);
+            let cos_angle = dot(view_direction, sun_dir);
+            let disc_mask = smoothstep(cos_outer, cos_inner, cos_angle);
+
+            if (disc_mask > 0.0) {
+                let cos_radius = cos(angular_radius);
+                let mu = sqrt(saturate((cos_angle - cos_outer) / max(1.0 - cos_outer, 1e-6)));
+                // Eddington solar limb darkening (mean over disc = 0.8)
+                let limb = (0.4 + 0.6 * mu) * (1.0 / 0.8);
+                let solid_angle = max(2.0 * PI * (1.0 - cos_radius), 1e-6);
+
+                let observer_radius = length(view_rel);
+                let up = view_rel / observer_radius;
+                let altitude = observer_radius - atmosphere.planet_radius;
+                let sun_transmittance = sample_transmittance_lut_params_for(
+                    atmosphere,
+                    altitude,
+                    dot(view_direction, up)
+                );
+
+                let raw_disc_radiance = (settings.sun_irradiance / solid_angle) * limb * sun_transmittance;
+                let max_channel = max(max(raw_disc_radiance.r, raw_disc_radiance.g), max(raw_disc_radiance.b, 1e-6));
+                let disc_radiance = raw_disc_radiance * min(1.0, MAX_SOLAR_DISC_RADIANCE / max_channel);
+
+                result += disc_radiance * disc_mask;
+            }
+        }
+    }
+
+    return vec4<f32>(result, 1.0);
+}
+    `, [
+        PI_DECLARATION,
+        chunk_uv_to_ndc,
+        chunk_mat4_extract_position,
+        chunk_sky_irradiance_lut_encode_uv,
+        chunk_sample_transmittance_lut_params_for,
+    ]
+);
+
+export const shader_background_sky = ImageShader.from({
+    descriptor: ShaderDescriptor.from({
+        label: "Scene Background / Atmosphere Sky",
+        resources,
+        body
+    }),
+    depthStencil: {
+        format: "depth32float",
+        depthCompare: "equal"
+    },
+    targets: [
+        {
+            label: "shaded",
+            format: "rgba16float"
+        }
+    ]
+});

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"}