@woosh/meep-engine 3.67.0 → 3.69.0

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

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

@@ -1,15 +1,10 @@
+import { LIGHT_DATA_RESOURCE } from "../../../../light/LIGHT_DATA_RESOURCE.js";
 import { LIGHT_DATABASE_SPEC } from "../../../../light/LIGHT_DATABASE_SPEC.js";
-import { chunk_sample_environment_color } from "../../../../atmosphere/chunk_sample_environment_color.js";
 import { CodeChunk } from "../../../compiler/CodeChunk.js";
-import { chunk_integrate_scattering } from "../../atmosphere/chunk_integrate_scattering.js";
-import { chunk_planet_intersection } from "../../atmosphere/chunk_planet_intersection.js";
-import { F32_MAX_DEFINITION } from "../../math/F32_MAX_DEFINITION.js";
 import { DIRECTIONAL_LIGHT_STRUCT } from "../DIRECTIONAL_LIGHT_STRUCT.js";
-import {
-    chunk_directional_lights_iteration_mask
-} from "../io/chunk_directional_lights_iteration_mask.js";
+import { chunk_directional_lights_iteration_mask } from "./chunk_directional_lights_iteration_mask.js";
 
-const DIRECTIONAL_DESCRIPTOR = LIGHT_DATABASE_SPEC.get('light_directional');
+const DIRECTIONAL_DESCRIPTOR = LIGHT_DATABASE_SPEC.get("light_directional");
 
 /**
  * "The sun" — the first occupied directional light in the table.
@@ -21,6 +16,8 @@ const DIRECTIONAL_DESCRIPTOR = LIGHT_DATABASE_SPEC.get('light_directional');
  * iterating; per-pixel direct shading should iterate via
  * {@link chunk_directional_lights_iteration_mask} so every directional
  * light contributes.
+ *
+ * @type {CodeChunk}
  */
 export const chunk_light_get_sun = CodeChunk.from(
     //language=WGSL
@@ -41,21 +38,4 @@ export const chunk_light_get_sun = CodeChunk.from(
     ]
 );
 
-/**
- * @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.from(
-// language=WGSL
-    `
-fn sample_sky_color(position: vec3<f32>, direction:vec3<f32>) -> vec3<f32>{
-    return sample_sky_irradiance_lut( direction );
-}
-    `, [
-        chunk_sample_environment_color,
-        chunk_planet_intersection,
-        chunk_integrate_scattering,
-        chunk_light_get_sun,
-        F32_MAX_DEFINITION,
-    ]
-);
+chunk_light_get_sun.requireResource(LIGHT_DATA_RESOURCE);

package/src/shade/renderer/shadow/sdf/cascade/shader_scene_sdf_soft_shadows.js

@@ -15,7 +15,7 @@ import {
 } from "../../../shader/chunk/geometry/normal/chunk_decode_g_buffer_face_normal.js";
 import { RAY_STRUCT } from "../../../shader/chunk/geometry/ray/RAY_STRUCT.js";
 import { chunk_v3_matrix4_project } from "../../../shader/chunk/geometry/vec3/chunk_v3_matrix4_project.js";
-import { chunk_light_get_sun } from "../../../shader/chunk/light/sky/chunk_sample_sky_color.js";
+import { chunk_light_get_sun } from "../../../shader/chunk/light/io/chunk_light_get_sun.js";
 import { chunk_spatio_temporal_noise_r2_64 } from "../../../shader/chunk/noise/chunk_spatio_temporal_noise_r2_64.js";
 import { chunk_texel_coordinate_to_uv } from "../../../shader/chunk/texture/chunk_texel_coordinate_to_uv.js";
 import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";

package/src/shade/renderer/trails/GPUTrailAVBOITChannel.d.ts

@@ -0,0 +1,69 @@
+/**
+ * The GPU trails as an `AVBOITSideChannel`: drawn inside the transparency pipeline, order-independently
+ * against the transparent meshes, the particles, the dynamic meshes and each other.
+ *
+ * - **occupancy** — the segments pass: a thread per live segment, culled by fade and by the view
+ *   frustum, marking the depth slices its capsule spans and appending itself to its draw class's list.
+ * - **splat** and **draw** — the unlit pair the dynamic meshes draw through, with the tube extruded in
+ *   the vertex stage: one indexed indirect draw per draw class, a segment an instance.
+ *
+ * The frame's simulation is recorded before this is asked (the trails' frame extension runs at
+ * AfterLighting); {@link begin_frame} hands it over with the view it was recorded for. A registered
+ * trail makes the channel non-empty: whether every trail has faded is the GPU's to know, and the CPU
+ * does not read it back.
+ */
+export class GPUTrailAVBOITChannel {
+    /**
+     * The frame's simulation, for the view it is drawn in.
+     *
+     * @param {object} graph
+     * @param {import("../view/GPUViewContext.js").GPUViewContext} view
+     * @param {import("./GPUTrailSystem.js").GPUTrailSystem} runtime
+     * @param {import("./graph_trails.js").TrailSimulationHandles} simulation
+     */
+    begin_frame(graph: object, view: import("../view/GPUViewContext.js").GPUViewContext, runtime: import("./GPUTrailSystem.js").GPUTrailSystem, simulation: import("./graph_trails.js").TrailSimulationHandles): void;
+    /**
+     * Forget the frame: the passes carry their own references to what they read.
+     */
+    end_frame(): void;
+    /**
+     * @param {import("../view/GPUViewContext.js").GPUViewContext} view
+     * @returns {boolean}
+     */
+    avboit_is_empty(view: import("../view/GPUViewContext.js").GPUViewContext): boolean;
+    avboit_occupancy({ graph, camera, cluster_parameters, occupancy }: {
+        graph: any;
+        camera: any;
+        cluster_parameters: any;
+        occupancy: any;
+    }): number;
+    avboit_splat({ graph, camera, warp, voxel_resolution, volume }: {
+        graph: any;
+        camera: any;
+        warp: any;
+        voxel_resolution: any;
+        volume: any;
+    }): {
+        extinction: number;
+        overflow: number;
+        dummy: number;
+    };
+    avboit_draw({ graph, view_ctx, camera, depth_texture, warp, integral, volumetrics_lut, volumetrics_metadata, accumulators }: {
+        graph: any;
+        view_ctx: any;
+        camera: any;
+        depth_texture: any;
+        warp: any;
+        integral: any;
+        volumetrics_lut: any;
+        volumetrics_metadata: any;
+        accumulators: any;
+    }): {
+        color: number;
+        norm: number;
+        extinction: number;
+        emission: number;
+    };
+    #private;
+}
+//# sourceMappingURL=GPUTrailAVBOITChannel.d.ts.map

package/src/shade/renderer/trails/GPUTrailAVBOITChannel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GPUTrailAVBOITChannel.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/trails/GPUTrailAVBOITChannel.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;GAaG;AACH;IAMI;;;;;;;OAOG;IACH,mBALW,MAAM,QACN,OAAO,2BAA2B,EAAE,cAAc,WAClD,OAAO,qBAAqB,EAAE,cAAc,cAC5C,OAAO,mBAAmB,EAAE,sBAAsB,QAI5D;IAED;;OAEG;IACH,kBAEC;IAED;;;OAGG;IACH,sBAHW,OAAO,2BAA2B,EAAE,cAAc,GAChD,OAAO,CAMnB;IAED;;;;;eAaC;IAED;;;;;;;;;;MAeC;IAED;;;;;;;;;;;;;;;MAgCC;;CAYJ"}

package/src/shade/renderer/trails/GPUTrailAVBOITChannel.js

@@ -0,0 +1,129 @@
+import { assert } from "../../../core/assert.js";
+import { graph_trails_avboit_draw, graph_trails_avboit_segments, graph_trails_avboit_splat } from "./graph_trails_avboit.js";
+
+/**
+ * The GPU trails as an `AVBOITSideChannel`: drawn inside the transparency pipeline, order-independently
+ * against the transparent meshes, the particles, the dynamic meshes and each other.
+ *
+ * - **occupancy** — the segments pass: a thread per live segment, culled by fade and by the view
+ *   frustum, marking the depth slices its capsule spans and appending itself to its draw class's list.
+ * - **splat** and **draw** — the unlit pair the dynamic meshes draw through, with the tube extruded in
+ *   the vertex stage: one indexed indirect draw per draw class, a segment an instance.
+ *
+ * The frame's simulation is recorded before this is asked (the trails' frame extension runs at
+ * AfterLighting); {@link begin_frame} hands it over with the view it was recorded for. A registered
+ * trail makes the channel non-empty: whether every trail has faded is the GPU's to know, and the CPU
+ * does not read it back.
+ */
+export class GPUTrailAVBOITChannel {
+    /**
+     * @type {{graph: object, view: object, runtime: import("./GPUTrailSystem.js").GPUTrailSystem, simulation: import("./graph_trails.js").TrailSimulationHandles, segments: import("./graph_trails_avboit.js").TrailSegmentsHandles|null}|null}
+     */
+    #frame = null;
+
+    /**
+     * The frame's simulation, for the view it is drawn in.
+     *
+     * @param {object} graph
+     * @param {import("../view/GPUViewContext.js").GPUViewContext} view
+     * @param {import("./GPUTrailSystem.js").GPUTrailSystem} runtime
+     * @param {import("./graph_trails.js").TrailSimulationHandles} simulation
+     */
+    begin_frame(graph, view, runtime, simulation) {
+        this.#frame = { graph, view, runtime, simulation, segments: null };
+    }
+
+    /**
+     * Forget the frame: the passes carry their own references to what they read.
+     */
+    end_frame() {
+        this.#frame = null;
+    }
+
+    /**
+     * @param {import("../view/GPUViewContext.js").GPUViewContext} view
+     * @returns {boolean}
+     */
+    avboit_is_empty(view) {
+        const frame = this.#frame;
+
+        return frame === null || frame.view !== view || frame.runtime.count === 0;
+    }
+
+    avboit_occupancy({ graph, camera, cluster_parameters, occupancy }) {
+        const frame = this.#frame_for(graph);
+
+        frame.segments = graph_trails_avboit_segments({
+            graph,
+            camera,
+            cluster_parameters,
+            occupancy,
+            simulation: frame.simulation,
+            runtime: frame.runtime,
+        });
+
+        return frame.segments.occupancy;
+    }
+
+    avboit_splat({ graph, camera, warp, voxel_resolution, volume }) {
+        const frame = this.#frame_for(graph);
+
+        assert.notNull(frame.segments, "the occupancy was not recorded into this graph");
+
+        return graph_trails_avboit_splat({
+            graph,
+            camera,
+            warp,
+            voxel_resolution,
+            volume,
+            simulation: frame.simulation,
+            segments: frame.segments,
+            runtime: frame.runtime,
+        });
+    }
+
+    avboit_draw({
+                    graph,
+                    view_ctx,
+                    camera,
+                    depth_texture,
+                    warp,
+                    integral,
+                    volumetrics_lut,
+                    volumetrics_metadata,
+                    accumulators
+                }) {
+        const frame = this.#frame_for(graph);
+
+        assert.notNull(frame.segments, "the occupancy was not recorded into this graph");
+
+        // the last of the three: what is left is the passes'
+        this.#frame = null;
+
+        return graph_trails_avboit_draw({
+            graph,
+            view_ctx,
+            camera,
+            depth_texture,
+            warp,
+            integral,
+            volumetrics_lut,
+            volumetrics_metadata,
+            accumulators,
+            simulation: frame.simulation,
+            segments: frame.segments,
+            runtime: frame.runtime,
+        });
+    }
+
+    /**
+     * @param {object} graph
+     */
+    #frame_for(graph) {
+        const frame = this.#frame;
+
+        assert.ok(frame !== null && frame.graph === graph, "the trails' simulation was not recorded into this graph");
+
+        return frame;
+    }
+}