@woosh/meep-engine 3.67.0 → 3.68.0

package/src/shade/renderer/shader/chunk/atmosphere/chunk_atmosphere_ray_bounds.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_atmosphere_ray_bounds.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/atmosphere/chunk_atmosphere_ray_bounds.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;GAiBG;AACH,0CAFU,SAAS,CAiDjB;0BApEwB,6BAA6B"}
+{"version":3,"file":"chunk_atmosphere_ray_bounds.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/atmosphere/chunk_atmosphere_ray_bounds.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;GAiBG;AACH,0CAFU,SAAS,CAgDjB;0BAnEwB,6BAA6B"}

package/src/shade/renderer/shader/chunk/atmosphere/chunk_atmosphere_ray_bounds.js

@@ -1,69 +1,68 @@
-import { CodeChunk } from "../../compiler/CodeChunk.js";
-import { ATMOSPHERE_RADII_DECLARATION } from "./ATMOSPHERE_RADII_DECLARATION.js";
-
-/**
- * How far a ray inside the atmosphere may be marched, and whether it ends on the surface.
- *
- * The ground and the atmosphere shell are concentric on the planet and the ray is shared, so
- * one quadratic setup serves both intersections — only the radius term differs. Calling a
- * general sphere-intersection routine twice instead recomputes the ray-origin offset and all
- * three dot products for the second sphere, and re-derives a leading coefficient that is 1
- * for a unit direction.
- *
- * `origin_rel` is relative to the planet centre and assumed to be inside the atmosphere and
- * at or above the surface, which is what makes the shell's far root the exit point.
- * `ray_direction` must be normalised.
- *
- * `ground_distance` is negative when the ray never meets the surface, which includes looking
- * up from above it: both roots are behind the origin there.
- *
- * @type {CodeChunk}
- */
-export const chunk_atmosphere_ray_bounds = CodeChunk.from(
-    //language=WGSL
-    `
-struct AtmosphereRayBounds {
-    // as far as a march may go: the surface when the ray meets it, the shell otherwise
-    t_max: f32,
-    // distance to the surface, negative when there is no hit ahead
-    ground_distance: f32,
-    hits_ground: bool,
-}
-
-fn atmosphere_ray_bounds(
-    origin_rel: vec3<f32>,
-    ray_direction: vec3<f32>
-) -> AtmosphereRayBounds {
-
-    // ray_direction is a unit vector, so the leading coefficient is 1 and the factors of two
-    // divide out of both roots
-    let b = dot(origin_rel, ray_direction);
-    let r2 = dot(origin_rel, origin_rel);
-    let b2 = b * b;
-
-    // inside the shell, so its constant term is negative, the discriminant is positive, and
-    // the far root is where the ray leaves
-    let atmosphere_distance = -b + sqrt(max(b2 - (r2 - ATMOSPHERE_TOP_RADIUS_SQUARED), 0.0));
-
-    // the ground is the near root, and only when that root is ahead of us
-    let ground_discriminant = b2 - (r2 - ATMOSPHERE_GROUND_RADIUS_SQUARED);
-    let ground_distance = select(
-        -1.0,
-        -b - sqrt(max(ground_discriminant, 0.0)),
-        ground_discriminant >= 0.0
-    );
-
-    let hits_ground = ground_distance > 0.0;
-
-    var result: AtmosphereRayBounds;
-
-    result.t_max = select(atmosphere_distance, ground_distance, hits_ground);
-    result.ground_distance = ground_distance;
-    result.hits_ground = hits_ground;
-
-    return result;
-}
-    `, [
-        ATMOSPHERE_RADII_DECLARATION,
-    ]
-);
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+import { ATMOSPHERE_RADII_DECLARATION } from "./ATMOSPHERE_RADII_DECLARATION.js";
+
+/**
+ * How far a ray inside the atmosphere may be marched, and whether it ends on the surface.
+ *
+ * The ground and the atmosphere shell are concentric on the planet and the ray is shared, so
+ * one quadratic setup serves both intersections — only the radius term differs. Calling a
+ * general sphere-intersection routine twice instead recomputes the ray-origin offset and all
+ * three dot products for the second sphere, and re-derives a leading coefficient that is 1
+ * for a unit direction.
+ *
+ * `origin_rel` is relative to the planet centre and assumed to be inside the atmosphere and
+ * at or above the surface, which is what makes the shell's far root the exit point.
+ * `ray_direction` must be normalised.
+ *
+ * `ground_distance` is negative when the ray never meets the surface, which includes looking
+ * up from above it: both roots are behind the origin there.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_atmosphere_ray_bounds = CodeChunk.from(
+    //language=WGSL
+    `
+struct AtmosphereRayBounds {
+    // as far as a march may go: the surface when the ray meets it, the shell otherwise
+    t_max: f32,
+    // distance to the surface, negative when there is no hit ahead
+    ground_distance: f32,
+    hits_ground: bool,
+}
+
+fn atmosphere_ray_bounds(
+    origin_rel: vec3<f32>,
+    ray_direction: vec3<f32>
+) -> AtmosphereRayBounds {
+
+    // ray_direction is a unit vector, so the leading coefficient is 1 and the factors of two
+    // divide out of both roots
+    let b = dot(origin_rel, ray_direction);
+    let r = length(origin_rel);
+    let b2 = b * b;
+
+    // Difference-of-squares factoring (r - R)(r + R) avoids catastrophic f32 cancellation when
+    // altitude (r - R) is metres above a 6,378 km planet radius.
+    let atmosphere_distance = -b + sqrt(max(b2 - (r - ATMOSPHERE_TOP_RADIUS) * (r + ATMOSPHERE_TOP_RADIUS), 0.0));
+
+    // the ground is the near root, and only when that root is ahead of us
+    let ground_discriminant = b2 - (r - ATMOSPHERE_GROUND_RADIUS) * (r + ATMOSPHERE_GROUND_RADIUS);
+    let hits_ground = (b < 0.0) && (ground_discriminant >= 0.0);
+    let ground_distance = select(
+        -1.0,
+        max(-b - sqrt(max(ground_discriminant, 0.0)), 0.0),
+        hits_ground
+    );
+
+    var result: AtmosphereRayBounds;
+
+    result.t_max = select(atmosphere_distance, ground_distance, hits_ground);
+    result.ground_distance = ground_distance;
+    result.hits_ground = hits_ground;
+
+    return result;
+}
+    `, [
+        ATMOSPHERE_RADII_DECLARATION,
+    ]
+);

package/src/shade/renderer/shader/chunk/atmosphere/chunk_get_sun_transmittance.d.ts

@@ -1,5 +1,8 @@
 /**
- * @see https://www.shadertoy.com/view/slSXRW
+ * Integrates direct solar transmittance from `pos` along `sunDir` to the top of the atmosphere,
+ * returning zero when the ray intersects the planet sphere.
+ *
+ * @see "A Scalable and Production Ready Sky and Atmosphere Rendering Technique", Hillaire (2020)
  * @type {CodeChunk}
  */
 export const chunk_get_sun_transmittance: CodeChunk;

package/src/shade/renderer/shader/chunk/atmosphere/chunk_get_sun_transmittance.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_get_sun_transmittance.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/atmosphere/chunk_get_sun_transmittance.js"],"names":[],"mappings":"AASA;;;GAGG;AACH,0CAFU,SAAS,CA+CjB;0BA1DwB,6BAA6B"}
+{"version":3,"file":"chunk_get_sun_transmittance.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/atmosphere/chunk_get_sun_transmittance.js"],"names":[],"mappings":"AAMA;;;;;;GAMG;AACH,0CAFU,SAAS,CAsDjB;0BA7DwB,6BAA6B"}

package/src/shade/renderer/shader/chunk/atmosphere/chunk_get_sun_transmittance.js

@@ -1,59 +1,66 @@
+import {
+    ATMOSPHERE_PARAMETERS_STRUCT,
+    chunk_atmosphere_parameters
+} from "../../../atmosphere/ATMOSPHERE_PARAMETERS_STRUCT.js";
 import { CodeChunk } from "../../compiler/CodeChunk.js";
-import { chunk_atmosphere_density } from "./chunk_atmosphere_density.js";
-import { chunk_atmosphere_height } from "./chunk_atmosphere_height.js";
-import { chunk_atmosphere_intersection } from "./chunk_atmosphere_intersection.js";
-import { chunk_compute_extinction } from "./chunk_compute_extinction.js";
-import { chunk_sphere_intersection } from "./chunk_sphere_intersection.js";
-import { PLANET_CENTER_DECLARATION } from "./PLANET_CENTER_DECLARATION.js";
-import { PLANET_RADIUS_DECLARATION } from "./PLANET_RADIUS_DECLARATION.js";
 
 /**
- * @see https://www.shadertoy.com/view/slSXRW
+ * Integrates direct solar transmittance from `pos` along `sunDir` to the top of the atmosphere,
+ * returning zero when the ray intersects the planet sphere.
+ *
+ * @see "A Scalable and Production Ready Sky and Atmosphere Rendering Technique", Hillaire (2020)
  * @type {CodeChunk}
  */
 export const chunk_get_sun_transmittance = CodeChunk.from(
     //language=WGSL
     `
-fn get_sun_transmittance(pos: vec3<f32>, sunDir: vec3<f32>, sunTransmittanceSteps: f32) -> vec3<f32>{
-    
-    if (sphere_intersection(pos, sunDir, PLANET_CENTER, PLANET_RADIUS).x > 0.0) {
-        // we're outside of the atmosphere
-        return vec3(0.0);
+fn get_sun_transmittance_rel_for(
+    atm: ${ATMOSPHERE_PARAMETERS_STRUCT.wgsl_ref},
+    rel: vec3<f32>,
+    sunDir: vec3<f32>,
+    sunTransmittanceSteps: f32
+) -> vec3<f32> {
+    let bounds = atmosphere_ray_bounds_for(atm, rel, sunDir);
+
+    if (bounds.hits_ground) {
+        return vec3<f32>(0.0);
     }
-    
-    let ray_length = atmosphere_intersection(pos, sunDir ).y;
+
+    let ray_length = bounds.t_max;
     var t = 0.0;
-    
-    var transmittance = vec3(1.0);
-    
-    // integrate optical depth
+    var transmittance = vec3<f32>(1.0);
+
     for (var i = 0.0; i < sunTransmittanceSteps; i += 1.0) {
         let f = (i + 0.3) / sunTransmittanceSteps;
-    
         let newT = f * ray_length;
         let dt = newT - t;
         t = newT;
-        
-        let newPos = pos + t * sunDir;
-        
-        let local_height = atmosphere_height(newPos);
-		let local_density  = atmosphere_density(local_height);
-        
-        let extinction = compute_extinction(local_density);
-		
-		transmittance *= exp(-dt * extinction);
-		
+
+        let step_rel = rel + t * sunDir;
+        let local_height = length(step_rel) - atm.planet_radius;
+        let local_density = atmosphere_density_for(atm, local_height);
+        let extinction = atmosphere_extinction_for(atm, local_density);
+
+        transmittance *= exp(-dt * extinction);
     }
-    
+
     return transmittance;
 }
+
+fn get_sun_transmittance_for(
+    atm: ${ATMOSPHERE_PARAMETERS_STRUCT.wgsl_ref},
+    pos_ws: vec3<f32>,
+    sunDir: vec3<f32>,
+    sunTransmittanceSteps: f32
+) -> vec3<f32> {
+    let rel = atmosphere_position_relative_for(atm, pos_ws);
+    return get_sun_transmittance_rel_for(atm, rel, sunDir, sunTransmittanceSteps);
+}
+
+fn get_sun_transmittance(pos_ws: vec3<f32>, sunDir: vec3<f32>, sunTransmittanceSteps: f32) -> vec3<f32> {
+    return get_sun_transmittance_for(atmosphere_earth_parameters(), pos_ws, sunDir, sunTransmittanceSteps);
+}
     `, [
-        chunk_sphere_intersection,
-        chunk_atmosphere_height,
-        chunk_atmosphere_density,
-        PLANET_RADIUS_DECLARATION,
-        PLANET_CENTER_DECLARATION,
-        chunk_atmosphere_intersection,
-        chunk_compute_extinction,
+        chunk_atmosphere_parameters,
     ]
-);
+);

package/src/shade/renderer/shader/chunk/atmosphere/chunk_position_relative_to_planet_center.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_position_relative_to_planet_center.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/atmosphere/chunk_position_relative_to_planet_center.js"],"names":[],"mappings":"AAGA,iEASE;0BAZwB,6BAA6B"}
+{"version":3,"file":"chunk_position_relative_to_planet_center.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/atmosphere/chunk_position_relative_to_planet_center.js"],"names":[],"mappings":"AAIA,iEAUE;0BAbwB,6BAA6B"}

package/src/shade/renderer/shader/chunk/atmosphere/chunk_position_relative_to_planet_center.js

@@ -1,13 +1,15 @@
+import { ATMOSPHERE_UNIT_SCALE_DECLARATION } from "../../../atmosphere/ATMOSPHERE_UNIT_SCALE.js";
 import { CodeChunk } from "../../compiler/CodeChunk.js";
 import { PLANET_CENTER_DECLARATION } from "./PLANET_CENTER_DECLARATION.js";
 
 export const chunk_position_relative_to_planet_center = CodeChunk.from(
-//language=WGSL
+    //language=WGSL
     `
-fn position_relative_to_planet_center(pos:vec3<f32>) -> vec3<f32> {
-    return pos - PLANET_CENTER;
+fn position_relative_to_planet_center(pos: vec3<f32>) -> vec3<f32> {
+    return pos * METERS_TO_ATMOSPHERE_UNITS - PLANET_CENTER;
 }
     `, [
+        ATMOSPHERE_UNIT_SCALE_DECLARATION,
         PLANET_CENTER_DECLARATION
     ]
 );

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

@@ -1,12 +1,15 @@
 /**
- * How much of the eye's response is the rods', at an adaptation: 1 at and below {@link PURKINJE_MESOPIC_MIN_NITS}, 0 at
- * and above {@link PURKINJE_MESOPIC_MAX_NITS}, linear in log luminance in between. The share `apply_purkinje_shift`
- * blends by, for code that needs it on the CPU.
+ * How much of the eye's response is the rods', at an adaptation, across a response range: 1 at and below `rods_below`,
+ * 0 at and above `cones_above`, linear in log luminance in between. CIE 191's range is
+ * {@link PURKINJE_MESOPIC_MIN_NITS} to {@link PURKINJE_MESOPIC_MAX_NITS}. The share `apply_purkinje_shift` blends by,
+ * for code that needs it on the CPU.
  *
  * @param {number} adaptation_luminance cd/m²
+ * @param {number} rods_below cd/m², over 0
+ * @param {number} cones_above cd/m², over `rods_below`
  * @returns {number} 0 to 1
  */
-export function purkinje_rod_share(adaptation_luminance: number): number;
+export function purkinje_rod_share(adaptation_luminance: number, rods_below: number, cones_above: number): number;
 /**
  * Rec.709 photopic luminance weights: what the cones see of a linear Rec.709 colour.
  * @type {ReadonlyArray<number>}
@@ -26,6 +29,7 @@ export const PURKINJE_REC709_SCOTOPIC: ReadonlyArray<number>;
 export const PURKINJE_NIGHT_TINT: ReadonlyArray<number>;
 /**
  * CIE 191's mesopic range, cd/m²: rods alone below the lower bound (scotopic), cones alone above the upper (photopic).
+ * The response range of the tone mapper's run-time shift.
  */
 export const PURKINJE_MESOPIC_MIN_NITS: 0.005;
 export const PURKINJE_MESOPIC_MAX_NITS: 5;
@@ -34,14 +38,18 @@ export const PURKINJE_MESOPIC_MAX_NITS: 5;
  * Human vision system shifts color perception away from red in night-time conditions.
  *
  * ```wgsl
- * fn apply_purkinje_shift(color_rec709: vec3<f32>, adaptation_luminance: f32) -> vec3<f32>
- * fn purkinje_rod_share(adaptation_luminance: f32) -> f32
+ * fn purkinje_rod_share(adaptation_luminance: f32, rods_below: f32, cones_above: f32) -> f32
+ * fn apply_purkinje_shift(color_rec709: vec3<f32>, rod_share: f32) -> vec3<f32>
  * ```
  *
- * `color_rec709` is scene-linear Rec.709; `adaptation_luminance` is the luminance the eye is adapted to, cd/m². Above
- * 5 cd/m² the colour is returned as it is; below 0.005 cd/m² it is the rod response alone, its scotopic luminance
- * carried by a blue tint; in between the two blend linearly in log luminance, by `purkinje_rod_share`. The shift is
- * linear in the colour, so it gives the same result ahead of the exposure as after it.
+ * `purkinje_rod_share` is how much of the eye's response is the rods' at `adaptation_luminance`, the luminance the eye
+ * is adapted to, across a response range, all in cd/m²: 1 at and below `rods_below`, 0 at and above `cones_above`
+ * (which must be over `rods_below`, itself over 0), linear in log luminance in between. CIE 191's mesopic range,
+ * `PURKINJE_MESOPIC_MIN_NITS` to `PURKINJE_MESOPIC_MAX_NITS` (0.005 to 5 cd/m²), is the eye's.
+ *
+ * `apply_purkinje_shift` blends `color_rec709`, scene-linear Rec.709, towards the rod response by `rod_share`: at 0 the
+ * colour is returned as it is; at 1 it is the rod response alone, its scotopic luminance carried by a blue tint. The
+ * shift is linear in the colour, so it gives the same result ahead of the exposure as after it.
  *
  * The constants are the module's exports ({@link PURKINJE_REC709_SCOTOPIC} and the rest), and
  * {@link purkinje_rod_share} is the share on the CPU.

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

@@ -1 +1 @@
-{"version":3,"file":"chunk_apply_purkinje_shift.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/shade/renderer/shader/chunk/color/tonemap/purkinje/chunk_apply_purkinje_shift.js"],"names":[],"mappings":"AAiCA;;;;;;;GAOG;AACH,yDAHW,MAAM,GACJ,MAAM,CAQlB;AA7CD;;;GAGG;AACH,uCAFU,cAAc,MAAM,CAAC,CAEiD;AAEhF;;;;GAIG;AACH,uCAFU,cAAc,MAAM,CAAC,CAEiD;AAEhF;;;;GAIG;AACH,kCAFU,cAAc,MAAM,CAAC,CAEmC;AAElE;;GAEG;AACH,8CAA+C;AAC/C,0CAA2C;AAwC3C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,yCAFU,SAAS,CAwCjB;0BAvIwB,mCAAmC"}
+{"version":3,"file":"chunk_apply_purkinje_shift.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/shade/renderer/shader/chunk/color/tonemap/purkinje/chunk_apply_purkinje_shift.js"],"names":[],"mappings":"AA6BA;;;;;;;;;;GAUG;AACH,yDALW,MAAM,cACN,MAAM,eACN,MAAM,GACJ,MAAM,CAQlB;AA5CD;;;GAGG;AACH,uCAFU,cAAc,MAAM,CAAC,CAEiD;AAEhF;;;;GAIG;AACH,uCAFU,cAAc,MAAM,CAAC,CAEiD;AAEhF;;;;GAIG;AACH,kCAFU,cAAc,MAAM,CAAC,CAEmC;AAElE;;;GAGG;AACH,8CAA+C;AAC/C,0CAA2C;AAsC3C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,yCAFU,SAAS,CAwCjB;0BA1IwB,mCAAmC"}

package/src/shade/renderer/shader/chunk/color/tonemap/purkinje/chunk_apply_purkinje_shift.js

@@ -22,27 +22,26 @@ export const PURKINJE_NIGHT_TINT = Object.freeze([0.3, 0.5, 0.9]);
 
 /**
  * CIE 191's mesopic range, cd/m²: rods alone below the lower bound (scotopic), cones alone above the upper (photopic).
+ * The response range of the tone mapper's run-time shift.
  */
 export const PURKINJE_MESOPIC_MIN_NITS = 0.005;
 export const PURKINJE_MESOPIC_MAX_NITS = 5;
 
 /**
- * The least adaptation the share is read at, cd/m²: under it, the rods alone see, as they do at the bound itself.
- */
-const ADAPTATION_FLOOR_NITS = 1e-5;
-
-/**
- * How much of the eye's response is the rods', at an adaptation: 1 at and below {@link PURKINJE_MESOPIC_MIN_NITS}, 0 at
- * and above {@link PURKINJE_MESOPIC_MAX_NITS}, linear in log luminance in between. The share `apply_purkinje_shift`
- * blends by, for code that needs it on the CPU.
+ * How much of the eye's response is the rods', at an adaptation, across a response range: 1 at and below `rods_below`,
+ * 0 at and above `cones_above`, linear in log luminance in between. CIE 191's range is
+ * {@link PURKINJE_MESOPIC_MIN_NITS} to {@link PURKINJE_MESOPIC_MAX_NITS}. The share `apply_purkinje_shift` blends by,
+ * for code that needs it on the CPU.
  *
  * @param {number} adaptation_luminance cd/m²
+ * @param {number} rods_below cd/m², over 0
+ * @param {number} cones_above cd/m², over `rods_below`
  * @returns {number} 0 to 1
  */
-export function purkinje_rod_share(adaptation_luminance) {
-    const low = Math.log(PURKINJE_MESOPIC_MIN_NITS);
-    const high = Math.log(PURKINJE_MESOPIC_MAX_NITS);
-    const t = (Math.log(Math.max(adaptation_luminance, ADAPTATION_FLOOR_NITS)) - low) / (high - low);
+export function purkinje_rod_share(adaptation_luminance, rods_below, cones_above) {
+    const low = Math.log(rods_below);
+    const high = Math.log(cones_above);
+    const t = (Math.log(Math.min(Math.max(adaptation_luminance, rods_below), cones_above)) - low) / (high - low);
 
     return 1 - Math.min(1, Math.max(0, t));
 }
@@ -69,14 +68,18 @@ function wgsl_vec3(v) {
  * Human vision system shifts color perception away from red in night-time conditions.
  *
  * ```wgsl
- * fn apply_purkinje_shift(color_rec709: vec3<f32>, adaptation_luminance: f32) -> vec3<f32>
- * fn purkinje_rod_share(adaptation_luminance: f32) -> f32
+ * fn purkinje_rod_share(adaptation_luminance: f32, rods_below: f32, cones_above: f32) -> f32
+ * fn apply_purkinje_shift(color_rec709: vec3<f32>, rod_share: f32) -> vec3<f32>
  * ```
  *
- * `color_rec709` is scene-linear Rec.709; `adaptation_luminance` is the luminance the eye is adapted to, cd/m². Above
- * 5 cd/m² the colour is returned as it is; below 0.005 cd/m² it is the rod response alone, its scotopic luminance
- * carried by a blue tint; in between the two blend linearly in log luminance, by `purkinje_rod_share`. The shift is
- * linear in the colour, so it gives the same result ahead of the exposure as after it.
+ * `purkinje_rod_share` is how much of the eye's response is the rods' at `adaptation_luminance`, the luminance the eye
+ * is adapted to, across a response range, all in cd/m²: 1 at and below `rods_below`, 0 at and above `cones_above`
+ * (which must be over `rods_below`, itself over 0), linear in log luminance in between. CIE 191's mesopic range,
+ * `PURKINJE_MESOPIC_MIN_NITS` to `PURKINJE_MESOPIC_MAX_NITS` (0.005 to 5 cd/m²), is the eye's.
+ *
+ * `apply_purkinje_shift` blends `color_rec709`, scene-linear Rec.709, towards the rod response by `rod_share`: at 0 the
+ * colour is returned as it is; at 1 it is the rod response alone, its scotopic luminance carried by a blue tint. The
+ * shift is linear in the colour, so it gives the same result ahead of the exposure as after it.
  *
  * The constants are the module's exports ({@link PURKINJE_REC709_SCOTOPIC} and the rest), and
  * {@link purkinje_rod_share} is the share on the CPU.
@@ -104,21 +107,21 @@ const PURKINJE_NIGHT_TINT = ${wgsl_vec3(PURKINJE_NIGHT_TINT)};
 const PURKINJE_MESOPIC_MIN_NITS = ${wgsl_float(PURKINJE_MESOPIC_MIN_NITS)}; // Rods dominate below this
 const PURKINJE_MESOPIC_MAX_NITS = ${wgsl_float(PURKINJE_MESOPIC_MAX_NITS)}; // Cones dominate above this
 
-// how much of the response is the rods', linear in log luminance across the mesopic range: a perceptually linear
+// how much of the response is the rods', linear in log luminance across the response range: a perceptually linear
 // transition
-fn purkinje_rod_share(adaptation_luminance: f32) -> f32 {
-    let logLum = log(max(adaptation_luminance, ${wgsl_float(ADAPTATION_FLOOR_NITS)}));
+fn purkinje_rod_share(adaptation_luminance: f32, rods_below: f32, cones_above: f32) -> f32 {
+    let logLum = log(clamp(adaptation_luminance, rods_below, cones_above));
 
-    const logLow = log(PURKINJE_MESOPIC_MIN_NITS);
-    const logHigh = log(PURKINJE_MESOPIC_MAX_NITS);
-    const logDelta = logHigh - logLow;
+    let logLow = log(rods_below);
+    let logHigh = log(cones_above);
+    let logDelta = logHigh - logLow;
 
     return 1.0 - saturate( (logLum - logLow) / logDelta );
 }
 
 fn apply_purkinje_shift(
     color_rec709: vec3<f32>,
-    adaptation_luminance: f32
+    rod_share: f32
 ) -> vec3<f32>{
     // 1. Calculate Rod Luminance (Night)
     // Note: Red objects will have a near-zero Y_night, making them turn black.
@@ -129,8 +132,8 @@ fn apply_purkinje_shift(
     // We treat the rod signal as a scalar intensity applied to our blue tint
     let color_night = Y_night * PURKINJE_NIGHT_TINT;
 
-    // 3. Lerp from Day view to Night view, by the rods' share at the adaptation
-    return mix(color_rec709, color_night, purkinje_rod_share(adaptation_luminance));
+    // 3. Lerp from Day view to Night view, by the rods' share
+    return mix(color_rec709, color_night, rod_share);
 }
     `
 );

package/src/shade/renderer/shader/chunk/depth/chunk_get_device_depth.d.ts

@@ -0,0 +1,14 @@
+/**
+ * The device depth a camera's projection gives a view depth, the inverse of {@link chunk_get_view_space_depth}:
+ *
+ * ```wgsl
+ * fn get_device_depth(view_depth: f32, camera: CameraUniforms) -> f32
+ * ```
+ *
+ * Reverse Z, as `device_depth_to_view_space` is ({@link compute_device_depth_to_view_space_depth_params}).
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_get_device_depth: CodeChunk;
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_get_device_depth.d.ts.map

package/src/shade/renderer/shader/chunk/depth/chunk_get_device_depth.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_get_device_depth.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/depth/chunk_get_device_depth.js"],"names":[],"mappings":"AAGA;;;;;;;;;;GAUG;AACH,qCAFU,SAAS,CAiBjB;0BA5BwB,6BAA6B"}

package/src/shade/renderer/shader/chunk/depth/chunk_get_device_depth.js

@@ -0,0 +1,30 @@
+import { CAMERA_UNIFORM_STRUCT } from "../../../camera/CAMERA_UNIFORM_STRUCT.js";
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+
+/**
+ * The device depth a camera's projection gives a view depth, the inverse of {@link chunk_get_view_space_depth}:
+ *
+ * ```wgsl
+ * fn get_device_depth(view_depth: f32, camera: CameraUniforms) -> f32
+ * ```
+ *
+ * Reverse Z, as `device_depth_to_view_space` is ({@link compute_device_depth_to_view_space_depth_params}).
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_get_device_depth = CodeChunk.from(
+    //language=WGSL
+    `
+fn get_device_depth(
+    view_depth: f32,
+    camera: ${CAMERA_UNIFORM_STRUCT.wgsl_ref}
+) -> f32 {
+
+    let device_to_view_depth = camera.device_depth_to_view_space;
+
+    return device_to_view_depth.y / view_depth - device_to_view_depth.x;
+}
+    `, [
+        CAMERA_UNIFORM_STRUCT.declaration_chunk,
+    ]
+);

package/src/shade/renderer/shader/chunk/geometry/octahedron/chunk_uv_equal_area_sphere.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Clarberg's equal-area mapping between the unit square and the unit sphere, octahedrally folded: every
+ * region of the square covers 4π times its area of the sphere, so a regular n×n grid of texels splits the
+ * sphere into texels of 4π/n² steradians each, and a point drawn uniformly inside a texel is a direction drawn
+ * uniformly over that texel's solid angle.
+ *
+ * ```wgsl
+ * fn uv_equal_area_sphere_decode(uv: vec2<f32>) -> vec3<f32>   // the square [0, 1]² to a unit vector
+ * fn uv_equal_area_sphere_encode(direction: vec3<f32>) -> vec2<f32>   // any non-zero vector to the square
+ * ```
+ *
+ * The square's diamond |2u−1| + |2v−1| ≤ 1 is the +z hemisphere and its centre +z; the four corners meet at −z.
+ * The fold is the standard octahedral one, so the square's edges join as an octahedral map's do.
+ *
+ * @see Petrik Clarberg, "Fast Equal-Area Mapping of the (Hemi)Sphere using SIMD", Journal of Graphics Tools
+ *   13(3), 2008
+ * @type {CodeChunk}
+ */
+export const chunk_uv_equal_area_sphere: CodeChunk;
+import { CodeChunk } from "../../../compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_uv_equal_area_sphere.d.ts.map

package/src/shade/renderer/shader/chunk/geometry/octahedron/chunk_uv_equal_area_sphere.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_uv_equal_area_sphere.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/geometry/octahedron/chunk_uv_equal_area_sphere.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;GAiBG;AACH,yCAFU,SAAS,CAwCZ;0BA3DmB,gCAAgC"}

package/src/shade/renderer/shader/chunk/geometry/octahedron/chunk_uv_equal_area_sphere.js

@@ -0,0 +1,60 @@
+import { CodeChunk } from "../../../compiler/CodeChunk.js";
+import { PI_DECLARATION } from "../../math/PI_DECLARATION.js";
+
+/**
+ * Clarberg's equal-area mapping between the unit square and the unit sphere, octahedrally folded: every
+ * region of the square covers 4π times its area of the sphere, so a regular n×n grid of texels splits the
+ * sphere into texels of 4π/n² steradians each, and a point drawn uniformly inside a texel is a direction drawn
+ * uniformly over that texel's solid angle.
+ *
+ * ```wgsl
+ * fn uv_equal_area_sphere_decode(uv: vec2<f32>) -> vec3<f32>   // the square [0, 1]² to a unit vector
+ * fn uv_equal_area_sphere_encode(direction: vec3<f32>) -> vec2<f32>   // any non-zero vector to the square
+ * ```
+ *
+ * The square's diamond |2u−1| + |2v−1| ≤ 1 is the +z hemisphere and its centre +z; the four corners meet at −z.
+ * The fold is the standard octahedral one, so the square's edges join as an octahedral map's do.
+ *
+ * @see Petrik Clarberg, "Fast Equal-Area Mapping of the (Hemi)Sphere using SIMD", Journal of Graphics Tools
+ *   13(3), 2008
+ * @type {CodeChunk}
+ */
+export const chunk_uv_equal_area_sphere = CodeChunk.from(
+    //language=WGSL
+    `
+fn uv_equal_area_sphere_decode(uv: vec2<f32>) -> vec3<f32> {
+    let s = fma(uv, vec2<f32>(2.0), vec2<f32>(-1.0));
+    let d = 1.0 - (abs(s.x) + abs(s.y));
+    let r = 1.0 - abs(d);
+
+    // the square's centre and corners are the poles, where r is zero and the azimuth is any
+    let phi = select((PI * 0.25) * ((abs(s.y) - abs(s.x)) / r + 1.0), 0.0, r == 0.0);
+    let f = r * sqrt(2.0 - r * r);
+
+    return vec3<f32>(
+        f * sign(s.x) * abs(cos(phi)),
+        f * sign(s.y) * abs(sin(phi)),
+        sign(d) * (1.0 - r * r),
+    );
+}
+
+fn uv_equal_area_sphere_encode(direction: vec3<f32>) -> vec2<f32> {
+    let n = normalize(direction);
+    let a = abs(n);
+    let r = sqrt(max(1.0 - a.z, 0.0));
+
+    // the azimuth in the quadrant, 0 along x to 1 along y; on the z axis r is zero and it is never read
+    let tangent = min(a.x, a.y) / max(max(a.x, a.y), 1e-30);
+    let half_turn = atan(tangent) * (2.0 / PI);
+    let phi = select(half_turn, 1.0 - half_turn, a.x < a.y);
+
+    var folded = vec2<f32>(r - phi * r, phi * r);
+
+    folded = select(folded, 1.0 - folded.yx, n.z < 0.0);
+    folded = select(folded, -folded, n.xy < vec2<f32>(0.0));
+
+    return fma(folded, vec2<f32>(0.5), vec2<f32>(0.5));
+}
+`, [
+        PI_DECLARATION,
+    ]);

package/src/shade/renderer/shader/chunk/light/{sky/chunk_sample_sky_color.d.ts → io/chunk_light_get_sun.d.ts}

@@ -8,12 +8,9 @@
  * iterating; per-pixel direct shading should iterate via
  * {@link chunk_directional_lights_iteration_mask} so every directional
  * light contributes.
- */
-export const chunk_light_get_sun: CodeChunk;
-/**
- * @see https://github.com/GPUOpen-LibrariesAndSDKs/FidelityFX-SDK/blob/1bbe66e7ea0d358e84af4471a90aa9c35b583de0/framework/rendermodules/skydome/shaders/skydomeproc.hlsl#L177
+ *
  * @type {CodeChunk}
  */
-export const chunk_sample_sky_color: CodeChunk;
+export const chunk_light_get_sun: CodeChunk;
 import { CodeChunk } from "../../../compiler/CodeChunk.js";
-//# sourceMappingURL=chunk_sample_sky_color.d.ts.map
+//# sourceMappingURL=chunk_light_get_sun.d.ts.map

package/src/shade/renderer/shader/chunk/light/io/chunk_light_get_sun.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_light_get_sun.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/light/io/chunk_light_get_sun.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;;GAYG;AACH,kCAFU,SAAS,CAmBjB;0BApCwB,gCAAgC"}