@woosh/meep-engine 3.67.0 → 3.69.0

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

@@ -16,5 +16,22 @@
  * @type {Readonly<SamplerDescriptor>}
  */
 export const SAMPLER_SKY_LUT: Readonly<SamplerDescriptor>;
+/**
+ * Resource declaration for `sSkyLut`, paired with {@link SKY_LUT_TRANSMITTANCE_RESOURCE} and
+ * {@link SKY_LUT_MULTISCATTER_RESOURCE}.
+ * @type {ShaderResourceDescriptor}
+ */
+export const SKY_LUT_SAMPLER_RESOURCE: ShaderResourceDescriptor;
+/**
+ * Resource declaration for `tSkyLutTransmittance`.
+ * @type {ShaderResourceDescriptor}
+ */
+export const SKY_LUT_TRANSMITTANCE_RESOURCE: ShaderResourceDescriptor;
+/**
+ * Resource declaration for `tSkyLutMultiscatter`.
+ * @type {ShaderResourceDescriptor}
+ */
+export const SKY_LUT_MULTISCATTER_RESOURCE: ShaderResourceDescriptor;
 import { SamplerDescriptor } from "../../descriptor/texture/SamplerDescriptor.js";
+import { ShaderResourceDescriptor } from "../shader/resource/ShaderResourceDescriptor.js";
 //# sourceMappingURL=SAMPLER_SKY_LUT.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"SAMPLER_SKY_LUT.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/atmosphere/SAMPLER_SKY_LUT.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;GAgBG;AACH,8BAFU,SAAS,iBAAiB,CAAC,CAOjC;kCAxB8B,+CAA+C"}
+{"version":3,"file":"SAMPLER_SKY_LUT.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/atmosphere/SAMPLER_SKY_LUT.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;GAgBG;AACH,8BAFU,SAAS,iBAAiB,CAAC,CAOjC;AAEJ;;;;GAIG;AACH,uCAFU,wBAAwB,CAMhC;AAEF;;;GAGG;AACH,6CAFU,wBAAwB,CAKhC;AAEF;;;GAGG;AACH,4CAFU,wBAAwB,CAKhC;kCAtDgC,+CAA+C;yCACxC,gDAAgD"}

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

@@ -1,25 +1,55 @@
-import { SamplerDescriptor } from "../../descriptor/texture/SamplerDescriptor.js";
-
-/**
- * Filtering sampler for the sky LUTs (transmittance, multiple-scattering).
- *
- * Both LUTs are `rgba16float`, which is filterable in core WebGPU — only the 32-bit float
- * formats need the `float32-filterable` feature — so these can go through the texture unit
- * instead of the 4-tap manual bilinear in `texture_sample_bilinear_uv`.
- *
- * `min` and `mag` are both set: the LUTs are single-mip and sampled with an explicit LOD of
- * 0, which selects the magnification filter, but relying on that alone would silently fall
- * back to point sampling if either LUT ever grew mips.
- *
- * Clamp-to-edge reproduces the manual filter's per-corner clamping exactly: `uv` is
- * saturated by `sky_lut_uv`, and at the edges both bilinear taps collapse onto the edge
- * texel.
- *
- * @type {Readonly<SamplerDescriptor>}
- */
-export const SAMPLER_SKY_LUT = Object.freeze(SamplerDescriptor.from({
-    magFilter: "linear",
-    minFilter: "linear",
-    addressModeU: "clamp-to-edge",
-    addressModeV: "clamp-to-edge",
-}));
+import { SamplerDescriptor } from "../../descriptor/texture/SamplerDescriptor.js";
+import { ShaderResourceDescriptor } from "../shader/resource/ShaderResourceDescriptor.js";
+
+/**
+ * Filtering sampler for the sky LUTs (transmittance, multiple-scattering).
+ *
+ * Both LUTs are `rgba16float`, which is filterable in core WebGPU — only the 32-bit float
+ * formats need the `float32-filterable` feature — so these can go through the texture unit
+ * instead of the 4-tap manual bilinear in `texture_sample_bilinear_uv`.
+ *
+ * `min` and `mag` are both set: the LUTs are single-mip and sampled with an explicit LOD of
+ * 0, which selects the magnification filter, but relying on that alone would silently fall
+ * back to point sampling if either LUT ever grew mips.
+ *
+ * Clamp-to-edge reproduces the manual filter's per-corner clamping exactly: `uv` is
+ * saturated by `sky_lut_uv`, and at the edges both bilinear taps collapse onto the edge
+ * texel.
+ *
+ * @type {Readonly<SamplerDescriptor>}
+ */
+export const SAMPLER_SKY_LUT = Object.freeze(SamplerDescriptor.from({
+    magFilter: "linear",
+    minFilter: "linear",
+    addressModeU: "clamp-to-edge",
+    addressModeV: "clamp-to-edge",
+}));
+
+/**
+ * Resource declaration for `sSkyLut`, paired with {@link SKY_LUT_TRANSMITTANCE_RESOURCE} and
+ * {@link SKY_LUT_MULTISCATTER_RESOURCE}.
+ * @type {ShaderResourceDescriptor}
+ */
+export const SKY_LUT_SAMPLER_RESOURCE = ShaderResourceDescriptor.sampler(
+    "sSkyLut",
+    "filtering",
+    SAMPLER_SKY_LUT
+);
+
+/**
+ * Resource declaration for `tSkyLutTransmittance`.
+ * @type {ShaderResourceDescriptor}
+ */
+export const SKY_LUT_TRANSMITTANCE_RESOURCE = ShaderResourceDescriptor.texture(
+    "tSkyLutTransmittance",
+    "float"
+);
+
+/**
+ * Resource declaration for `tSkyLutMultiscatter`.
+ * @type {ShaderResourceDescriptor}
+ */
+export const SKY_LUT_MULTISCATTER_RESOURCE = ShaderResourceDescriptor.texture(
+    "tSkyLutMultiscatter",
+    "float"
+);

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

@@ -0,0 +1,164 @@
+/**
+ * Scene-owned physical atmosphere configuration for Hillaire (2020) sky and aerial scattering.
+ *
+ * All CPU properties on this class are authored in world-space metres and inverse metres
+ * ($\text{m}^{-1}$). {@link write_uniform} converts lengths and coefficients into GPU atmosphere
+ * units ($\text{km}$ and $\text{km}^{-1}$, via `ATMOSPHERE_UNIT_METERS`) when uploading to
+ * {@link ATMOSPHERE_PARAMETERS_STRUCT}.
+ *
+ * Mutating parameters in place requires calling {@link invalidate} (or setting `needsUpdate = true`)
+ * so {@link GPUSky} and {@link GPULightCollection} know to rebuild the atmosphere LUTs and sky IBL,
+ * matching {@link SceneVolumetrics} and {@link LightCollection}. Assigning {@link enabled} bumps
+ * {@link version} automatically.
+ *
+ * @see "A Scalable and Production Ready Sky and Atmosphere Rendering Technique", Hillaire (2020)
+ */
+export class SceneAtmosphere {
+    /**
+     * Monotonically increasing change counter; bumped by {@link enabled} transitions and
+     * {@link invalidate}.
+     *
+     * @type {number}
+     */
+    version: number;
+    /**
+     * Planet radius from centre to sea level, in metres.
+     * @type {number}
+     */
+    planet_radius: number;
+    /**
+     * Thickness of the atmosphere shell above {@link planet_radius}, in metres.
+     * @type {number}
+     */
+    atmosphere_height: number;
+    /**
+     * Exponential scale height of Rayleigh (molecular) density, in metres.
+     * @type {number}
+     */
+    rayleigh_scale_height: number;
+    /**
+     * Sea-level Rayleigh scattering coefficients (RGB), in $\text{m}^{-1}$.
+     * @type {number[]}
+     */
+    rayleigh_scattering: number[];
+    /**
+     * Exponential scale height of Mie (aerosol) density, in metres.
+     * @type {number}
+     */
+    mie_scale_height: number;
+    /**
+     * Sea-level Mie scattering coefficients (RGB), in $\text{m}^{-1}$.
+     * @type {number[]}
+     */
+    mie_scattering: number[];
+    /**
+     * Sea-level Mie extinction coefficients (RGB), in $\text{m}^{-1}$. Mie absorption is derived as
+     * `max(mie_extinction - mie_scattering, 0)`.
+     * @type {number[]}
+     */
+    mie_extinction: number[];
+    /**
+     * Cornette–Shanks aerosol phase asymmetry factor $g \in (-1, 1)$.
+     * @type {number}
+     */
+    mie_phase_g: number;
+    /**
+     * Altitude of peak ozone tent density above sea level, in metres.
+     * @type {number}
+     */
+    ozone_center_height: number;
+    /**
+     * Half-width of the symmetric tent profile for ozone density, in metres.
+     * @type {number}
+     */
+    ozone_half_width: number;
+    /**
+     * Peak ozone absorption coefficients (RGB), in $\text{m}^{-1}$.
+     * @type {number[]}
+     */
+    ozone_absorption: number[];
+    /**
+     * Diffuse Lambertian reflectance (RGB) of the planet surface for multiple scattering and
+     * lower-hemisphere ground bounce.
+     * @type {number[]}
+     */
+    ground_albedo: number[];
+    /**
+     * Reference observer altitude above sea level (in metres) used when baking the scene-wide
+     * octahedral sky IBL map (`GPULightCollection.environment`).
+     * @type {number}
+     */
+    reference_altitude: number;
+    /**
+     * Multiplier applied to the sun directional light's irradiance when driving atmospheric
+     * scattering.
+     * @type {number}
+     */
+    sun_irradiance_scale: number;
+    /**
+     * Whether to synthesise atmospheric skylight from {@link fallback_sun_direction} and
+     * {@link fallback_sun_irradiance} when the scene contains no `DirectionalLight` — ensuring
+     * sunless scenes still receive outdoor indirect illumination when the atmosphere is enabled.
+     * @type {boolean}
+     */
+    fallback_sun_enabled: boolean;
+    /**
+     * World-space unit vector pointing **toward** the fallback sun (+Y up), matching the default
+     * orientation of `make_sunlight()`.
+     * @type {number[]}
+     */
+    fallback_sun_direction: number[];
+    /**
+     * Extraterrestrial RGB solar irradiance used with {@link fallback_sun_direction} when no
+     * `DirectionalLight` is present in the scene.
+     * @type {number[]}
+     */
+    fallback_sun_irradiance: number[];
+    /**
+     * @param {boolean} value
+     */
+    set enabled(value: boolean);
+    /**
+     * Whether procedural Hillaire sky IBL and camera sky background are active when
+     * `scene.lights.environment` is `undefined`.
+     *
+     * @returns {boolean}
+     */
+    get enabled(): boolean;
+    /**
+     * Whether {@link enabled} was explicitly set by caller code.
+     * @returns {boolean}
+     */
+    get enabled_explicitly(): boolean;
+    /**
+     * Enable the atmosphere as an engine-supplied default unless caller code already explicitly
+     * configured {@link enabled}.
+     */
+    enable_by_default(): void;
+    /**
+     * Mark atmosphere parameters dirty so GPU LUTs and procedural sky IBL rebuild on the next
+     * update.
+     */
+    invalidate(): void;
+    /**
+     * Alias matching `LightCollection.needsUpdate`.
+     * @param {boolean} value
+     */
+    set needsUpdate(value: boolean);
+    /**
+     * Marshal physical atmosphere parameters (authored in $\text{m}$ and $\text{m}^{-1}$) into a
+     * POJO matching {@link ATMOSPHERE_PARAMETERS_STRUCT} (in GPU atmosphere units: $\text{km}$ and
+     * $\text{km}^{-1}$).
+     *
+     * @param {Record<string, any>} [out]
+     * @returns {Record<string, any>}
+     */
+    write_uniform(out?: Record<string, any>): Record<string, any>;
+    /**
+     * @readonly
+     * @type {boolean}
+     */
+    readonly isSceneAtmosphere: boolean;
+    #private;
+}
+//# sourceMappingURL=SceneAtmosphere.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"SceneAtmosphere.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/atmosphere/SceneAtmosphere.js"],"names":[],"mappings":"AAuBA;;;;;;;;;;;;;;GAcG;AACH;IAeI;;;;;OAKG;IACH,SAFU,MAAM,CAEJ;IAEZ;;;OAGG;IACH,eAFU,MAAM,CAEU;IAE1B;;;OAGG;IACH,mBAFU,MAAM,CAEY;IAE5B;;;OAGG;IACH,uBAFU,MAAM,CAEc;IAE9B;;;OAGG;IACH,qBAFU,MAAM,EAAE,CAEqC;IAEvD;;;OAGG;IACH,kBAFU,MAAM,CAES;IAEzB;;;OAGG;IACH,gBAFU,MAAM,EAAE,CAE8B;IAEhD;;;;OAIG;IACH,gBAFU,MAAM,EAAE,CAE8B;IAEhD;;;OAGG;IACH,aAFU,MAAM,CAEE;IAElB;;;OAGG;IACH,qBAFU,MAAM,CAEa;IAE7B;;;OAGG;IACH,kBAFU,MAAM,CAEU;IAE1B;;;OAGG;IACH,kBAFU,MAAM,EAAE,CAEgC;IAElD;;;;OAIG;IACH,eAFU,MAAM,EAAE,CAEc;IAEhC;;;;OAIG;IACH,oBAFU,MAAM,CAES;IAEzB;;;;OAIG;IACH,sBAFU,MAAM,CAEW;IAE3B;;;;;OAKG;IACH,sBAFU,OAAO,CAEW;IAE5B;;;;OAIG;IACH,wBAFU,MAAM,EAAE,CAMhB;IAEF;;;;OAIG;IACH,yBAFU,MAAM,EAAE,CAEwB;IAY1C;;OAEG;IACH,4BASC;IAtBD;;;;;OAKG;IACH,uBAEC;IAgBD;;;OAGG;IACH,kCAEC;IAED;;;OAGG;IACH,0BAKC;IAED;;;OAGG;IACH,mBAEC;IAED;;;OAGG;IACH,gCAIC;IAED;;;;;;;OAOG;IACH,oBAHW,OAAO,MAAM,EAAE,GAAG,CAAC,GACjB,OAAO,MAAM,EAAE,GAAG,CAAC,CA0D/B;IAGL;;;OAGG;IACH,4BAFU,OAAO,CAE0B;;CAN1C"}

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

@@ -0,0 +1,308 @@
+import { assert } from "../../../core/assert.js";
+import {
+    INVERSE_METERS_TO_ATMOSPHERE_UNITS,
+    METERS_TO_ATMOSPHERE_UNITS,
+    MIN_ATMOSPHERE_LENGTH_UNITS
+} from "./ATMOSPHERE_UNIT_SCALE.js";
+import { compute_mie_absorption } from "./compute_mie_absorption.js";
+
+const DEFAULT_FALLBACK_SUN_LEN = Math.hypot(0.2, 1.0, -0.2);
+
+/**
+ * @param {readonly number[]} src
+ * @param {number} scale
+ * @param {number[]} [out]
+ * @returns {number[]}
+ */
+function scale_rgb(src, scale, out = [0, 0, 0]) {
+    out[0] = src[0] * scale;
+    out[1] = src[1] * scale;
+    out[2] = src[2] * scale;
+    return out;
+}
+
+/**
+ * Scene-owned physical atmosphere configuration for Hillaire (2020) sky and aerial scattering.
+ *
+ * All CPU properties on this class are authored in world-space metres and inverse metres
+ * ($\text{m}^{-1}$). {@link write_uniform} converts lengths and coefficients into GPU atmosphere
+ * units ($\text{km}$ and $\text{km}^{-1}$, via `ATMOSPHERE_UNIT_METERS`) when uploading to
+ * {@link ATMOSPHERE_PARAMETERS_STRUCT}.
+ *
+ * Mutating parameters in place requires calling {@link invalidate} (or setting `needsUpdate = true`)
+ * so {@link GPUSky} and {@link GPULightCollection} know to rebuild the atmosphere LUTs and sky IBL,
+ * matching {@link SceneVolumetrics} and {@link LightCollection}. Assigning {@link enabled} bumps
+ * {@link version} automatically.
+ *
+ * @see "A Scalable and Production Ready Sky and Atmosphere Rendering Technique", Hillaire (2020)
+ */
+export class SceneAtmosphere {
+    /**
+     * @type {boolean}
+     */
+    #enabled = false;
+
+    /**
+     * Tracks whether application code explicitly assigned {@link enabled}, allowing
+     * {@link GraphicsEngine#set_scene} to enable outdoor sky lighting by default on unconfigured
+     * scenes without overriding a caller that deliberately turned it off.
+     *
+     * @type {boolean}
+     */
+    #enabled_explicitly = false;
+
+    /**
+     * Monotonically increasing change counter; bumped by {@link enabled} transitions and
+     * {@link invalidate}.
+     *
+     * @type {number}
+     */
+    version = 0;
+
+    /**
+     * Planet radius from centre to sea level, in metres.
+     * @type {number}
+     */
+    planet_radius = 6_378_000;
+
+    /**
+     * Thickness of the atmosphere shell above {@link planet_radius}, in metres.
+     * @type {number}
+     */
+    atmosphere_height = 100_000;
+
+    /**
+     * Exponential scale height of Rayleigh (molecular) density, in metres.
+     * @type {number}
+     */
+    rayleigh_scale_height = 8_000;
+
+    /**
+     * Sea-level Rayleigh scattering coefficients (RGB), in $\text{m}^{-1}$.
+     * @type {number[]}
+     */
+    rayleigh_scattering = [5.802e-6, 13.558e-6, 33.100e-6];
+
+    /**
+     * Exponential scale height of Mie (aerosol) density, in metres.
+     * @type {number}
+     */
+    mie_scale_height = 1_200;
+
+    /**
+     * Sea-level Mie scattering coefficients (RGB), in $\text{m}^{-1}$.
+     * @type {number[]}
+     */
+    mie_scattering = [3.996e-6, 3.996e-6, 3.996e-6];
+
+    /**
+     * Sea-level Mie extinction coefficients (RGB), in $\text{m}^{-1}$. Mie absorption is derived as
+     * `max(mie_extinction - mie_scattering, 0)`.
+     * @type {number[]}
+     */
+    mie_extinction = [4.440e-6, 4.440e-6, 4.440e-6];
+
+    /**
+     * Cornette–Shanks aerosol phase asymmetry factor $g \in (-1, 1)$.
+     * @type {number}
+     */
+    mie_phase_g = 0.8;
+
+    /**
+     * Altitude of peak ozone tent density above sea level, in metres.
+     * @type {number}
+     */
+    ozone_center_height = 25_000;
+
+    /**
+     * Half-width of the symmetric tent profile for ozone density, in metres.
+     * @type {number}
+     */
+    ozone_half_width = 15_000;
+
+    /**
+     * Peak ozone absorption coefficients (RGB), in $\text{m}^{-1}$.
+     * @type {number[]}
+     */
+    ozone_absorption = [0.650e-6, 1.881e-6, 0.085e-6];
+
+    /**
+     * Diffuse Lambertian reflectance (RGB) of the planet surface for multiple scattering and
+     * lower-hemisphere ground bounce.
+     * @type {number[]}
+     */
+    ground_albedo = [0.3, 0.3, 0.3];
+
+    /**
+     * Reference observer altitude above sea level (in metres) used when baking the scene-wide
+     * octahedral sky IBL map (`GPULightCollection.environment`).
+     * @type {number}
+     */
+    reference_altitude = 1.0;
+
+    /**
+     * Multiplier applied to the sun directional light's irradiance when driving atmospheric
+     * scattering.
+     * @type {number}
+     */
+    sun_irradiance_scale = 1.0;
+
+    /**
+     * Whether to synthesise atmospheric skylight from {@link fallback_sun_direction} and
+     * {@link fallback_sun_irradiance} when the scene contains no `DirectionalLight` — ensuring
+     * sunless scenes still receive outdoor indirect illumination when the atmosphere is enabled.
+     * @type {boolean}
+     */
+    fallback_sun_enabled = true;
+
+    /**
+     * World-space unit vector pointing **toward** the fallback sun (+Y up), matching the default
+     * orientation of `make_sunlight()`.
+     * @type {number[]}
+     */
+    fallback_sun_direction = [
+        0.2 / DEFAULT_FALLBACK_SUN_LEN,
+        1.0 / DEFAULT_FALLBACK_SUN_LEN,
+        -0.2 / DEFAULT_FALLBACK_SUN_LEN,
+    ];
+
+    /**
+     * Extraterrestrial RGB solar irradiance used with {@link fallback_sun_direction} when no
+     * `DirectionalLight` is present in the scene.
+     * @type {number[]}
+     */
+    fallback_sun_irradiance = [6.0, 6.0, 6.0];
+
+    /**
+     * Whether procedural Hillaire sky IBL and camera sky background are active when
+     * `scene.lights.environment` is `undefined`.
+     *
+     * @returns {boolean}
+     */
+    get enabled() {
+        return this.#enabled;
+    }
+
+    /**
+     * @param {boolean} value
+     */
+    set enabled(value) {
+        assert.isBoolean(value, "value");
+
+        this.#enabled_explicitly = true;
+
+        if (this.#enabled !== value) {
+            this.#enabled = value;
+            this.version++;
+        }
+    }
+
+    /**
+     * Whether {@link enabled} was explicitly set by caller code.
+     * @returns {boolean}
+     */
+    get enabled_explicitly() {
+        return this.#enabled_explicitly;
+    }
+
+    /**
+     * Enable the atmosphere as an engine-supplied default unless caller code already explicitly
+     * configured {@link enabled}.
+     */
+    enable_by_default() {
+        if (!this.#enabled_explicitly && !this.#enabled) {
+            this.#enabled = true;
+            this.version++;
+        }
+    }
+
+    /**
+     * Mark atmosphere parameters dirty so GPU LUTs and procedural sky IBL rebuild on the next
+     * update.
+     */
+    invalidate() {
+        this.version++;
+    }
+
+    /**
+     * Alias matching `LightCollection.needsUpdate`.
+     * @param {boolean} value
+     */
+    set needsUpdate(value) {
+        if (value) {
+            this.version++;
+        }
+    }
+
+    /**
+     * Marshal physical atmosphere parameters (authored in $\text{m}$ and $\text{m}^{-1}$) into a
+     * POJO matching {@link ATMOSPHERE_PARAMETERS_STRUCT} (in GPU atmosphere units: $\text{km}$ and
+     * $\text{km}^{-1}$).
+     *
+     * @param {Record<string, any>} [out]
+     * @returns {Record<string, any>}
+     */
+    write_uniform(out = {}) {
+        out.planet_radius = Math.max(
+            MIN_ATMOSPHERE_LENGTH_UNITS,
+            this.planet_radius * METERS_TO_ATMOSPHERE_UNITS
+        );
+        out.atmosphere_height = Math.max(
+            MIN_ATMOSPHERE_LENGTH_UNITS,
+            this.atmosphere_height * METERS_TO_ATMOSPHERE_UNITS
+        );
+        out.rayleigh_scale_height = Math.max(
+            MIN_ATMOSPHERE_LENGTH_UNITS,
+            this.rayleigh_scale_height * METERS_TO_ATMOSPHERE_UNITS
+        );
+        out.mie_scale_height = Math.max(
+            MIN_ATMOSPHERE_LENGTH_UNITS,
+            this.mie_scale_height * METERS_TO_ATMOSPHERE_UNITS
+        );
+
+        out.rayleigh_scattering = scale_rgb(
+            this.rayleigh_scattering,
+            INVERSE_METERS_TO_ATMOSPHERE_UNITS,
+            out.rayleigh_scattering
+        );
+        // Cornette-Shanks evaluates 0 / 0 along the sun/anti-sun axis when |g| == 1.
+        out.mie_phase_g = Math.min(0.999, Math.max(-0.999, this.mie_phase_g));
+
+        out.mie_scattering = scale_rgb(
+            this.mie_scattering,
+            INVERSE_METERS_TO_ATMOSPHERE_UNITS,
+            out.mie_scattering
+        );
+        out.ozone_center_height = this.ozone_center_height * METERS_TO_ATMOSPHERE_UNITS;
+
+        const mie_absorption = compute_mie_absorption(
+            this.mie_scattering,
+            this.mie_extinction,
+            out.mie_absorption ?? [0, 0, 0]
+        );
+        out.mie_absorption = scale_rgb(
+            mie_absorption,
+            INVERSE_METERS_TO_ATMOSPHERE_UNITS,
+            mie_absorption
+        );
+        out.ozone_half_width = Math.max(
+            MIN_ATMOSPHERE_LENGTH_UNITS,
+            this.ozone_half_width * METERS_TO_ATMOSPHERE_UNITS
+        );
+
+        out.ozone_absorption = scale_rgb(
+            this.ozone_absorption,
+            INVERSE_METERS_TO_ATMOSPHERE_UNITS,
+            out.ozone_absorption
+        );
+        out.ground_albedo = scale_rgb(this.ground_albedo, 1.0, out.ground_albedo);
+
+        return out;
+    }
+}
+
+/**
+ * @readonly
+ * @type {boolean}
+ */
+SceneAtmosphere.prototype.isSceneAtmosphere = true;

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

@@ -1,18 +1,9 @@
 /**
- * One direction's contribution to Equations (5) and (7) from the paper: `out_lum` is the
- * second-order in-scattered luminance along `rayDir`, `out_fms` the luminance that would
- * come back if the medium scattered one unit of light isotropically. The caller integrates
- * over the direction set -- see {@link chunk_multiscatter_sample_direction} -- by taking the
- * mean, which is what the paper's uniform phase p_u = 1/(4*PI) reduces to.
- *
- * Splitting one direction out of the loop is what lets `shader_multiscatter_lut` put a
- * thread on each of the 64 directions.
- *
- * `pos` is assumed to be inside the atmosphere and at or above the surface, which is what
- * makes the far root of the outer sphere the atmosphere exit.
+ * One direction's contribution to Equations (5) and (7) from Hillaire (2020): `out_lum` is the
+ * second-order in-scattered luminance along `rayDir`, `out_fms` the luminance that would come back
+ * if the medium scattered one unit of light isotropically.
  *
  * @see "A Scalable and Production Ready Sky and Atmosphere Rendering Technique", Hillaire (2020)
- * @see https://www.shadertoy.com/view/slSXRW
  * @type {CodeChunk}
  */
 export const chunk_get_multiscatter_values: CodeChunk;

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

@@ -1 +1 @@
-{"version":3,"file":"chunk_get_multiscatter_values.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/atmosphere/chunk_get_multiscatter_values.js"],"names":[],"mappings":"AAuBA;;;;;;;;;;;;;;;;GAgBG;AACH,4CAFU,SAAS,CA2HlB;0BAhJyB,iCAAiC"}
+{"version":3,"file":"chunk_get_multiscatter_values.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/atmosphere/chunk_get_multiscatter_values.js"],"names":[],"mappings":"AAaA;;;;;;;GAOG;AACH,4CAFU,SAAS,CAyGjB;0BAvHwB,iCAAiC"}