babylonjs-addons 8.26.1 → 8.26.2

package/babylonjs.addons.d.ts

@@ -683,6 +683,1145 @@ declare module ADDONS {
     };
 
 
+    /**
+     * The transmittance LUT can be used to get the radiance from an external light source arriving a given point, accounting for atmospheric scattering.
+     */
+    export class TransmittanceLut {
+        /**
+         * Listen to this observer to know when the LUT data has been updated.
+         * This is typically infrequent (once at startup), but also happens whenever the atmosphere's properties change.
+         */
+        readonly onUpdatedObservable: BABYLON.Observable<void>;
+        private readonly _atmosphere;
+        private _lutData;
+        private _renderTarget;
+        private _effectWrapper;
+        private _effectRenderer;
+        private _isDirty;
+        private _isDisposed;
+        /**
+         * True if the LUT has been rendered.
+         */
+        get isDirty(): boolean;
+        /**
+         * The render target that contains the transmittance LUT.
+         * @throws if the LUT has been disposed.
+         */
+        get renderTarget(): BABYLON.RenderTargetTexture;
+        /**
+         * Constructs the {@link TransmittanceLut}.
+         * @param atmosphere - The atmosphere that owns this LUT.
+         */
+        constructor(atmosphere: Atmosphere);
+        /**
+         * Gets the transmittance of an external light through the atmosphere to a point specified by its distance to the planet center and its geocentric normal.
+         * The result is always a linear space color.
+         * @param directionToLight - The direction to the light source.
+         * @param pointRadius - The distance from the origin to the point.
+         * @param pointGeocentricNormal - The normal of the point.
+         * @param result - The color to write the result to.
+         * @returns The result color.
+         */
+        getTransmittedColorToRef<T extends BABYLON.IColor3Like>(directionToLight: BABYLON.IVector3Like, pointRadius: number, pointGeocentricNormal: BABYLON.IVector3Like, result: T): T;
+        /**
+         * Derives light color from the transmittance at a point specified by its distance to the planet center and its geocentric normal.
+         * @param light - The light to update.
+         * @param pointRadius - The distance from the origin to the point.
+         * @param pointGeocentricNormal - The normal of the point.
+         */
+        updateLightParameters(light: BABYLON.DirectionalLight, pointRadius: number, pointGeocentricNormal: BABYLON.IVector3Like): void;
+        /**
+         * Renders the LUT if needed.
+         * @returns true if the LUT was rendered.
+         */
+        render(): boolean;
+        /**
+         * Marks the LUT as needing to be rendered.
+         */
+        markDirty(): void;
+        /**
+         * Disposes the LUT and its resources.
+         */
+        dispose(): void;
+    }
+
+
+    /**
+     * Samples the texture data at the given uv coordinate using bilinear interpolation.
+     * Note this will not match GPU sampling behavior exactly.
+     * Currently assumes clamping behavior.
+     * @param u - The u coordinate to sample.
+     * @param v - The v coordinate to sample.
+     * @param widthPx - The width of the texture in texels.
+     * @param heightPx - The height of the texture in texels.
+     * @param data - The texture data to sample.
+     * @param result - The color to store the sample.
+     * @param normalizeFunc - The function to normalize the texel values. Default is to divide by 255.
+     * @returns The result color.
+     */
+    export const Sample2DRgbaToRef: <T extends BABYLON.IColor4Like>(u: number, v: number, widthPx: number, heightPx: number, data: Uint8Array | Uint16Array | Float32Array, result: T, normalizeFunc?: (value: number) => number) => T;
+
+
+
+
+    /**
+     * The diffuse sky irradiance LUT is used to query the diffuse irradiance at a specified position.
+     */
+    export class DiffuseSkyIrradianceLut {
+        private readonly _atmosphere;
+        private _renderTarget;
+        private _effectWrapper;
+        private _effectRenderer;
+        private _isDirty;
+        private _isDisposed;
+        private _lutData;
+        /**
+         * True if the LUT needs to be rendered.
+         */
+        get isDirty(): boolean;
+        /**
+         * True if the LUT has been disposed.
+         */
+        get isDisposed(): boolean;
+        /**
+         * The render target used for this LUT.
+         * @throws if the LUT has been disposed.
+         */
+        get renderTarget(): BABYLON.RenderTargetTexture;
+        /**
+         * True if the LUT data has been read back from the GPU.
+         */
+        get hasLutData(): boolean;
+        /**
+         * Constructs the {@link DiffuseSkyIrradianceLut}.
+         * @param atmosphere - The atmosphere to use.
+         */
+        constructor(atmosphere: Atmosphere);
+        /**
+         * Gets the diffuse sky irradiance for a surface oriented along the geocentric normal.
+         * Resulting color is always in linear space.
+         * @param directionToLight - The direction to the light in world space.
+         * @param radius - The position's distance to the planet origin.
+         * @param cameraGeocentricNormal - The geocentric normal of the camera.
+         * @param lightIrradiance - The irradiance of the light.
+         * @param result - The color to store the result in.
+         * @returns The result color.
+         */
+        getDiffuseSkyIrradianceToRef<T extends BABYLON.IColor3Like>(directionToLight: BABYLON.IVector3Like, radius: number, cameraGeocentricNormal: BABYLON.IVector3Like, lightIrradiance: number, result: T): T;
+        /**
+         * Renders the LUT.
+         * @returns True if the LUT was rendered.
+         */
+        render(): boolean;
+        /**
+         * Marks the LUT as needing to be rendered.
+         */
+        markDirty(): void;
+        /**
+         * Disposes the LUT.
+         */
+        dispose(): void;
+    }
+
+
+    /**
+     * The options for the {@link AtmospherePhysicalProperties} that describe the planet, the atmosphere, and scattering.
+     */
+    export interface IAtmospherePhysicalPropertiesOptions {
+        /**
+         * The radius of the planet in kilometers.
+         */
+        planetRadius?: number;
+        /**
+         * The minimum camera radius (distance from the planet's center) allowed when rendering the atmosphere.
+         * This should be greater than 0.
+         * It prevents rendering issues close to the planet's surface.
+         */
+        planetRadiusOffset?: number;
+        /**
+         * The thickness of the atmosphere measured in kilometers from the planet's surface to the outer edge of the atmosphere.
+         */
+        atmosphereThickness?: number;
+        /**
+         * The scale applied to the Rayleigh scattering.
+         */
+        rayleighScatteringScale?: number;
+        /**
+         * The Rayleigh scattering per kilometer at sea level for red, green, and blue wavelengths.
+         */
+        peakRayleighScattering?: BABYLON.Vector3;
+        /**
+         * The scale applied to the Mie scattering.
+         */
+        mieScatteringScale?: number;
+        /**
+         * The Mie scattering per kilometer at sea level for red, green, and blue wavelengths.
+         */
+        peakMieScattering?: BABYLON.Vector3;
+        /**
+         * The scale applied to the Mie absorption.
+         */
+        mieAbsorptionScale?: number;
+        /**
+         * The Mie absorption per kilometer at sea level for red, green, and blue wavelengths.
+         */
+        peakMieAbsorption?: BABYLON.Vector3;
+        /**
+         * The scale applied to the ozone absorption.
+         */
+        ozoneAbsorptionScale?: number;
+        /**
+         * The ozone absorption per kilometer at sea level for red, green, and blue wavelengths.
+         */
+        peakOzoneAbsorption?: BABYLON.Vector3;
+    }
+
+
+    /**
+     * Describes the physical properties of the atmosphere. Assumes a spherical planet.
+     * - "radius" values describe a distance from the planet's center.
+     * - "height" values describe a distance from the planet's surface.
+     * - Distances are in kilometers unless otherwise specified. Angles are in radians.
+     */
+    export class AtmospherePhysicalProperties {
+        /**
+         * Notification for when properties of the {@link AtmospherePhysicalProperties} are changed.
+         */
+        readonly onChangedObservable: BABYLON.Observable<AtmospherePhysicalProperties>;
+        private _planetRadius;
+        private _planetRadiusOffset;
+        private _atmosphereThickness;
+        private _rayleighScatteringScale;
+        private _peakRayleighScattering;
+        private _mieScatteringScale;
+        private _peakMieScattering;
+        private _mieAbsorptionScale;
+        private _peakMieAbsorption;
+        private _ozoneAbsorptionScale;
+        private _peakOzoneAbsorption;
+        private _planetRadiusWithOffset;
+        private _planetRadiusSquared;
+        private _atmosphereRadius;
+        private _atmosphereRadiusSquared;
+        private _horizonDistanceToAtmosphereEdge;
+        private _horizonDistanceToAtmosphereEdgeSquared;
+        private _rayleighScattering;
+        private _mieScattering;
+        private _mieAbsorption;
+        private _mieExtinction;
+        private _ozoneAbsorption;
+        /**
+         * The radius of the planet in kilometers.
+         */
+        get planetRadius(): number;
+        set planetRadius(value: number);
+        /**
+         * The squared radius of the planet in kilometers.
+         */
+        get planetRadiusSquared(): number;
+        /**
+         * Offset applied to view points near the planet's surface. This should be greater than 0.
+         * It prevents rendering issues close to the planet's surface.
+         */
+        get planetRadiusOffset(): number;
+        set planetRadiusOffset(value: number);
+        /**
+         * This is the {@link planetRadius} with the additional {@link planetRadiusOffset}, in kilometers.
+         */
+        get planetRadiusWithOffset(): number;
+        /**
+         * The thickness of the atmosphere measured in kilometers.
+         */
+        get atmosphereThickness(): number;
+        set atmosphereThickness(value: number);
+        /**
+         * The combined planet radius and atmosphere thickness in kilometers.
+         */
+        get atmosphereRadius(): number;
+        /**
+         * The atmosphere radius squared in kilometers.
+         */
+        get atmosphereRadiusSquared(): number;
+        /**
+         * Horizon distance from the planet's surface to the outer edge of the atmosphere in kilometers.
+         */
+        get horizonDistanceToAtmosphereEdge(): number;
+        /**
+         * Horizon distance from the planet's surface to the outer edge of the atmosphere, squared, in kilometers.
+         */
+        get horizonDistanceToAtmosphereEdgeSquared(): number;
+        /**
+         * The scale applied to {@link peakRayleighScattering}.
+         */
+        get rayleighScatteringScale(): number;
+        set rayleighScatteringScale(value: number);
+        /**
+         * The Rayleigh scattering per kilometer at sea level for red, green, and blue wavelengths.
+         */
+        get peakRayleighScattering(): BABYLON.Vector3;
+        set peakRayleighScattering(value: BABYLON.Vector3);
+        /**
+         * The Rayleigh scattering per kilometer at sea level for red, green, and blue wavelengths.
+         * This value cannot be set directly. It is inferred by scaling {@link peakRayleighScattering} by {@link rayleighScatteringScale}.
+         */
+        get rayleighScattering(): BABYLON.Vector3;
+        /**
+         * The scale applied to {@link peakMieScattering}.
+         */
+        get mieScatteringScale(): number;
+        set mieScatteringScale(value: number);
+        /**
+         * The Mie scattering per kilometer at sea level for red, green, and blue wavelengths.
+         */
+        get peakMieScattering(): BABYLON.Vector3;
+        set peakMieScattering(value: BABYLON.Vector3);
+        /**
+         * The Mie scattering per kilometer at sea level for red, green, and blue wavelengths.
+         * This value cannot be set directly. It is inferred by scaling {@link mieScatteringScale} by {@link peakMieScattering}.
+         */
+        get mieScattering(): BABYLON.Vector3;
+        /**
+         * The scale applied to {@link peakMieAbsorption}.
+         */
+        get mieAbsorptionScale(): number;
+        set mieAbsorptionScale(value: number);
+        /**
+         * The Mie absorption per kilometer at sea level for red, green, and blue wavelengths.
+         */
+        get peakMieAbsorption(): BABYLON.Vector3;
+        set peakMieAbsorption(value: BABYLON.Vector3);
+        /**
+         * The Mie absorption per kilometer at sea level for red, green, and blue wavelengths.
+         * This value cannot be set directly. It is inferred by scaling {@link mieAbsorptionScale} by {@link peakMieAbsorption}.
+         */
+        get mieAbsorption(): BABYLON.Vector3;
+        /**
+         * The Mie extinction per kilometer at sea level for red, green, and blue wavelengths.
+         * This value cannot be set directly. It is inferred by adding the {@link mieAbsorption} to the {@link mieScattering}.
+         */
+        get mieExtinction(): BABYLON.Vector3;
+        /**
+         * The scale applied to {@link peakOzoneAbsorption}.
+         */
+        get ozoneAbsorptionScale(): number;
+        set ozoneAbsorptionScale(value: number);
+        /**
+         * The ozone absorption per kilometer measured at a height corresponding to it's peak concentration,
+         * for red, green, and blue wavelengths.
+         */
+        get peakOzoneAbsorption(): BABYLON.Vector3;
+        set peakOzoneAbsorption(value: BABYLON.Vector3);
+        /**
+         * The ozone absorption per kilometer at sea level for red, green, and blue wavelengths.
+         * This value cannot be set directly. It is inferred by scaling {@link peakOzoneAbsorption} by {@link ozoneAbsorptionScale}.
+         */
+        get ozoneAbsorption(): BABYLON.Vector3;
+        /**
+         * Constructs the {@link AtmospherePhysicalProperties}.
+         * @param options - The options for the {@link AtmospherePhysicalProperties}.
+         */
+        constructor(options?: IAtmospherePhysicalPropertiesOptions);
+        private _recomputeDimensionalParameters;
+        private _recomputeRayleighScattering;
+        private _recomputeMieScattering;
+        private _recomputeMieAbsorption;
+        private _recomputeMieExtinction;
+        private _recomputeOzoneAbsorption;
+    }
+
+
+    /**
+     * Variables that are used to render the atmosphere and are computed per-camera.
+     */
+    export class AtmospherePerCameraVariables {
+        private _inverseViewProjectionMatrixWithoutTranslation;
+        private _directionToLightRelativeToCameraGeocentricNormal;
+        private _cosAngleLightToZenith;
+        private _cameraRadius;
+        private _clampedCameraRadius;
+        private _cameraHeight;
+        private _clampedCameraHeight;
+        private _cameraPositionGlobal;
+        private _clampedCameraPositionGlobal;
+        private _cosCameraHorizonAngleFromZenith;
+        private _sinCameraAtmosphereHorizonAngleFromNadir;
+        private _cameraGeocentricNormal;
+        private _cameraForward;
+        private _cameraNearPlane;
+        private _cameraPosition;
+        private _viewport;
+        private _lastViewMatrix;
+        private _lastProjectionMatrix;
+        private _inverseViewMatrixWithoutTranslation;
+        private _inverseProjectionMatrix;
+        /**
+         * The inverse view projection matrix is used to unproject rays.
+         * To avoid precision issues, the translation part of the matrix has been removed.
+         */
+        get inverseViewProjectionMatrixWithoutTranslation(): BABYLON.IMatrixLike;
+        /**
+         * The direction to the light relative to the geocentric normal under the camera.
+         */
+        get directionToLightRelativeToCameraGeocentricNormal(): BABYLON.IVector3Like;
+        /**
+         * The cosine of the angle between the light direction and zenith.
+         */
+        get cosAngleLightToZenith(): number;
+        /**
+         * The distance from the camera to the planet origin in kilometers.
+         */
+        get cameraRadius(): number;
+        /**
+         * The distance from the camera to the planet origin, clamped to the planet radius offset, in kilometers.
+         */
+        get clampedCameraRadius(): number;
+        /**
+         * The height of the camera above the planet surface in kilometers.
+         */
+        get cameraHeight(): number;
+        /**
+         * The height of the camera above the planet surface, clamped to the planet radius offset, in kilometers.
+         */
+        get clampedCameraHeight(): number;
+        /**
+         * The camera position in global space kilometers.
+         */
+        get cameraPositionGlobal(): BABYLON.IVector3Like;
+        /**
+         * The camera position, clamped to the planet radius offset, in global space kilometers.
+         */
+        get clampedCameraPositionGlobal(): BABYLON.IVector3Like;
+        /**
+         * The cosine of the angle from the zenith to the horizon of the planet, measured from the camera position.
+         */
+        get cosCameraHorizonAngleFromZenith(): number;
+        /**
+         * The sine of the angle from the nadir to the horizon of the atmosphere, measured from the camera position.
+         */
+        get sinCameraAtmosphereHorizonAngleFromNadir(): number;
+        /**
+         * The geocentric normal of the camera in global space i.e., the normalization of {@link cameraPositionGlobal}.
+         */
+        get cameraGeocentricNormal(): BABYLON.IVector3Like;
+        /**
+         * The camera's forward direction in world space.
+         */
+        get cameraForward(): BABYLON.IVector3Like;
+        /**
+         * The distance to the near plane of the camera.
+         */
+        get cameraNearPlane(): number;
+        /**
+         * The camera's position in world space.
+         */
+        get cameraPosition(): BABYLON.IVector3Like;
+        /**
+         * The viewport for the camera.
+         */
+        get viewport(): BABYLON.IVector4Like;
+        /**
+         * Updates the variables.
+         * @param camera - The camera to update the variables for.
+         * @param planetRadius - The radius of the planet in kilometers.
+         * @param planetRadiusWithOffset - The radius of the planet with the offset in kilometers.
+         * @param atmosphereRadius - The radius of the atmosphere in kilometers.
+         * @param directionToLight - The direction to the light in world space.
+         * @param originHeight - The height of the origin (distance from planet's surface) in kilometers.
+         */
+        update(camera: BABYLON.Camera, planetRadius: number, planetRadiusWithOffset: number, atmosphereRadius: number, directionToLight: BABYLON.IVector3Like, originHeight: number): void;
+    }
+
+
+    class AtmospherePBRMaterialDefines extends BABYLON.MaterialDefines {
+        USE_AERIAL_PERSPECTIVE_LUT: boolean;
+        APPLY_AERIAL_PERSPECTIVE_INTENSITY: boolean;
+        APPLY_AERIAL_PERSPECTIVE_RADIANCE_BIAS: boolean;
+        /**
+         * Constructs the {@link AtmospherePBRMaterialDefines}.
+         * @param useAerialPerspectiveLut - Whether to use the aerial perspective LUT.
+         */
+        constructor(useAerialPerspectiveLut: boolean);
+    }
+    /**
+     * Adds shading logic to a PBRMaterial that provides radiance, diffuse sky irradiance, and aerial perspective from the atmosphere.
+     */
+    export class AtmospherePBRMaterialPlugin extends BABYLON.MaterialPluginBase {
+        private readonly _atmosphere;
+        private readonly _isAerialPerspectiveEnabled;
+        /**
+         * Constructs the {@link AtmospherePBRMaterialPlugin}.
+         * @param material - The material to apply the plugin to.
+         * @param _atmosphere - The atmosphere to use for shading.
+         * @param _isAerialPerspectiveEnabled - Whether to apply aerial perspective.
+         */
+        constructor(material: BABYLON.Material, _atmosphere: Atmosphere, _isAerialPerspectiveEnabled?: boolean);
+        /**
+         * @override
+         */
+        getUniformBuffersNames(_ubos: string[]): void;
+        /**
+         * @override
+         */
+        getUniforms(): {
+            ubo: {
+                name: string;
+                size: number;
+                type: string;
+            }[];
+            fragment: string;
+            externalUniforms: string[];
+        };
+        /**
+         * @override
+         */
+        isReadyForSubMesh(): boolean;
+        /**
+         * @override
+         */
+        getActiveTextures(_activeTextures: BABYLON.BaseTexture[]): void;
+        /**
+         * @override
+         */
+        bindForSubMesh(uniformBuffer: BABYLON.UniformBuffer): void;
+        /**
+         * @override
+         */
+        prepareDefines(defines: AtmospherePBRMaterialDefines): void;
+        /**
+         * @override
+         */
+        getSamplers(samplers: string[]): void;
+        /**
+         * @override
+         */
+        getCustomCode(shaderType: string): BABYLON.Nullable<Record<string, string>>;
+    }
+
+
+    /**
+     * Creation options for the {@link Atmosphere}.
+     */
+    export interface IAtmosphereOptions {
+        /**
+         * The properties that define the atmosphere's composition and size.
+         */
+        physicalProperties?: AtmospherePhysicalProperties;
+        /**
+         * An optional depth texture that will be used by the fullscreen passes that render the sky, aerial perspective, or globe atmosphere.
+         * This enables deferred rendering scenarios, where atmospheric effects need to be composited onto geometry buffers.
+         * Expects infinite far plane on the camera (camera.maxZ = 0) and a non-linear depth to be stored in the red channel.
+         */
+        depthTexture?: BABYLON.BaseTexture;
+        /**
+         * Controls the overall brightness of the atmosphere rendering.
+         * A value of 1.0 is physically correct.
+         */
+        exposure?: number;
+        /**
+         * Whether the light values should be specified in linear space.
+         * Set to true when using PBRMaterials, which expect linear light values.
+         */
+        isLinearSpaceLight?: boolean;
+        /**
+         * Whether the composition of the sky should be in linear space.
+         * Set to true for HDR rendering or when using image post-processes.
+         */
+        isLinearSpaceComposition?: boolean;
+        /**
+         * Whether to apply approximate transmittance to dim surfaces behind the atmosphere.
+         * When true, distant surfaces are dimmed using a grayscale approximation of transmittance.
+         */
+        applyApproximateTransmittance?: boolean;
+        /**
+         * Whether to use the sky view LUT for compositing the sky.
+         * When false, full ray marching is required (slower).
+         */
+        isSkyViewLutEnabled?: boolean;
+        /**
+         * Whether to use the aerial perspective LUT.
+         * When false, full ray marching is required for aerial perspective (slower).
+         */
+        isAerialPerspectiveLutEnabled?: boolean;
+        /**
+         * Radiance bias applied to the aerial perspective.
+         * Positive values brighten the aerial perspective, negative values darken it.
+         * The default is 0 (no change).
+         */
+        aerialPerspectiveRadianceBias?: number;
+        /**
+         * Scale factor for the amount of light transmitted into aerial perspective from the light source.
+         * The default is 1 (no scaling).
+         */
+        aerialPerspectiveTransmittanceScale?: number;
+        /**
+         * Amount of saturation applied to the aerial perspective.
+         * Lower values make the aerial perspective more gray.
+         * The default is 1 (no saturation change).
+         */
+        aerialPerspectiveSaturation?: number;
+        /**
+         * Overall intensity multiplier for the aerial perspective effect.
+         * Higher values increase haziness.
+         * The default is 1 (no intensity change).
+         */
+        aerialPerspectiveIntensity?: number;
+        /**
+         * Whether to use the diffuse sky irradiance LUT.
+         */
+        isDiffuseSkyIrradianceLutEnabled?: boolean;
+        /**
+         * Higher values result in more desaturated diffuse irradiance.
+         * The default is 0 (no desaturation).
+         */
+        diffuseSkyIrradianceDesaturationFactor?: number;
+        /**
+         * Overall intensity multiplier for the diffuse irradiance.
+         * The default is 1 (no intensity change).
+         */
+        diffuseSkyIrradianceIntensity?: number;
+        /**
+         * Controls the intensity of the additional diffuse irradiance amount.
+         */
+        additionalDiffuseSkyIrradianceIntensity?: number;
+        /**
+         * Controls the color of the additional diffuse irradiance amount.
+         */
+        additionalDiffuseSkyIrradianceColor?: BABYLON.IColor3Like;
+        /**
+         * Higher values increase the contribution of multiple scattering to the overall atmosphere.
+         * Default is 1 (no intensity change).
+         */
+        multiScatteringIntensity?: number;
+        /**
+         * Average color of light reflected off the ground.
+         * Affects the multiply scattered light contribution in the atmosphere.
+         */
+        groundAlbedo?: BABYLON.IColor3Like;
+        /**
+         * Minimum color for multiple scattering.
+         * Useful for creating a quick, but not physically accurate, night sky.
+         */
+        minimumMultiScatteringColor?: BABYLON.IColor3Like;
+        /**
+         * Controls the intensity of the {@link minimumMultiScatteringColor}.
+         * Useful for creating a quick, but not physically accurate, night sky.
+         */
+        minimumMultiScatteringIntensity?: number;
+        /**
+         * Height in kilometers of the scene's origin relative to the planet surface.
+         */
+        originHeight?: number;
+        /**
+         * The rendering group ID for the sky compositor.
+         * When specified, the sky will only be rendered for this group.
+         * If not specified, defaults to group 0.
+         */
+        skyRenderingGroup?: number;
+        /**
+         * The rendering group ID for the aerial perspective compositor.
+         * When specified, aerial perspective will only be rendered for this group.
+         * If not specified, defaults to group 0.
+         */
+        aerialPerspectiveRenderingGroup?: number;
+        /**
+         * The rendering group ID for the globe atmosphere compositor.
+         * When specified, the globe atmosphere will only be rendered for this group.
+         * If not specified, defaults to group 0.
+         */
+        globeAtmosphereRenderingGroup?: number;
+    }
+
+
+    /**
+     * Renders a physically based atmosphere.
+     * Use {@link IsSupported} to check if the atmosphere is supported before creating an instance.
+     * @experimental
+     */
+    export class Atmosphere implements BABYLON.IDisposable {
+        readonly name: string;
+        readonly scene: BABYLON.Scene;
+        private readonly _directionToLight;
+        private readonly _tempSceneAmbient;
+        private readonly _engine;
+        private _physicalProperties;
+        private _transmittanceLut;
+        private _diffuseSkyIrradianceLut;
+        private _isSkyViewLutEnabled;
+        private _isAerialPerspectiveLutEnabled;
+        private _aerialPerspectiveTransmittanceScale;
+        private _aerialPerspectiveSaturation;
+        private _aerialPerspectiveIntensity;
+        private _aerialPerspectiveRadianceBias;
+        private _diffuseSkyIrradianceDesaturationFactor;
+        private _additionalDiffuseSkyIrradianceIntensity;
+        private _additionalDiffuseSkyIrradianceColor;
+        private _additionalDiffuseSkyIrradiance;
+        private _diffuseSkyIrradianceIntensity;
+        private _multiScatteringIntensity;
+        private _groundAlbedo;
+        private _minimumMultiScatteringColor;
+        private _minimumMultiScatteringIntensity;
+        private _lights;
+        private _atmosphereUbo;
+        private _minimumMultiScattering;
+        private _cameraAtmosphereVariables;
+        private _isLinearSpaceComposition;
+        private _isLinearSpaceLight;
+        private _lightRadianceAtCamera;
+        private _linearLightColor;
+        private _originHeight;
+        private _applyApproximateTransmittance;
+        private _exposure;
+        private _atmosphereUniformBufferAsArray;
+        private _effectRenderer;
+        private _skyRenderingGroup;
+        private _aerialPerspectiveRenderingGroup;
+        private _globeAtmosphereRenderingGroup;
+        private _isEnabled;
+        private _hasRenderedMultiScatteringLut;
+        private _multiScatteringEffectWrapper;
+        private _multiScatteringLutRenderTarget;
+        private _aerialPerspectiveLutEffectWrapper;
+        private _aerialPerspectiveLutEffectRenderer;
+        private _aerialPerspectiveLutRenderTarget;
+        private _skyViewLutEffectWrapper;
+        private _skyViewLutEffectRenderer;
+        private _skyViewLutRenderTarget;
+        private _aerialPerspectiveCompositorEffectWrapper;
+        private _skyCompositorEffectWrapper;
+        private _globeAtmosphereCompositorEffectWrapper;
+        private _onBeforeCameraRenderObserver;
+        private _onBeforeDrawPhaseObserver;
+        private _onAfterRenderingGroupObserver;
+        /**
+         * Checks if the {@link Atmosphere} is supported.
+         * @param engine - The engine to check.
+         * @returns True if the atmosphere is supported, false otherwise.
+         */
+        static IsSupported(engine: BABYLON.AbstractEngine): boolean;
+        /**
+         * Called after the atmosphere variables have been updated for the specified camera.
+         */
+        readonly onAfterUpdateVariablesForCameraObservable: BABYLON.Observable<BABYLON.Camera>;
+        /**
+         * Called immediately before the light variables are finalized.
+         */
+        readonly onBeforeLightVariablesUpdateObservable: BABYLON.Observable<void>;
+        /**
+         * Called before the LUTs are rendered for this camera. This happens after the per-camera UBO update.
+         */
+        readonly onBeforeRenderLutsForCameraObservable: BABYLON.Observable<void>;
+        /**
+         * Called after the LUTs were rendered.
+         */
+        readonly onAfterRenderLutsForCameraObservable: BABYLON.Observable<void>;
+        /**
+         * If provided, this is the depth texture used for composition passes.
+         * Expects an infinite far plane on the camera (camera.maxZ = 0) and the non-linear depth accessible in red channel.
+         * @internal
+         */
+        readonly depthTexture: BABYLON.Nullable<BABYLON.BaseTexture>;
+        /**
+         * Controls the overall brightness of the atmosphere rendering.
+         */
+        get exposure(): number;
+        set exposure(value: number);
+        /**
+         * Affects the overall intensity of the multiple scattering.
+         */
+        get multiScatteringIntensity(): number;
+        set multiScatteringIntensity(value: number);
+        /**
+         * Affects the multiply scattered light contribution in the atmosphere by describing the average light color reflected off the ground.
+         */
+        get groundAlbedo(): BABYLON.DeepImmutable<BABYLON.IColor3Like>;
+        set groundAlbedo(value: BABYLON.DeepImmutable<BABYLON.IColor3Like>);
+        /**
+         * Can be used to clamp the multiple scattering to a minimum value.
+         */
+        get minimumMultiScatteringColor(): BABYLON.DeepImmutable<BABYLON.IColor3Like>;
+        set minimumMultiScatteringColor(value: BABYLON.DeepImmutable<BABYLON.IColor3Like>);
+        /**
+         * This is an additional scaling factor applied to the {@link minimumMultiScatteringColor}.
+         */
+        get minimumMultiScatteringIntensity(): number;
+        set minimumMultiScatteringIntensity(value: number);
+        /**
+         * Can be used to force the diffuse irradiance towards a gray color.
+         */
+        get diffuseSkyIrradianceDesaturationFactor(): number;
+        set diffuseSkyIrradianceDesaturationFactor(value: number);
+        /**
+         * This is an additional amount of irradiance added to the diffuse irradiance.
+         */
+        get additionalDiffuseSkyIrradianceIntensity(): number;
+        set additionalDiffuseSkyIrradianceIntensity(value: number);
+        /**
+         * This is the color for the additional amount of irradiance added to the diffuse irradiance.
+         */
+        get additionalDiffuseSkyIrradianceColor(): BABYLON.DeepImmutable<BABYLON.IColor3Like>;
+        set additionalDiffuseSkyIrradianceColor(value: BABYLON.DeepImmutable<BABYLON.IColor3Like>);
+        /**
+         * The final additional diffuse irradiance, taking into account the intensity and color.
+         */
+        get additionalDiffuseSkyIrradiance(): BABYLON.DeepImmutable<BABYLON.IColor3Like>;
+        /**
+         * The intensity of the diffuse irradiance.
+         */
+        get diffuseSkyIrradianceIntensity(): number;
+        set diffuseSkyIrradianceIntensity(value: number);
+        /**
+         * True if the sky view LUT should be used for compositing the sky instead of a per-pixel ray march.
+         */
+        get isSkyViewLutEnabled(): boolean;
+        set isSkyViewLutEnabled(value: boolean);
+        /**
+         * Gets the sky view LUT render target or null if not enabled.
+         * @returns The render target.
+         */
+        get skyViewLutRenderTarget(): BABYLON.Nullable<BABYLON.RenderTargetTexture>;
+        /**
+         * True if the aerial perspective LUT should be used.
+         * If false, full ray marching would be used instead.
+         */
+        get isAerialPerspectiveLutEnabled(): boolean;
+        set isAerialPerspectiveLutEnabled(value: boolean);
+        /**
+         * Gets the aerial perspective LUT render target or null if not enabled.
+         * @returns The render target.
+         */
+        get aerialPerspectiveLutRenderTarget(): BABYLON.Nullable<BABYLON.RenderTargetTexture>;
+        /**
+         * The intensity of the aerial perspective.
+         */
+        get aerialPerspectiveIntensity(): number;
+        set aerialPerspectiveIntensity(value: number);
+        /**
+         * The amount of light transmitted into aerial perspective.
+         * A scale of 1 is physically correct.
+         */
+        get aerialPerspectiveTransmittanceScale(): number;
+        set aerialPerspectiveTransmittanceScale(value: number);
+        /**
+         * The amount of saturation applied to the aerial perspective.
+         * Reducing to zero desaturates the aerial perspective completely.
+         * A value of 1 has no effect.
+         */
+        get aerialPerspectiveSaturation(): number;
+        set aerialPerspectiveSaturation(value: number);
+        /**
+         * A radiance bias applied to aerial perspective.
+         */
+        get aerialPerspectiveRadianceBias(): number;
+        set aerialPerspectiveRadianceBias(value: number);
+        /**
+         * True if the composition should be in linear space (e.g. for HDR rendering).
+         * Typically linear space is expected when ImageProcessing is enabled via PostProcesses.
+         * False for non-linear output.
+         */
+        get isLinearSpaceComposition(): boolean;
+        set isLinearSpaceComposition(value: boolean);
+        /**
+         * True if the {@link light} value should be specified in linear space.
+         * If using PBRMaterials, light value is expected to be linear.
+         */
+        get isLinearSpaceLight(): boolean;
+        set isLinearSpaceLight(value: boolean);
+        /**
+         * The lookup table for transmittance.
+         */
+        get transmittanceLut(): BABYLON.Nullable<TransmittanceLut>;
+        /**
+         * Gets the multiple scattering LUT render target.
+         * @returns The render target.
+         */
+        get multiScatteringLutRenderTarget(): BABYLON.Nullable<BABYLON.RenderTargetTexture>;
+        /**
+         * The lookup table for diffuse sky irradiance, or null if not enabled.
+         */
+        get diffuseSkyIrradianceLut(): BABYLON.Nullable<DiffuseSkyIrradianceLut>;
+        /**
+         * The properties used to describe the size and optical parameters of the atmosphere.
+         */
+        get physicalProperties(): AtmospherePhysicalProperties;
+        /**
+         * The height in kilometers of the scene's origin.
+         */
+        get originHeight(): number;
+        set originHeight(value: number);
+        /**
+         * When atmospheric scattering is applied to surfaces, if this value is set to true,
+         * a grayscale approximation of the transmittance is used to dim surfaces.
+         *
+         * When set to false, the atmospheric composition does not dim the surfaces behind it.
+         * It is up to the client application to apply transmittance manually.
+         */
+        get applyApproximateTransmittance(): boolean;
+        set applyApproximateTransmittance(value: boolean);
+        /**
+         * The directional lights in the scene which represent the suns illuminating the atmosphere.
+         * Each frame, the color and intensity of the lights are updated based on the camera position and the light's direction.
+         */
+        get lights(): ReadonlyArray<BABYLON.DirectionalLight>;
+        /**
+         * The rendering group ID for the sky compositor.
+         * The sky will only be rendered for this group.
+         */
+        get skyRenderingGroup(): number;
+        set skyRenderingGroup(value: number);
+        /**
+         * The rendering group ID for the aerial perspective compositor.
+         * Aerial perspective will only be rendered for this group.
+         */
+        get aerialPerspectiveRenderingGroup(): number;
+        set aerialPerspectiveRenderingGroup(value: number);
+        /**
+         * The rendering group ID for the globe atmosphere compositor.
+         * The globe atmosphere will only be rendered for this group.
+         */
+        get globeAtmosphereRenderingGroup(): number;
+        set globeAtmosphereRenderingGroup(value: number);
+        /**
+         * Gets the uniform buffer used to store the atmosphere's physical properties.
+         */
+        get uniformBuffer(): BABYLON.UniformBuffer;
+        /**
+         * Gets the camera-related variables for this atmosphere. Updated each frame.
+         */
+        get cameraAtmosphereVariables(): AtmospherePerCameraVariables;
+        private _peakRayleighScatteringMmInternal;
+        private _peakRayleighScatteringKm;
+        private _peakMieScatteringMmInternal;
+        private _peakMieScatteringKm;
+        private _peakMieAbsorptionMmInternal;
+        private _peakMieAbsorptionKm;
+        private _peakOzoneAbsorptionMmInternal;
+        private _peakOzoneAbsorptionKm;
+        private get _planetRadius();
+        private set _planetRadius(value);
+        private get _planetRadiusOffset();
+        private set _planetRadiusOffset(value);
+        private get _atmosphereThickness();
+        private set _atmosphereThickness(value);
+        private get _rayleighScatteringScale();
+        private set _rayleighScatteringScale(value);
+        private get _peakRayleighScatteringMm();
+        private set _peakRayleighScatteringMm(value);
+        private get _mieScatteringScale();
+        private set _mieScatteringScale(value);
+        private get _peakMieScatteringMm();
+        private set _peakMieScatteringMm(value);
+        private get _mieAbsorptionScale();
+        private set _mieAbsorptionScale(value);
+        private get _peakMieAbsorptionMm();
+        private set _peakMieAbsorptionMm(value);
+        private get _ozoneAbsorptionScale();
+        private set _ozoneAbsorptionScale(value);
+        private get _peakOzoneAbsorptionMm();
+        private set _peakOzoneAbsorptionMm(value);
+        /**
+         * Constructs the {@link Atmosphere}.
+         * @param name - The name of this instance.
+         * @param scene - The scene to which the atmosphere will be added.
+         * @param lights - The light sources that illuminate the atmosphere. Currently only supports one light, and that light should be the first light in the scene.
+         * @param options - The options used to create the atmosphere.
+         */
+        constructor(name: string, scene: BABYLON.Scene, lights: BABYLON.DirectionalLight[], options?: IAtmosphereOptions);
+        /**
+         * @override
+         */
+        dispose(): void;
+        /**
+         * True if the atmosphere is enabled.
+         * @returns - True if the atmosphere is enabled.
+         */
+        isEnabled(): boolean;
+        /**
+         * Sets the enabled state of the atmosphere.
+         * @param enabled - True to enable the atmosphere, false to disable it.
+         */
+        setEnabled(enabled: boolean): void;
+        /**
+         * The class name of the {@link Atmosphere}.
+         * @returns - The class name of the atmosphere.
+         */
+        getClassName(): string;
+        /**
+         * Gets the color of a light after being transmitted through the atmosphere to a point specified by its distance to the planet center and its geocentric normal.
+         * NOTE, the result is always a linear space color.
+         * @param directionToLight - The direction of the light.
+         * @param pointRadius - The distance from the planet center to the point in kilometers.
+         * @param pointGeocentricNormal - The geocentric normal at the point i.e., normalize(point - planet center).
+         * @param result - The color to store the result in.
+         * @returns The result color.
+         */
+        getTransmittedColorToRef: <T extends BABYLON.IColor3Like>(directionToLight: BABYLON.IVector3Like, pointRadius: number, pointGeocentricNormal: BABYLON.IVector3Like, result: T) => T;
+        /**
+         * Gets the diffuse sky irradiance. Result is always in linear space.
+         * @param directionToLight - The direction of the point to the light.
+         * @param pointRadius - The distance from the planet center to the point in kilometers.
+         * @param pointGeocentricNormal - The geocentric normal at the point: normalize(point - planet center).
+         * @param lightIrradiance - The irradiance of the light.
+         * @param result - The color to store the result in.
+         * @returns The result color.
+         */
+        getDiffuseSkyIrradianceToRef: <T extends BABYLON.IColor3Like>(directionToLight: BABYLON.IVector3Like, pointRadius: number, pointGeocentricNormal: BABYLON.IVector3Like, lightIrradiance: number, result: T) => T;
+        /**
+         * Creates a new {@link EffectWrapper} for the multiple scattering LUT
+         * @returns The newly created {@link EffectWrapper}.
+         */
+        private _createMultiScatteringEffectWrapper;
+        /**
+         * Draws the multiple scattering LUT using {@link EffectWrapper} and {@link EffectRenderer}.
+         */
+        private _drawMultiScatteringLut;
+        /**
+         * Draws the aerial perspective compositor using {@link EffectWrapper} and {@link EffectRenderer}.
+         */
+        private _drawAerialPerspectiveCompositor;
+        /**
+         * Draws the sky compositor using {@link EffectWrapper} and {@link EffectRenderer}.
+         */
+        private _drawSkyCompositor;
+        /**
+         * Draws the globe atmosphere compositor using {@link EffectWrapper} and {@link EffectRenderer}.
+         */
+        private _drawGlobeAtmosphereCompositor;
+        private _disposeSkyCompositor;
+        private _disposeAerialPerspectiveCompositor;
+        private _disposeGlobeAtmosphereCompositor;
+        /**
+         * Updates the camera variables that are specific to the atmosphere.
+         * @param camera - The camera to update the variables for.
+         */
+        private _updatePerCameraVariables;
+        /**
+         * Renders the lookup tables, some of which can vary per-camera.
+         * It is expected that updatePerCameraVariables was previously called.
+         */
+        private _renderLutsForCamera;
+        /**
+         * Renders the lookup tables that do not depend on a camera position.
+         */
+        renderGlobalLuts(): void;
+        /**
+         * Binds the atmosphere's uniform buffer to an {@link BABYLON.Effect}.
+         * @param effect - The {@link BABYLON.Effect} to bind the uniform buffer to.
+         */
+        bindUniformBufferToEffect(effect: BABYLON.Effect): void;
+        /**
+         * Updates the atmosphere's uniform buffer.
+         */
+        private _updateUniformBuffer;
+        /**
+         * Draws the aerial perspective LUT using {@link EffectWrapper} and {@link EffectRenderer}.
+         */
+        private _drawAerialPerspectiveLut;
+        /**
+         * Draws the sky view LUT using {@link EffectWrapper} and {@link EffectRenderer}.
+         */
+        private _drawSkyViewLut;
+    }
+
+
+    /** @internal */
+    export var transmittancePixelShader: {
+        name: string;
+        shader: string;
+    };
+
+
+    /** @internal */
+    export var skyViewPixelShader: {
+        name: string;
+        shader: string;
+    };
+
+
+    /** @internal */
+    export var multiScatteringPixelShader: {
+        name: string;
+        shader: string;
+    };
+
+
+    /** @internal */
+    export var fullscreenTriangleVertexShader: {
+        name: string;
+        shader: string;
+    };
+
+
+    /** @internal */
+    export var diffuseSkyIrradiancePixelShader: {
+        name: string;
+        shader: string;
+    };
+
+
+    /** @internal */
+    export var compositeSkyPixelShader: {
+        name: string;
+        shader: string;
+    };
+
+
+    /** @internal */
+    export var compositeGlobeAtmospherePixelShader: {
+        name: string;
+        shader: string;
+    };
+
+
+    /** @internal */
+    export var compositeAerialPerspectivePixelShader: {
+        name: string;
+        shader: string;
+    };
+
+
+    /** @internal */
+    export var aerialPerspectivePixelShader: {
+        name: string;
+        shader: string;
+    };
+
+
+    /** @internal */
+    export var depthFunctions: {
+        name: string;
+        shader: string;
+    };
+
+
+    /** @internal */
+    export var atmosphereVertexDeclaration: {
+        name: string;
+        shader: string;
+    };
+
+
+    /** @internal */
+    export var atmosphereUboDeclaration: {
+        name: string;
+        shader: string;
+    };
+
+
+    /** @internal */
+    export var atmosphereFunctions: {
+        name: string;
+        shader: string;
+    };
+
+
+    /** @internal */
+    export var atmosphereFragmentDeclaration: {
+        name: string;
+        shader: string;
+    };
+
+
 
 }