@woosh/meep-engine 3.65.0 → 3.68.0

package/src/shade/renderer/Renderer.d.ts

@@ -44,6 +44,12 @@ export class Renderer {
      * @type {ProbeClipmapSettings}
      */
     probe_clipmap: ProbeClipmapSettings;
+    /**
+     * Settings of {@link ShadeIndirectLightingMode.ScreenProbes}, read every frame it runs; its world, the bricks and
+     * the world-space probes, is set by {@link probe_clipmap}. See {@link ScreenProbeSettings}.
+     * @type {ScreenProbeSettings}
+     */
+    screen_probes: ScreenProbeSettings;
     /**
      * Which order-independent transparency technique draws the transparent buckets. Both modes
      * are wired at the single transparency call site and take the same inputs, so this is safe to
@@ -577,6 +583,7 @@ import { SceneManager } from "./scene/SceneManager.js";
 import { ShadeIndirectLightingMode } from "./ShadeIndirectLightingMode.js";
 import { MaterialDispatch } from "./material/dispatch/MaterialDispatch.js";
 import { ProbeClipmapSettings } from "./global_illumination/probe_clipmap/ProbeClipmapSettings.js";
+import { ScreenProbeSettings } from "./global_illumination/screen_probe/ScreenProbeSettings.js";
 import { ShadeTransparencyMode } from "./ShadeTransparencyMode.js";
 import { ToneMapper } from "./deferred/tonemap/ToneMapper.js";
 import { AVBOITSettings } from "./rasterize/native/avboit/AVBOITSettings.js";

package/src/shade/renderer/Renderer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Renderer.d.ts","sourceRoot":"","sources":["../../../../src/shade/renderer/Renderer.js"],"names":[],"mappings":"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"}
+{"version":3,"file":"Renderer.d.ts","sourceRoot":"","sources":["../../../../src/shade/renderer/Renderer.js"],"names":[],"mappings":"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"}

package/src/shade/renderer/Renderer.js

@@ -16,8 +16,11 @@ import { shade_device_floor_unmet } from "../device/shade_device_floor_unmet.js"
 import { ShadeDeviceFailure } from "../device/ShadeDeviceFailure.js";
 import { PipelineEnquiry } from "../device/pipeline/PipelineEnquiry.js";
 import { ShadeGPUCommandContext } from "../device/ShadeGPUCommandContext.js";
+import { create_atmosphere_sun_state, resolve_atmosphere_sun } from "./atmosphere/resolve_atmosphere_sun.js";
+import { SKY_VIEW_LUT_HEIGHT, SKY_VIEW_LUT_WIDTH, shader_sky_view_lut } from "./atmosphere/shader_sky_view_lut.js";
 import { CameraManager } from "./camera/CameraManager.js";
 import { shader_background } from "./deferred/shader_background.js";
+import { shader_background_sky } from "./deferred/shader_background_sky.js";
 import { shader_composite_volumetrics } from "./deferred/shader_composite_volumetrics.js";
 import { shader_deferred_main } from "./deferred/shader_deferred_main.js";
 import { LOCAL_LIGHT_SHADING } from "./deferred/LOCAL_LIGHT_SHADING.js";
@@ -48,6 +51,14 @@ import { shader_diffuse_LPV } from "./global_illumination/lpv/shader_diffuse_LPV
 import { GPUProbeClipmapGI } from "./global_illumination/probe_clipmap/GPUProbeClipmapGI.js";
 import { ProbeClipmapSettings } from "./global_illumination/probe_clipmap/ProbeClipmapSettings.js";
 import { ProbeClipmapDebugView } from "./global_illumination/probe_clipmap/debug/ProbeClipmapDebugView.js";
+import { GPUScreenProbeGI } from "./global_illumination/screen_probe/GPUScreenProbeGI.js";
+import { ScreenProbeSettings } from "./global_illumination/screen_probe/ScreenProbeSettings.js";
+import { ScreenProbeDebugView } from "./global_illumination/screen_probe/ScreenProbeDebugView.js";
+import { graph_screen_probe_debug_view } from "./global_illumination/screen_probe/graph_screen_probe_debug_view.js";
+import {
+    shader_screen_probe_diffuse,
+    shader_screen_probe_indirect_lighting
+} from "./global_illumination/screen_probe/shader_screen_probe_indirect_lighting.js";
 import { shader_resolve_indirect_lighting } from "./global_illumination/shader_resolve_indirect_lighting.js";
 import { GraphicsContext } from "./GraphicsContext.js";
 import {
@@ -137,6 +148,8 @@ METRICS.create({ name: 'frame_time' });
  */
 const INTERNAL_RESOLUTION_MIN = 1;
 
+const SKY_VIEW_LUT_RESOLUTION = Object.freeze([SKY_VIEW_LUT_WIDTH, SKY_VIEW_LUT_HEIGHT]);
+
 MetricCollectionConsoleMonitor.from(METRICS);
 
 export class Renderer {
@@ -243,6 +256,22 @@ export class Renderer {
      */
     #probe_clipmap_gi;
 
+    /**
+     * Settings of {@link ShadeIndirectLightingMode.ScreenProbes}, read every frame it runs; its world, the bricks and
+     * the world-space probes, is set by {@link probe_clipmap}. See {@link ScreenProbeSettings}.
+     * @type {ScreenProbeSettings}
+     */
+    screen_probes = new ScreenProbeSettings();
+
+    /**
+     * The main view's screen probes under {@link ShadeIndirectLightingMode.ScreenProbes}, over the world
+     * {@link #probe_clipmap_gi} holds: made on the first frame in the mode, given back on the first frame out of it.
+     *
+     * Constructed in {@link initialize}.
+     * @type {GPUScreenProbeGI | undefined}
+     */
+    #screen_probe_gi;
+
     /**
      * Which order-independent transparency technique draws the transparent buckets. Both modes
      * are wired at the single transparency call site and take the same inputs, so this is safe to
@@ -713,6 +742,26 @@ export class Renderer {
      */
     #extensions = new RenderExtensionRegistry();
 
+    /**
+     * Reusable per-frame sun state and immediate uniform payloads for Hillaire Sky-View LUT and
+     * background solar-disc composition.
+     */
+    #sky_sun_state = create_atmosphere_sun_state();
+
+    #sky_view_lut_settings = {
+        sun_direction: this.#sky_sun_state.sun_direction,
+        resolution_x: SKY_VIEW_LUT_WIDTH,
+        sun_irradiance: this.#sky_sun_state.sun_irradiance,
+        resolution_y: SKY_VIEW_LUT_HEIGHT,
+    };
+
+    #sky_background_settings = {
+        sun_direction: this.#sky_sun_state.sun_direction,
+        sun_disk_radius: 0,
+        sun_irradiance: this.#sky_sun_state.sun_irradiance,
+        sun_has_disc: 0,
+    };
+
     /**
      * Raised when there is no usable device — the browser has no WebGPU, the hardware is below the
      * floor, or a working device was lost while running. Carries a {@link ShadeDeviceFailure}.
@@ -1150,6 +1199,8 @@ export class Renderer {
         }
 
         this.#volumetrics?.reset_history();
+
+        this.#screen_probe_gi?.reset_history();
     }
 
     /**
@@ -1252,6 +1303,7 @@ export class Renderer {
      * @param {number} params.gr_occlusion_clip
      * @param {number} params.gr_buffer_camera_current
      * @param {number} params.gr_buffer_camera_previous
+     * @param {number} params.gr_exposure_multiplier - graph resource ID of the exposure the last frame was shown at
      * @param {Vector2} params.resolution
      * @returns {number} Updated scene-color graph resource ID
      */
@@ -1273,6 +1325,7 @@ export class Renderer {
                                  gr_occlusion_clip,
                                  gr_buffer_camera_current,
                                  gr_buffer_camera_previous,
+                                 gr_exposure_multiplier,
                                  resolution,
                              }) {
 
@@ -1354,6 +1407,65 @@ export class Renderer {
                 }
                 break;
 
+            case ShadeIndirectLightingMode.ScreenProbes: {
+                // the diffuse is the screen probes', resolved once the bent normals exist; the specular the world-space
+                // probes', as under the probe clipmap
+                const diffuse = this.#screen_probe_gi.graph_resolve({
+                    graph,
+                    depth: gr_texture_depth_current,
+                    depth_previous: gr_texture_depth_previous,
+                    pbr: gr_texture_pbr,
+                    velocity: gr_velocity,
+                    bent_normals,
+                    exposure: gr_exposure_multiplier,
+                });
+
+                if (prefer_fused && !this.feature_ssr_enabled) {
+                    [current_color_out] = graph_image_pass({
+                        graph,
+                        shader: shader_screen_probe_indirect_lighting,
+                        output: [current_color_out],
+                        input_depth: gr_texture_depth_current,
+                        load_op: "load",
+                        inputs: this.#probe_clipmap_gi.write_sampling_bindings({
+                            ...this.#probe_clipmap_indirect_inputs({
+                                view_ctx,
+                                depth: gr_texture_depth_current,
+                                normal: gr_texture_normal,
+                                bent_normal: bent_normals,
+                                albedo_ao: gr_texture_material_albedo_ao,
+                                pbr: gr_texture_pbr,
+                                environment: gr_texture_environment,
+                                camera: gr_buffer_camera_current,
+                            }),
+                            tScreenProbeDiffuse: diffuse,
+                        }),
+                    });
+
+                    return current_color_out;
+                }
+
+                diffuse_pass = {
+                    shader: shader_screen_probe_diffuse,
+                    inputs: {
+                        tGBufferAlbedo: gr_texture_material_albedo_ao,
+                        tScreenProbeDiffuse: diffuse,
+                    },
+                };
+                specular_pass = {
+                    shader: shader_specular_IBL,
+                    inputs: {
+                        tBentNormals: bent_normals,
+                        tNormals: gr_texture_normal,
+                        tDepth: gr_texture_depth_current,
+                        tPBR: gr_texture_pbr,
+                        tEnvironment: gr_texture_environment,
+                        camera: gr_buffer_camera_current,
+                    },
+                };
+                break;
+            }
+
             case ShadeIndirectLightingMode.Brick4:
                 // SSR needs its own specular resolve and denoising passes.
                 if (prefer_fused && !this.feature_ssr_enabled) {
@@ -1469,7 +1581,7 @@ export class Renderer {
                 input_environment: gr_texture_environment,
                 brick4: ssr_brick4,
                 lpv: ssr_lpv,
-                input_indirect_diffuse: mode === ShadeIndirectLightingMode.ProbeClipmap ? indirect_diffuse : undefined,
+                input_indirect_diffuse: mode === ShadeIndirectLightingMode.ProbeClipmap || mode === ShadeIndirectLightingMode.ScreenProbes ? indirect_diffuse : undefined,
                 // in every mode: a clipmap of no cascade while it has no probes
                 probes: this.#probe_clipmap_gi,
                 shader_switches: this.#shader_switches,
@@ -1843,6 +1955,7 @@ export class Renderer {
         this.#views = new ViewManager(graphics, this.#cameras, this.#scenes);
         this.#volumetrics = new GPUViewVolumetrics(this.device);
         this.#probe_clipmap_gi = new GPUProbeClipmapGI(graphics);
+        this.#screen_probe_gi = new GPUScreenProbeGI(this.device);
 
         const resolution_internal = this.#internal_resolution.asArray();
 
@@ -1954,6 +2067,8 @@ export class Renderer {
         }
 
         enquiry.render.push(shader_background.pipeline_for(color_formats));
+        enquiry.render.push(shader_sky_view_lut.pipeline);
+        enquiry.render.push(shader_background_sky.pipeline_for(color_formats));
 
         if (this.indirect_lighting_mode === ShadeIndirectLightingMode.IBL) {
             if (!this.feature_ssr_enabled) {
@@ -2067,6 +2182,7 @@ export class Renderer {
         this.#nss?.destroy();
         this.#volumetrics?.destroy();
         this.#probe_clipmap_gi?.destroy();
+        this.#screen_probe_gi?.destroy();
 
         this.#views?.destroy();
         this.#scenes?.destroy();
@@ -2964,7 +3080,11 @@ export class Renderer {
         // (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §5); its hits trace their own shadow rays, so it reads no
         // shadow map. Made for this view and these settings on the first frame in the mode, and given back
         // on the first frame out of it.
-        if (this.indirect_lighting_mode === ShadeIndirectLightingMode.ProbeClipmap) {
+        // The screen probes trace the probe clipmap's world and read its world-space probes past their reach, so that
+        // world runs under both modes; the screen probes follow it in the same frame.
+        const screen_probes = this.indirect_lighting_mode === ShadeIndirectLightingMode.ScreenProbes;
+
+        if (this.indirect_lighting_mode === ShadeIndirectLightingMode.ProbeClipmap || screen_probes) {
             this.#probe_clipmap_gi.graph_update({
                 graph,
                 view: view_ctx,
@@ -2979,6 +3099,25 @@ export class Renderer {
             this.#probe_clipmap_gi.release();
         }
 
+        if (screen_probes) {
+            this.#screen_probe_gi.graph_update({
+                graph,
+                view: view_ctx,
+                settings: this.screen_probes,
+                world: this.#probe_clipmap_gi,
+                stbn: STATIC_GRAPHICS_ENGINE_ASSETS.stbn_vec2,
+                depth: gr_texture_depth_current,
+                normal: gr_texture_normal,
+                pbr: gr_texture_pbr,
+                velocity: gr_velocity,
+                occlusion: gr_occlusion_clip,
+                hzb: gr_texture_hzb,
+                exposure: gr_exposure_multiplier,
+            });
+        } else {
+            this.#screen_probe_gi.release();
+        }
+
         const volumetrics = this.#volumetrics.graph_update({
             graph,
             view: view_ctx,
@@ -3098,18 +3237,60 @@ export class Renderer {
 
 
         // Shade background
-        [current_color_out] = graph_image_pass({
-            graph,
-            shader: shader_background,
-            inputs: {
-                camera: view_ctx.camera.buffer,
-                view: view_ctx.uniform_buffer.buffer,
-                tEnvironment: gr_texture_environment,
-            },
-            input_depth: gr_texture_depth_current,
-            load_op: "load",
-            output: [current_color_out],
-        });
+        if (scene_ctx.scene.lights.environment === undefined && scene_ctx.scene.atmosphere.enabled) {
+            const sky = scene_ctx.sky;
+            sky.update();
+
+            const gr_sky_transmittance = volumetrics.lut_transmittance
+                ?? graph_import_texture(graph, sky.lut_transmittance, "sky/transmittance");
+            const gr_sky_multiscatter = volumetrics.lut_multiple_scattering
+                ?? graph_import_texture(graph, sky.lut_multiple_scattering, "sky/multiscatter");
+
+            const sun = resolve_atmosphere_sun(scene_ctx.scene, this.#sky_sun_state);
+            this.#sky_background_settings.sun_disk_radius = sun.sun_disk_radius;
+            this.#sky_background_settings.sun_has_disc = sun.sun_has_disc;
+
+            const [gr_sky_view_lut] = graph_image_pass({
+                graph,
+                shader: shader_sky_view_lut,
+                output_resolution: SKY_VIEW_LUT_RESOLUTION,
+                inputs: {
+                    settings: this.#sky_view_lut_settings,
+                    camera: view_ctx.camera.buffer,
+                    atmosphere: sky.parameters_buffer.buffer,
+                    tSkyLutTransmittance: gr_sky_transmittance,
+                    tSkyLutMultiscatter: gr_sky_multiscatter,
+                },
+            });
+
+            [current_color_out] = graph_image_pass({
+                graph,
+                shader: shader_background_sky,
+                inputs: {
+                    settings: this.#sky_background_settings,
+                    camera: view_ctx.camera.buffer,
+                    atmosphere: sky.parameters_buffer.buffer,
+                    tSkyViewLut: gr_sky_view_lut,
+                    tSkyLutTransmittance: gr_sky_transmittance,
+                },
+                input_depth: gr_texture_depth_current,
+                load_op: "load",
+                output: [current_color_out],
+            });
+        } else {
+            [current_color_out] = graph_image_pass({
+                graph,
+                shader: shader_background,
+                inputs: {
+                    camera: view_ctx.camera.buffer,
+                    view: view_ctx.uniform_buffer.buffer,
+                    tEnvironment: gr_texture_environment,
+                },
+                input_depth: gr_texture_depth_current,
+                load_op: "load",
+                output: [current_color_out],
+            });
+        }
 
         current_color_out = this.#graph_indirect_lighting({
             graph,
@@ -3129,9 +3310,15 @@ export class Renderer {
             gr_occlusion_clip,
             gr_buffer_camera_current,
             gr_buffer_camera_previous,
+            gr_exposure_multiplier,
             resolution,
         });
 
+        // the opaque surfaces' lit colour, the screen probes' hits' radiance next frame: before fog and transparencies
+        if (screen_probes) {
+            this.#screen_probe_gi.graph_capture({ graph, color: current_color_out });
+        }
+
         // Composite volumetric fog over the finalized opaque + background + indirect colour.
         // A dedicated pass (not inline in the shading shaders) because indirect lighting is added
         // in a separate additively-blended pass, so the full surface radiance only exists here.
@@ -3299,7 +3486,18 @@ export class Renderer {
 
         // the probe clipmap mode's debug views replace the colour the same way
         if (
-            this.indirect_lighting_mode === ShadeIndirectLightingMode.ProbeClipmap
+            screen_probes
+            && this.screen_probes.debug_view !== ScreenProbeDebugView.None
+        ) {
+            current_color_out = graph_screen_probe_debug_view({
+                graph,
+                gi: this.#screen_probe_gi,
+                view_mode: this.screen_probes.debug_view,
+                depth: gr_texture_depth_current,
+                resolution: resolution_internal.asArray(),
+            });
+        } else if (
+            (this.indirect_lighting_mode === ShadeIndirectLightingMode.ProbeClipmap || screen_probes)
             && this.probe_clipmap.debug_view !== ProbeClipmapDebugView.None
         ) {
             current_color_out = this.#probe_clipmap_gi.graph_debug_view({
@@ -3404,8 +3602,6 @@ export class Renderer {
             });
         }
 
-        let exposure = -1;
-
         /*
          The scene as it stands before bloom composites over it: what the metering reads, and what
          bloom reads too.
@@ -3437,21 +3633,22 @@ export class Renderer {
             current_color_out = bloom.composited;
         }
 
-        if (this.feature_automatic_exposure_enabled) {
-            // TODO force time_delta_second to a very high value on view transition
+        const gr_exposure_adaptation = graph_import_buffer(graph, this.#autoexposure.adaptation, "exposure adaptation");
 
-            exposure = this.#autoexposure.update({
+        // TODO force time_delta_second to a very high value on view transition
+        const exposure = this.feature_automatic_exposure_enabled
+            ? this.#autoexposure.update({
                 graph,
                 input_color: metered_color,
                 multiplier: gr_exposure_multiplier,
+                adaptation: gr_exposure_adaptation,
                 time_delta_seconds,
+            })
+            : this.#autoexposure.unadapted({
+                graph,
+                multiplier: gr_exposure_multiplier,
+                adaptation: gr_exposure_adaptation,
             });
-        }
-
-
-        if (this.feature_automatic_exposure_enabled === false) {
-            exposure = this.#autoexposure.unadapted({ graph, multiplier: gr_exposure_multiplier });
-        }
 
 
         // current_color_out = graph_draw_texture_as_rgba({
@@ -3477,7 +3674,8 @@ export class Renderer {
         current_color_out = this.tone_mapper.render({
             graph,
             input_color: current_color_out,
-            exposure,
+            exposure: exposure.multiplier,
+            adaptation: exposure.adaptation,
             hdr: this.#hdr_supported,
             target: gr_texture_canvas,
         });

package/src/shade/renderer/ShadeIndirectLightingMode.d.ts

@@ -8,5 +8,6 @@ export namespace ShadeIndirectLightingMode {
     let Brick4: number;
     let LPV: number;
     let ProbeClipmap: number;
+    let ScreenProbes: number;
 }
 //# sourceMappingURL=ShadeIndirectLightingMode.d.ts.map

package/src/shade/renderer/ShadeIndirectLightingMode.js

@@ -17,4 +17,13 @@ export const ShadeIndirectLightingMode = {
      * `Renderer.probe_clipmap`. Lit as {@link IBL} until its probes are traced (that proposal's §13, S4).
      */
     ProbeClipmap: 3,
+    /**
+     * Lumen's screen probe gather over the {@link ProbeClipmap}'s world: probes placed on the G-buffer every few
+     * pixels, more densely where interpolation between them would cross an edge, traced through the screen and
+     * then the SDF bricks, the world-space probes standing in for what lies past a probe's own reach, and
+     * reprojected from frame to frame (`global_illumination/screen_probe/GPUScreenProbeGI.js`). The opaque surfaces'
+     * diffuse light is the screen probes'; everything else reads the world-space probes as under
+     * {@link ProbeClipmap}. Settings are `Renderer.screen_probes`, and `Renderer.probe_clipmap` for the world.
+     */
+    ScreenProbes: 4,
 };

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

@@ -0,0 +1,22 @@
+/**
+ * Packed GPU uniform representation of {@link SceneAtmosphere} in GPU atmosphere units
+ * ($\text{km}$ and $\text{km}^{-1}$, scaled via `ATMOSPHERE_UNIT_METERS`).
+ *
+ * @see "A Scalable and Production Ready Sky and Atmosphere Rendering Technique", Hillaire (2020)
+ * @type {WebGPUStruct}
+ */
+export const ATMOSPHERE_PARAMETERS_STRUCT: WebGPUStruct;
+/**
+ * Deeply frozen default Earth uniform payload matching {@link ATMOSPHERE_PARAMETERS_STRUCT}.
+ */
+export const ATMOSPHERE_EARTH_UNIFORM: Readonly<Record<string, any>>;
+/**
+ * Parameterised Hillaire (2020) atmosphere medium, geometry, and LUT coordinate helpers operating
+ * on {@link ATMOSPHERE_PARAMETERS_STRUCT}.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_atmosphere_parameters: CodeChunk;
+import { WebGPUStruct } from "../shader/type/WebGPUStruct.js";
+import { CodeChunk } from "../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=ATMOSPHERE_PARAMETERS_STRUCT.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ATMOSPHERE_PARAMETERS_STRUCT.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/atmosphere/ATMOSPHERE_PARAMETERS_STRUCT.js"],"names":[],"mappings":"AAQA;;;;;;GAMG;AACH,2CAFU,YAAY,CAmBK;AAE3B;;GAEG;AACH,qEAQK;AAEL;;;;;GAKG;AACH,0CAFU,SAAS,CA4GjB;6BA5J2B,gCAAgC;0BAFnC,iCAAiC"}

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

@@ -0,0 +1,160 @@
+import { chunk_atmosphere_ray_bounds } from "../shader/chunk/atmosphere/chunk_atmosphere_ray_bounds.js";
+import { CodeChunk } from "../shader/compiler/CodeChunk.js";
+import { f32, vec3f } from "../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUStruct } from "../shader/type/WebGPUStruct.js";
+import { ATMOSPHERE_ALTITUDE_CUTOFF } from "./ATMOSPHERE_ALTITUDE_CUTOFF.js";
+import { ATMOSPHERE_UNIT_SCALE_DECLARATION } from "./ATMOSPHERE_UNIT_SCALE.js";
+import { SceneAtmosphere } from "./SceneAtmosphere.js";
+
+/**
+ * Packed GPU uniform representation of {@link SceneAtmosphere} in GPU atmosphere units
+ * ($\text{km}$ and $\text{km}^{-1}$, scaled via `ATMOSPHERE_UNIT_METERS`).
+ *
+ * @see "A Scalable and Production Ready Sky and Atmosphere Rendering Technique", Hillaire (2020)
+ * @type {WebGPUStruct}
+ */
+export const ATMOSPHERE_PARAMETERS_STRUCT = WebGPUStruct.from({
+    planet_radius: f32,
+    atmosphere_height: f32,
+    rayleigh_scale_height: f32,
+    mie_scale_height: f32,
+
+    rayleigh_scattering: vec3f,
+    mie_phase_g: f32,
+
+    mie_scattering: vec3f,
+    ozone_center_height: f32,
+
+    mie_absorption: vec3f,
+    ozone_half_width: f32,
+
+    ozone_absorption: vec3f,
+    ground_albedo: vec3f,
+}, "AtmosphereParameters");
+
+/**
+ * Deeply frozen default Earth uniform payload matching {@link ATMOSPHERE_PARAMETERS_STRUCT}.
+ */
+export const ATMOSPHERE_EARTH_UNIFORM = (() => {
+    const raw = new SceneAtmosphere().write_uniform();
+    raw.rayleigh_scattering = Object.freeze([...raw.rayleigh_scattering]);
+    raw.mie_scattering = Object.freeze([...raw.mie_scattering]);
+    raw.mie_absorption = Object.freeze([...raw.mie_absorption]);
+    raw.ozone_absorption = Object.freeze([...raw.ozone_absorption]);
+    raw.ground_albedo = Object.freeze([...raw.ground_albedo]);
+    return Object.freeze(raw);
+})();
+
+/**
+ * Parameterised Hillaire (2020) atmosphere medium, geometry, and LUT coordinate helpers operating
+ * on {@link ATMOSPHERE_PARAMETERS_STRUCT}.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_atmosphere_parameters = CodeChunk.from(
+    //language=WGSL
+    `
+fn atmosphere_earth_parameters() -> ${ATMOSPHERE_PARAMETERS_STRUCT.wgsl_ref} {
+    var atm: ${ATMOSPHERE_PARAMETERS_STRUCT.wgsl_ref};
+    atm.planet_radius = 6378000.0 * METERS_TO_ATMOSPHERE_UNITS;
+    atm.atmosphere_height = 100000.0 * METERS_TO_ATMOSPHERE_UNITS;
+    atm.rayleigh_scale_height = 8000.0 * METERS_TO_ATMOSPHERE_UNITS;
+    atm.mie_scale_height = 1200.0 * METERS_TO_ATMOSPHERE_UNITS;
+    atm.rayleigh_scattering = vec3<f32>(5.802e-6, 13.558e-6, 33.100e-6) * INVERSE_METERS_TO_ATMOSPHERE_UNITS;
+    atm.mie_phase_g = 0.8;
+    atm.mie_scattering = vec3<f32>(3.996e-6, 3.996e-6, 3.996e-6) * INVERSE_METERS_TO_ATMOSPHERE_UNITS;
+    atm.ozone_center_height = 25000.0 * METERS_TO_ATMOSPHERE_UNITS;
+    atm.mie_absorption = vec3<f32>(0.444e-6, 0.444e-6, 0.444e-6) * INVERSE_METERS_TO_ATMOSPHERE_UNITS;
+    atm.ozone_half_width = 15000.0 * METERS_TO_ATMOSPHERE_UNITS;
+    atm.ozone_absorption = vec3<f32>(0.650e-6, 1.881e-6, 0.085e-6) * INVERSE_METERS_TO_ATMOSPHERE_UNITS;
+    atm.ground_albedo = vec3<f32>(0.3, 0.3, 0.3);
+    return atm;
+}
+
+fn atmosphere_planet_center_for(atm: ${ATMOSPHERE_PARAMETERS_STRUCT.wgsl_ref}) -> vec3<f32> {
+    return vec3<f32>(0.0, -atm.planet_radius, 0.0);
+}
+
+// Converts a world-space position (in metres) into planet-centre-relative GPU atmosphere units (km).
+fn atmosphere_position_relative_for(atm: ${ATMOSPHERE_PARAMETERS_STRUCT.wgsl_ref}, pos_ws: vec3<f32>) -> vec3<f32> {
+    return pos_ws * METERS_TO_ATMOSPHERE_UNITS - atmosphere_planet_center_for(atm);
+}
+
+// Planet-centre-relative observer position (in km) clamped away from the ground and top-of-atmosphere boundaries.
+fn atmosphere_clamped_observer_relative(
+    atm: ${ATMOSPHERE_PARAMETERS_STRUCT.wgsl_ref},
+    world_pos: vec3<f32>
+) -> vec3<f32> {
+    let rel = atmosphere_position_relative_for(atm, world_pos);
+    let r_raw = length(rel);
+    let up = select(vec3<f32>(0.0, 1.0, 0.0), rel / r_raw, r_raw > 0.0);
+    let cutoff = ${ATMOSPHERE_ALTITUDE_CUTOFF.toFixed(1)} * METERS_TO_ATMOSPHERE_UNITS;
+    let min_r = atm.planet_radius + cutoff;
+    let max_r = max(min_r, atm.planet_radius + atm.atmosphere_height - cutoff);
+    return up * clamp(r_raw, min_r, max_r);
+}
+
+fn atmosphere_density_for(atm: ${ATMOSPHERE_PARAMETERS_STRUCT.wgsl_ref}, h: f32) -> vec3<f32> {
+    let clamped_h = max(h, 0.0);
+    let rayleigh = exp(-clamped_h / max(atm.rayleigh_scale_height, MIN_ATMOSPHERE_LENGTH_UNITS));
+    let mie = exp(-clamped_h / max(atm.mie_scale_height, MIN_ATMOSPHERE_LENGTH_UNITS));
+    let ozone = max(0.0, 1.0 - abs(h - atm.ozone_center_height) / max(atm.ozone_half_width, MIN_ATMOSPHERE_LENGTH_UNITS));
+    return vec3<f32>(rayleigh, mie, ozone);
+}
+
+fn atmosphere_extinction_for(atm: ${ATMOSPHERE_PARAMETERS_STRUCT.wgsl_ref}, density: vec3<f32>) -> vec3<f32> {
+    let rayleigh = density.x * atm.rayleigh_scattering;
+    let mie = density.y * (atm.mie_scattering + atm.mie_absorption);
+    let ozone = density.z * atm.ozone_absorption;
+    return rayleigh + mie + ozone;
+}
+
+fn atmosphere_ray_bounds_for(
+    atm: ${ATMOSPHERE_PARAMETERS_STRUCT.wgsl_ref},
+    origin_rel: vec3<f32>,
+    ray_direction: vec3<f32>
+) -> AtmosphereRayBounds {
+    let b = dot(origin_rel, ray_direction);
+    let r = length(origin_rel);
+    let b2 = b * b;
+
+    let ground_r = atm.planet_radius;
+    let top_r = atm.planet_radius + atm.atmosphere_height;
+
+    // Difference-of-squares factoring (r - R)(r + R) avoids catastrophic f32 cancellation when
+    // altitude (r - ground_r) is metres above a 6,378 km planet radius.
+    let atmosphere_distance = -b + sqrt(max(b2 - (r - top_r) * (r + top_r), 0.0));
+
+    let ground_discriminant = b2 - (r - ground_r) * (r + ground_r);
+    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;
+}
+
+fn sky_lut_uv_for(
+    atm: ${ATMOSPHERE_PARAMETERS_STRUCT.wgsl_ref},
+    height: f32,
+    sun_cos_zenith_angle: f32,
+    resolution: vec2<f32>
+) -> vec2<f32> {
+    let unit = vec2<f32>(
+        saturate(0.5 + 0.5 * sun_cos_zenith_angle),
+        saturate(height / max(atm.atmosphere_height, MIN_ATMOSPHERE_LENGTH_UNITS))
+    );
+    return (unit * (resolution - 1.0) + 0.5) / resolution;
+}
+    `, [
+        ATMOSPHERE_UNIT_SCALE_DECLARATION,
+        ATMOSPHERE_PARAMETERS_STRUCT.declaration_chunk,
+        chunk_atmosphere_ray_bounds,
+    ]
+);