@woosh/meep-engine 3.67.0 → 3.69.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.map

@@ -1 +1 @@
-{"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"}
+{"version":3,"file":"ColorGrade.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/deferred/tonemap/ColorGrade.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;GAeG;AACH,8CA2BG;AAEH;;;GAGG;AACH,wCAFU,MAAM,CAE4B;AAE5C;;;GAGG;AACH,qCAFU,MAAM,CAEsD;AAEtE;;;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;AAgDD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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;6BA9Z4B,mCAAmC;wBAJxC,kCAAkC;+BAC3B,sDAAsD"}

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

@@ -1,6 +1,7 @@
 import { assert } from "../../../../core/assert.js";
 import { Vector4 } from "../../../../core/geom/Vector4.js";
 import { AnimationCurve } from "../../../../engine/animation/curve/AnimationCurve.js";
+import { ANIMATION_CURVE_KEYFRAME_FLOATS, animation_curve_write_keys } from "../../animation/animation_curve_write_keys.js";
 import { vec4f, vec4u } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
 import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
 import { m3_white_balance_rec709, WHITE_BALANCE_NEUTRAL_TEMPERATURE, WHITE_BALANCE_NEUTRAL_TINT } from "./m3_white_balance_rec709.js";
@@ -60,7 +61,7 @@ export const COLOR_GRADE_HEADER_FLOATS = 88;
  * Floats of one keyframe in `grade_keys`: time, value, in tangent, out tangent.
  * @type {number}
  */
-export const COLOR_GRADE_KEY_FLOATS = 4;
+export const COLOR_GRADE_KEY_FLOATS = ANIMATION_CURVE_KEYFRAME_FLOATS;
 
 /**
  * One zone of Unreal's primary grade: shadows, midtones, highlights, or all of them. Each vector is RGB and a master
@@ -148,30 +149,6 @@ function write_zone(out, at, zone, global) {
     write_sum(out, at + 16, zone.offset, global.offset);
 }
 
-/**
- * @param {Float32Array} out
- * @param {number} at float index
- * @param {AnimationCurve} curve
- * @returns {number} the float index after the curve's keys
- */
-function write_keys(out, at, curve) {
-    const keys = curve.keys;
-    const count = keys.length;
-
-    for (let i = 0; i < count; i++) {
-        const key = keys[i];
-
-        out[at] = key.time;
-        out[at + 1] = key.value;
-        out[at + 2] = key.inTangent;
-        out[at + 3] = key.outTangent;
-
-        at += COLOR_GRADE_KEY_FLOATS;
-    }
-
-    return at;
-}
-
 /**
  * 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:
@@ -424,17 +401,17 @@ export class ColorGrade {
         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);
+        at = animation_curve_write_keys(out, at, this.hue_shift);
+        at = animation_curve_write_keys(out, at, this.hue_saturation);
+        at = animation_curve_write_keys(out, at, this.hue_lightness);
+        at = animation_curve_write_keys(out, at, this.luma_saturation_red);
+        at = animation_curve_write_keys(out, at, this.luma_saturation_green);
+        at = animation_curve_write_keys(out, at, this.luma_saturation_blue);
+        at = animation_curve_write_keys(out, at, this.luma_saturation);
+        at = animation_curve_write_keys(out, at, this.luma_gain_red);
+        at = animation_curve_write_keys(out, at, this.luma_gain_green);
+        at = animation_curve_write_keys(out, at, this.luma_gain_blue);
+        at = animation_curve_write_keys(out, at, this.luma_exposure);
 
         out.fill(0, at);
 

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

@@ -13,7 +13,8 @@ export const TONEMAP_ADAPTATION_RESOURCE: ShaderResourceDescriptor;
  * ```
  *
  * - `false`, the default: the colour as it is.
- * - `true`: the colour through `apply_purkinje_shift` at the view's adaptation, {@link TONEMAP_ADAPTATION_RESOURCE}.
+ * - `true`: the colour through `apply_purkinje_shift` at the view's adaptation, {@link TONEMAP_ADAPTATION_RESOURCE},
+ *   across CIE 191's mesopic range.
  *
  * The shift is linear in the colour, so the function may be applied ahead of the exposure or after it.
  *

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

@@ -1 +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"}
+{"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;;;;;;;;;;;;;;GAcG;AACH,qCAFU,eAAe,CAE0D;yCA3B1C,mDAAmD;gCAD5D,0CAA0C"}

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

@@ -21,7 +21,8 @@ export const TONEMAP_ADAPTATION_RESOURCE = ShaderResourceDescriptor.uniform("ada
  * ```
  *
  * - `false`, the default: the colour as it is.
- * - `true`: the colour through `apply_purkinje_shift` at the view's adaptation, {@link TONEMAP_ADAPTATION_RESOURCE}.
+ * - `true`: the colour through `apply_purkinje_shift` at the view's adaptation, {@link TONEMAP_ADAPTATION_RESOURCE},
+ *   across CIE 191's mesopic range.
  *
  * The shift is linear in the colour, so the function may be applied ahead of the exposure or after it.
  *
@@ -41,7 +42,10 @@ const shifted = CodeChunk.from(
     //language=WGSL
     `
 fn tonemap_purkinje(color: vec3<f32>) -> vec3<f32> {
-    return apply_purkinje_shift(color, adaptation.value);
+    return apply_purkinje_shift(
+        color,
+        purkinje_rod_share(adaptation.value, PURKINJE_MESOPIC_MIN_NITS, PURKINJE_MESOPIC_MAX_NITS)
+    );
 }
 `, [chunk_apply_purkinje_shift]);
 

package/src/shade/renderer/dynamic/GPUDynamicMeshResidency.js

@@ -126,8 +126,8 @@ export class GPUDynamicMeshResidency {
          guard; index_count is left truthful, and the draw-time index_count === 0 test skips it.
 
          Reachable on the first upload rather than on a shrink: a geometry that shrinks has already
-         grown its buffers, and Trail3DSystem.link and PathDisplaySystem both build a DynamicMesh
-         from a Geometry that can already be empty.
+         grown its buffers, and PathDisplaySystem builds a DynamicMesh from a Geometry that can
+         already be empty.
         */
         if (vertex_bytes > 0) {
             device.queue.writeBuffer(this.#vertices, 0, staging.buffer, staging.byteOffset, vertex_bytes);

package/src/shade/renderer/dynamic/chunk_dynamic_mesh_avboit_vertex.d.ts

@@ -1,19 +1,8 @@
 /**
  * The vertex stage both AVBOIT passes draw a dynamic mesh with — the splat at the volume's
  * resolution and the draw at internal resolution — so the two see the same fragments at the same
- * depths.
- *
- * `view_depth` is the vertex's own view-space depth, interpolated across the triangle: what the
- * splat positions a fragment's extinction by and what the draw looks the volume up at. Both passes
- * take it from here rather than reconstructing it from `@builtin(position).z`, the arrangement the
- * particles' billboard stage has for the same reason. `color` is straight — not premultiplied — as
- * the vertices hold it.
- *
- * Both are interpolated at the **centroid** of the samples the triangle covers. The splat is
- * multisampled, and a thin triangle can cover some of a pixel's samples but not its centre; at the
- * centre its depth and alpha would be extrapolated off the triangle's edge, which on a ribbon seen
- * nearly edge-on lands the extinction slices away from the ribbon. The draw has one sample, where a
- * fragment exists only if the centre is covered and the centroid is the centre.
+ * depths. It hands the unlit fragment stages their `AVBOITUnlitVaryings`: the clip position, the
+ * vertex colour straight as the vertices hold it, and the vertex's own view-space depth.
  *
  * The enclosing shader binds the dynamic-mesh groups (`DYNAMIC_MESH_RESOURCES`), `camera` included,
  * and hands over `instance_index` as the draw's row, as for {@link chunk_dynamic_mesh_vertex}.

package/src/shade/renderer/dynamic/chunk_dynamic_mesh_avboit_vertex.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_dynamic_mesh_avboit_vertex.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/dynamic/chunk_dynamic_mesh_avboit_vertex.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,+CAFU,SAAS,CA0BjB;0BAjDwB,iCAAiC"}
+{"version":3,"file":"chunk_dynamic_mesh_avboit_vertex.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/dynamic/chunk_dynamic_mesh_avboit_vertex.js"],"names":[],"mappings":"AAIA;;;;;;;;;;GAUG;AACH,+CAFU,SAAS,CAqBjB;0BAjCwB,iCAAiC"}

package/src/shade/renderer/dynamic/chunk_dynamic_mesh_avboit_vertex.js

@@ -1,22 +1,12 @@
+import { chunk_avboit_unlit_varyings } from "../rasterize/native/avboit/chunk_avboit_unlit_varyings.js";
 import { CodeChunk } from "../shader/compiler/CodeChunk.js";
 import { chunk_dynamic_mesh_vertex } from "./chunk_dynamic_mesh_vertex.js";
 
 /**
  * The vertex stage both AVBOIT passes draw a dynamic mesh with — the splat at the volume's
  * resolution and the draw at internal resolution — so the two see the same fragments at the same
- * depths.
- *
- * `view_depth` is the vertex's own view-space depth, interpolated across the triangle: what the
- * splat positions a fragment's extinction by and what the draw looks the volume up at. Both passes
- * take it from here rather than reconstructing it from `@builtin(position).z`, the arrangement the
- * particles' billboard stage has for the same reason. `color` is straight — not premultiplied — as
- * the vertices hold it.
- *
- * Both are interpolated at the **centroid** of the samples the triangle covers. The splat is
- * multisampled, and a thin triangle can cover some of a pixel's samples but not its centre; at the
- * centre its depth and alpha would be extrapolated off the triangle's edge, which on a ribbon seen
- * nearly edge-on lands the extinction slices away from the ribbon. The draw has one sample, where a
- * fragment exists only if the centre is covered and the centroid is the centre.
+ * depths. It hands the unlit fragment stages their `AVBOITUnlitVaryings`: the clip position, the
+ * vertex colour straight as the vertices hold it, and the vertex's own view-space depth.
  *
  * The enclosing shader binds the dynamic-mesh groups (`DYNAMIC_MESH_RESOURCES`), `camera` included,
  * and hands over `instance_index` as the draw's row, as for {@link chunk_dynamic_mesh_vertex}.
@@ -26,16 +16,10 @@ import { chunk_dynamic_mesh_vertex } from "./chunk_dynamic_mesh_vertex.js";
 export const chunk_dynamic_mesh_avboit_vertex = CodeChunk.from(
     //language=WGSL
     `
-struct DynamicMeshAVBOITVertexOut {
-    @builtin(position) clip : vec4<f32>,
-    @location(0) @interpolate(perspective, centroid) color : vec4<f32>,
-    @location(1) @interpolate(perspective, centroid) view_depth : f32,
-}
-
-fn dynamic_mesh_avboit_vertex(vertex_index : u32, draw_index : u32) -> DynamicMeshAVBOITVertexOut {
+fn dynamic_mesh_avboit_vertex(vertex_index : u32, draw_index : u32) -> AVBOITUnlitVaryings {
     let vertex = dynamic_mesh_vertex(vertex_index, draw_index);
 
-    var out : DynamicMeshAVBOITVertexOut;
+    var out : AVBOITUnlitVaryings;
 
     out.clip = camera.view_projection_matrix * vertex.world;
     out.color = vertex.color;
@@ -45,6 +29,7 @@ fn dynamic_mesh_avboit_vertex(vertex_index : u32, draw_index : u32) -> DynamicMe
     return out;
 }
     `, [
+        chunk_avboit_unlit_varyings,
         chunk_dynamic_mesh_vertex,
     ]
 );