babylonjs-addons 8.26.1 → 8.27.0

package/babylonjs.addons.module.d.ts

@@ -1,5 +1,6 @@
 
 declare module "babylonjs-addons/index" {
+export * from "babylonjs-addons/atmosphere/index";
 export * from "babylonjs-addons/htmlMesh/index";
 export * from "babylonjs-addons/msdfText/index";
 
@@ -136,7 +137,7 @@ export class TextRenderer implements IDisposable {
 
 }
 declare module "babylonjs-addons/msdfText/paragraphOptions" {
-import { IVector2Like } from "babylonjs/Maths";
+import { IVector2Like } from "babylonjs/Maths/math.like";
 /** @internal */
 export type ParagraphOptions = {
     maxWidth: number;
@@ -752,693 +753,3101 @@ export const FitStrategy: {
 };
 
 }
+declare module "babylonjs-addons/atmosphere/transmittanceLut" {
+import { Atmosphere } from "babylonjs-addons/atmosphere/atmosphere";
+import { DirectionalLight } from "babylonjs/Lights/directionalLight";
+import { IColor3Like, IVector3Like } from "babylonjs/Maths/math.like";
+import { Observable } from "babylonjs/Misc/observable";
+import { RenderTargetTexture } from "babylonjs/Materials/Textures/renderTargetTexture";
+import "babylonjs-addons/atmosphere/Shaders/fullscreenTriangle.vertex";
+import "babylonjs-addons/atmosphere/Shaders/transmittance.fragment";
+/**
+ * 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: 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(): 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 IColor3Like>(directionToLight: IVector3Like, pointRadius: number, pointGeocentricNormal: 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: DirectionalLight, pointRadius: number, pointGeocentricNormal: 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;
+}
+
+}
+declare module "babylonjs-addons/atmosphere/sampling" {
+import { IColor4Like } from "babylonjs/Maths/math.like";
+/**
+ * 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 IColor4Like>(u: number, v: number, widthPx: number, heightPx: number, data: Uint8Array | Uint16Array | Float32Array, result: T, normalizeFunc?: (value: number) => number) => T;
+
+}
+declare module "babylonjs-addons/atmosphere/index" {
+export * from "babylonjs-addons/atmosphere/atmosphere";
+export * from "babylonjs-addons/atmosphere/atmosphereOptions";
+export * from "babylonjs-addons/atmosphere/atmospherePhysicalProperties";
+export * from "babylonjs-addons/atmosphere/atmospherePhysicalPropertiesOptions";
+export * from "babylonjs-addons/atmosphere/diffuseSkyIrradianceLut";
+export * from "babylonjs-addons/atmosphere/transmittanceLut";
+
+}
+declare module "babylonjs-addons/atmosphere/diffuseSkyIrradianceLut" {
+import { Atmosphere } from "babylonjs-addons/atmosphere/atmosphere";
+import { IColor3Like, IVector3Like } from "babylonjs/Maths/math.like";
+import { RenderTargetTexture } from "babylonjs/Materials/Textures/renderTargetTexture";
+import "babylonjs-addons/atmosphere/Shaders/diffuseSkyIrradiance.fragment";
+import "babylonjs-addons/atmosphere/Shaders/fullscreenTriangle.vertex";
+/**
+ * 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(): 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 IColor3Like>(directionToLight: IVector3Like, radius: number, cameraGeocentricNormal: 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;
+}
+
+}
+declare module "babylonjs-addons/atmosphere/atmospherePhysicalPropertiesOptions" {
+import { Vector3 } from "babylonjs/Maths/math.vector";
+/**
+ * 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?: 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?: 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?: 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?: Vector3;
+}
+
+}
+declare module "babylonjs-addons/atmosphere/atmospherePhysicalProperties" {
+import { IAtmospherePhysicalPropertiesOptions } from "babylonjs-addons/atmosphere/atmospherePhysicalPropertiesOptions";
+import { Observable } from "babylonjs/Misc/observable";
+import { Vector3 } from "babylonjs/Maths/math.vector";
+/**
+ * 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: 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(): Vector3;
+    set peakRayleighScattering(value: 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(): 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(): Vector3;
+    set peakMieScattering(value: 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(): 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(): Vector3;
+    set peakMieAbsorption(value: 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(): 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(): 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(): Vector3;
+    set peakOzoneAbsorption(value: 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(): 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;
+}
+
+}
+declare module "babylonjs-addons/atmosphere/atmospherePerCameraVariables" {
+import { Camera } from "babylonjs/Cameras/camera";
+import { IMatrixLike, IVector3Like, IVector4Like } from "babylonjs/Maths/math.like";
+/**
+ * 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(): IMatrixLike;
+    /**
+     * The direction to the light relative to the geocentric normal under the camera.
+     */
+    get directionToLightRelativeToCameraGeocentricNormal(): 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(): IVector3Like;
+    /**
+     * The camera position, clamped to the planet radius offset, in global space kilometers.
+     */
+    get clampedCameraPositionGlobal(): 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(): IVector3Like;
+    /**
+     * The camera's forward direction in world space.
+     */
+    get cameraForward(): IVector3Like;
+    /**
+     * The distance to the near plane of the camera.
+     */
+    get cameraNearPlane(): number;
+    /**
+     * The camera's position in world space.
+     */
+    get cameraPosition(): IVector3Like;
+    /**
+     * The viewport for the camera.
+     */
+    get viewport(): 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: Camera, planetRadius: number, planetRadiusWithOffset: number, atmosphereRadius: number, directionToLight: IVector3Like, originHeight: number): void;
+}
+
+}
+declare module "babylonjs-addons/atmosphere/atmospherePBRMaterialPlugin" {
+import { Atmosphere } from "babylonjs-addons/atmosphere/atmosphere";
+import { BaseTexture } from "babylonjs/Materials/Textures/baseTexture";
+import { Material } from "babylonjs/Materials/material";
+import { MaterialDefines } from "babylonjs/Materials/materialDefines";
+import { MaterialPluginBase } from "babylonjs/Materials/materialPluginBase";
+import { Nullable } from "babylonjs/types";
+import { UniformBuffer } from "babylonjs/Materials/uniformBuffer";
+class AtmospherePBRMaterialDefines extends 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 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: 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: BaseTexture[]): void;
+    /**
+     * @override
+     */
+    bindForSubMesh(uniformBuffer: UniformBuffer): void;
+    /**
+     * @override
+     */
+    prepareDefines(defines: AtmospherePBRMaterialDefines): void;
+    /**
+     * @override
+     */
+    getSamplers(samplers: string[]): void;
+    /**
+     * @override
+     */
+    getCustomCode(shaderType: string): Nullable<Record<string, string>>;
+}
+export {};
+
+}
+declare module "babylonjs-addons/atmosphere/atmosphereOptions" {
+import { AtmospherePhysicalProperties } from "babylonjs-addons/atmosphere/atmospherePhysicalProperties";
+import { BaseTexture } from "babylonjs/Materials/Textures/baseTexture";
+import { IColor3Like } from "babylonjs/Maths/math.like";
+/**
+ * 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?: 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?: 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?: IColor3Like;
+    /**
+     * Minimum color for multiple scattering.
+     * Useful for creating a quick, but not physically accurate, night sky.
+     */
+    minimumMultiScatteringColor?: 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;
+}
+
+}
+declare module "babylonjs-addons/atmosphere/atmosphere" {
+import { AbstractEngine } from "babylonjs/Engines/abstractEngine";
+import { AtmospherePerCameraVariables } from "babylonjs-addons/atmosphere/atmospherePerCameraVariables";
+import { AtmospherePhysicalProperties } from "babylonjs-addons/atmosphere/atmospherePhysicalProperties";
+import { BaseTexture } from "babylonjs/Materials/Textures/baseTexture";
+import { Camera } from "babylonjs/Cameras/camera";
+import { DeepImmutable, Nullable } from "babylonjs/types";
+import { DiffuseSkyIrradianceLut } from "babylonjs-addons/atmosphere/diffuseSkyIrradianceLut";
+import { DirectionalLight } from "babylonjs/Lights/directionalLight";
+import { Effect } from "babylonjs/Materials/effect";
+import { IAtmosphereOptions } from "babylonjs-addons/atmosphere/atmosphereOptions";
+import { IColor3Like, IVector3Like } from "babylonjs/Maths/math.like";
+import { IDisposable, Scene } from "babylonjs/scene";
+import { Observable } from "babylonjs/Misc/observable";
+import { RenderTargetTexture } from "babylonjs/Materials/Textures/renderTargetTexture";
+import { TransmittanceLut } from "babylonjs-addons/atmosphere/transmittanceLut";
+import { UniformBuffer } from "babylonjs/Materials/uniformBuffer";
+import "babylonjs-addons/atmosphere/Shaders/compositeAerialPerspective.fragment";
+import "babylonjs-addons/atmosphere/Shaders/compositeSky.fragment";
+import "babylonjs-addons/atmosphere/Shaders/compositeGlobeAtmosphere.fragment";
+import "babylonjs-addons/atmosphere/Shaders/fullscreenTriangle.vertex";
+import "babylonjs-addons/atmosphere/Shaders/multiScattering.fragment";
+import "babylonjs-addons/atmosphere/Shaders/skyView.fragment";
+import "babylonjs-addons/atmosphere/Shaders/aerialPerspective.fragment";
+import "babylonjs-addons/atmosphere/Shaders/ShadersInclude/atmosphereFragmentDeclaration";
+import "babylonjs-addons/atmosphere/Shaders/ShadersInclude/atmosphereFunctions";
+import "babylonjs-addons/atmosphere/Shaders/ShadersInclude/atmosphereUboDeclaration";
+import "babylonjs-addons/atmosphere/Shaders/ShadersInclude/atmosphereVertexDeclaration";
+import "babylonjs-addons/atmosphere/Shaders/ShadersInclude/depthFunctions";
+/**
+ * Renders a physically based atmosphere.
+ * Use {@link IsSupported} to check if the atmosphere is supported before creating an instance.
+ * @experimental
+ */
+export class Atmosphere implements IDisposable {
+    readonly name: string;
+    readonly scene: 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: AbstractEngine): boolean;
+    /**
+     * Called after the atmosphere variables have been updated for the specified camera.
+     */
+    readonly onAfterUpdateVariablesForCameraObservable: Observable<Camera>;
+    /**
+     * Called immediately before the light variables are finalized.
+     */
+    readonly onBeforeLightVariablesUpdateObservable: Observable<void>;
+    /**
+     * Called before the LUTs are rendered for this camera. This happens after the per-camera UBO update.
+     */
+    readonly onBeforeRenderLutsForCameraObservable: Observable<void>;
+    /**
+     * Called after the LUTs were rendered.
+     */
+    readonly onAfterRenderLutsForCameraObservable: 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: Nullable<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(): DeepImmutable<IColor3Like>;
+    set groundAlbedo(value: DeepImmutable<IColor3Like>);
+    /**
+     * Can be used to clamp the multiple scattering to a minimum value.
+     */
+    get minimumMultiScatteringColor(): DeepImmutable<IColor3Like>;
+    set minimumMultiScatteringColor(value: DeepImmutable<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(): DeepImmutable<IColor3Like>;
+    set additionalDiffuseSkyIrradianceColor(value: DeepImmutable<IColor3Like>);
+    /**
+     * The final additional diffuse irradiance, taking into account the intensity and color.
+     */
+    get additionalDiffuseSkyIrradiance(): DeepImmutable<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(): Nullable<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(): Nullable<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(): Nullable<TransmittanceLut>;
+    /**
+     * Gets the multiple scattering LUT render target.
+     * @returns The render target.
+     */
+    get multiScatteringLutRenderTarget(): Nullable<RenderTargetTexture>;
+    /**
+     * The lookup table for diffuse sky irradiance, or null if not enabled.
+     */
+    get diffuseSkyIrradianceLut(): 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<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(): 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: Scene, lights: 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 IColor3Like>(directionToLight: IVector3Like, pointRadius: number, pointGeocentricNormal: 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 IColor3Like>(directionToLight: IVector3Like, pointRadius: number, pointGeocentricNormal: 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 Effect}.
+     * @param effect - The {@link Effect} to bind the uniform buffer to.
+     */
+    bindUniformBufferToEffect(effect: 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;
+}
+
+}
+declare module "babylonjs-addons/atmosphere/Shaders/transmittance.fragment" {
+import "babylonjs-addons/atmosphere/Shaders/ShadersInclude/atmosphereFragmentDeclaration";
+import "babylonjs-addons/atmosphere/Shaders/ShadersInclude/atmosphereUboDeclaration";
+import "babylonjs/Shaders/ShadersInclude/helperFunctions";
+import "babylonjs-addons/atmosphere/Shaders/ShadersInclude/atmosphereFunctions";
+/** @internal */
+export const transmittancePixelShader: {
+    name: string;
+    shader: string;
+};
+
+}
+declare module "babylonjs-addons/atmosphere/Shaders/skyView.fragment" {
+import "babylonjs-addons/atmosphere/Shaders/ShadersInclude/atmosphereFragmentDeclaration";
+import "babylonjs-addons/atmosphere/Shaders/ShadersInclude/atmosphereUboDeclaration";
+import "babylonjs/Shaders/ShadersInclude/helperFunctions";
+import "babylonjs-addons/atmosphere/Shaders/ShadersInclude/atmosphereFunctions";
+/** @internal */
+export const skyViewPixelShader: {
+    name: string;
+    shader: string;
+};
+
+}
+declare module "babylonjs-addons/atmosphere/Shaders/multiScattering.fragment" {
+import "babylonjs-addons/atmosphere/Shaders/ShadersInclude/atmosphereFragmentDeclaration";
+import "babylonjs-addons/atmosphere/Shaders/ShadersInclude/atmosphereUboDeclaration";
+import "babylonjs/Shaders/ShadersInclude/helperFunctions";
+import "babylonjs-addons/atmosphere/Shaders/ShadersInclude/atmosphereFunctions";
+/** @internal */
+export const multiScatteringPixelShader: {
+    name: string;
+    shader: string;
+};
+
+}
+declare module "babylonjs-addons/atmosphere/Shaders/fullscreenTriangle.vertex" {
+import "babylonjs-addons/atmosphere/Shaders/ShadersInclude/atmosphereFragmentDeclaration";
+import "babylonjs-addons/atmosphere/Shaders/ShadersInclude/atmosphereUboDeclaration";
+/** @internal */
+export const fullscreenTriangleVertexShader: {
+    name: string;
+    shader: string;
+};
+
+}
+declare module "babylonjs-addons/atmosphere/Shaders/diffuseSkyIrradiance.fragment" {
+import "babylonjs-addons/atmosphere/Shaders/ShadersInclude/atmosphereFragmentDeclaration";
+import "babylonjs-addons/atmosphere/Shaders/ShadersInclude/atmosphereUboDeclaration";
+import "babylonjs/Shaders/ShadersInclude/helperFunctions";
+import "babylonjs-addons/atmosphere/Shaders/ShadersInclude/depthFunctions";
+import "babylonjs-addons/atmosphere/Shaders/ShadersInclude/atmosphereFunctions";
+import "babylonjs/Shaders/ShadersInclude/importanceSampling";
+import "babylonjs/Shaders/ShadersInclude/pbrBRDFFunctions";
+import "babylonjs/Shaders/ShadersInclude/hdrFilteringFunctions";
+/** @internal */
+export const diffuseSkyIrradiancePixelShader: {
+    name: string;
+    shader: string;
+};
+
+}
+declare module "babylonjs-addons/atmosphere/Shaders/compositeSky.fragment" {
+import "babylonjs-addons/atmosphere/Shaders/ShadersInclude/atmosphereFragmentDeclaration";
+import "babylonjs-addons/atmosphere/Shaders/ShadersInclude/atmosphereUboDeclaration";
+import "babylonjs/Shaders/ShadersInclude/helperFunctions";
+import "babylonjs-addons/atmosphere/Shaders/ShadersInclude/depthFunctions";
+import "babylonjs-addons/atmosphere/Shaders/ShadersInclude/atmosphereFunctions";
+/** @internal */
+export const compositeSkyPixelShader: {
+    name: string;
+    shader: string;
+};
+
+}
+declare module "babylonjs-addons/atmosphere/Shaders/compositeGlobeAtmosphere.fragment" {
+import "babylonjs-addons/atmosphere/Shaders/ShadersInclude/atmosphereFragmentDeclaration";
+import "babylonjs-addons/atmosphere/Shaders/ShadersInclude/atmosphereUboDeclaration";
+import "babylonjs/Shaders/ShadersInclude/helperFunctions";
+import "babylonjs-addons/atmosphere/Shaders/ShadersInclude/depthFunctions";
+import "babylonjs-addons/atmosphere/Shaders/ShadersInclude/atmosphereFunctions";
+/** @internal */
+export const compositeGlobeAtmospherePixelShader: {
+    name: string;
+    shader: string;
+};
+
+}
+declare module "babylonjs-addons/atmosphere/Shaders/compositeAerialPerspective.fragment" {
+import "babylonjs-addons/atmosphere/Shaders/ShadersInclude/atmosphereFragmentDeclaration";
+import "babylonjs-addons/atmosphere/Shaders/ShadersInclude/atmosphereUboDeclaration";
+import "babylonjs/Shaders/ShadersInclude/helperFunctions";
+import "babylonjs-addons/atmosphere/Shaders/ShadersInclude/depthFunctions";
+import "babylonjs-addons/atmosphere/Shaders/ShadersInclude/atmosphereFunctions";
+/** @internal */
+export const compositeAerialPerspectivePixelShader: {
+    name: string;
+    shader: string;
+};
+
+}
+declare module "babylonjs-addons/atmosphere/Shaders/aerialPerspective.fragment" {
+import "babylonjs-addons/atmosphere/Shaders/ShadersInclude/atmosphereFragmentDeclaration";
+import "babylonjs-addons/atmosphere/Shaders/ShadersInclude/atmosphereUboDeclaration";
+import "babylonjs/Shaders/ShadersInclude/helperFunctions";
+import "babylonjs-addons/atmosphere/Shaders/ShadersInclude/atmosphereFunctions";
+/** @internal */
+export const aerialPerspectivePixelShader: {
+    name: string;
+    shader: string;
+};
+
+}
+declare module "babylonjs-addons/atmosphere/Shaders/ShadersInclude/depthFunctions" {
+/** @internal */
+export const depthFunctions: {
+    name: string;
+    shader: string;
+};
+
+}
+declare module "babylonjs-addons/atmosphere/Shaders/ShadersInclude/atmosphereVertexDeclaration" {
+/** @internal */
+export const atmosphereVertexDeclaration: {
+    name: string;
+    shader: string;
+};
+
+}
+declare module "babylonjs-addons/atmosphere/Shaders/ShadersInclude/atmosphereUboDeclaration" {
+/** @internal */
+export const atmosphereUboDeclaration: {
+    name: string;
+    shader: string;
+};
+
+}
+declare module "babylonjs-addons/atmosphere/Shaders/ShadersInclude/atmosphereFunctions" {
+import "babylonjs/Shaders/ShadersInclude/intersectionFunctions";
+/** @internal */
+export const atmosphereFunctions: {
+    name: string;
+    shader: string;
+};
+
+}
+declare module "babylonjs-addons/atmosphere/Shaders/ShadersInclude/atmosphereFragmentDeclaration" {
+/** @internal */
+export const atmosphereFragmentDeclaration: {
+    name: string;
+    shader: string;
+};
+
+}
+
+declare module "babylonjs-addons" {
+    export * from "babylonjs-addons/index";
+}
+
+
+declare module ADDONS {
+
+
+    /**
+     * Abstract Node class from Babylon.js
+     */
+    export interface INodeLike {
+        getWorldMatrix(): BABYLON.IMatrixLike;
+    }
+    /**
+     * Class used to render text using MSDF (Multi-channel Signed Distance Field) technique
+     * Thanks a lot to the work of Bhushan_Wagh and zb_sj for their amazing work on MSDF for Babylon.js
+     * #6RLCWP#16
+     * Star wars scroller: #6RLCWP#29
+     * With metrics: #6RLCWP#35
+     * Thickness: #IABMEZ#3
+     * Solar system: #9YCDYC#9
+     * Stroke: #6RLCWP#37
+     */
+    export class TextRenderer implements BABYLON.IDisposable {
+        private readonly _useVAO;
+        private _engine;
+        private _shaderLanguage;
+        private _vertexBuffers;
+        private _spriteBuffer;
+        private _worldBuffer;
+        private _uvBuffer;
+        private _drawWrapperBase;
+        private _vertexArrayObject;
+        private _font;
+        private _charMatrices;
+        private _charUvs;
+        private _isDirty;
+        private _baseLine;
+        private _scalingMatrix;
+        private _fontScaleMatrix;
+        private _offsetMatrix;
+        private _translationMatrix;
+        private _baseMatrix;
+        private _scaledMatrix;
+        private _localMatrix;
+        private _finalMatrix;
+        private _lineMatrix;
+        private _parentWorldMatrix;
+        /**
+         * Gets or sets the color of the text
+         */
+        color: BABYLON.IColor4Like;
+        /**
+         * Gets or sets the color of the stroke around the text
+         */
+        strokeColor: BABYLON.IColor4Like;
+        /**
+         * Gets or sets the width of the stroke around the text (inset)
+         */
+        strokeInsetWidth: number;
+        /**
+         * Gets or sets the width of the stroke around the text (outset)
+         */
+        strokeOutsetWidth: number;
+        /**
+         * Gets or sets the thickness of the text (0 means as defined in the font)
+         * Value must be between -0.5 and 0.5
+         */
+        thicknessControl: number;
+        private _parent;
+        /**
+         * Gets or sets the parent of the text renderer
+         */
+        get parent(): BABYLON.Nullable<INodeLike>;
+        set parent(value: BABYLON.Nullable<INodeLike>);
+        private _transformMatrix;
+        /**
+         * Gets or sets the transform matrix of the text renderer
+         * It will be applied in that order:
+         * parent x transform x paragraph world
+         */
+        get transformMatrix(): BABYLON.IMatrixLike;
+        set transformMatrix(value: BABYLON.IMatrixLike);
+        /**
+         * Gets or sets if the text is billboarded
+         */
+        isBillboard: boolean;
+        /**
+         * Gets or sets if the text is screen projected
+         * This will work only if the text is billboarded
+         */
+        isBillboardScreenProjected: boolean;
+        /**
+         * Gets the number of characters in the text renderer
+         */
+        get characterCount(): number;
+        /**
+         * Gets or sets if the text renderer should ignore the depth buffer
+         * Default is false
+         */
+        ignoreDepthBuffer: boolean;
+        private constructor();
+        private _resizeBuffers;
+        private _setShaders;
+        /**
+         * Add a paragraph of text to the renderer
+         * @param text define the text to add
+         * @param options define the options to use for the paragraph (optional)
+         * @param worldMatrix define the world matrix to use for the paragraph (optional)
+         */
+        addParagraph(text: string, options?: Partial<ParagraphOptions>, worldMatrix?: BABYLON.IMatrixLike): void;
+        /**
+         * Render the text using the provided view and projection matrices
+         * @param viewMatrix define the view matrix to use
+         * @param projectionMatrix define the projection matrix to use
+         */
+        render(viewMatrix: BABYLON.IMatrixLike, projectionMatrix: BABYLON.IMatrixLike): void;
+        /**
+         * Release associated resources
+         */
+        dispose(): void;
+        /**
+         * Creates a new TextRenderer instance asynchronously
+         * @param font define the font asset to use
+         * @param engine define the engine to use
+         * @returns a promise that resolves to the created TextRenderer instance
+         */
+        static CreateTextRendererAsync(font: FontAsset, engine: BABYLON.AbstractEngine): Promise<TextRenderer>;
+    }
+
+
+    /** @internal */
+    export type ParagraphOptions = {
+        maxWidth: number;
+        lineHeight: number;
+        letterSpacing: number;
+        tabSize: number;
+        whiteSpace: "pre-line";
+        textAlign: "left" | "right" | "center";
+        translate: BABYLON.IVector2Like | undefined;
+    };
+    /** @internal */
+    export var DefaultParagraphOptions: ParagraphOptions;
+
+
+
+
+    /**
+     * Class representing a font asset for SDF (Signed Distance Field) rendering.
+     */
+    export class FontAsset implements BABYLON.IDisposable {
+        private readonly _chars;
+        private readonly _charsRegex;
+        private readonly _kernings;
+        /** @internal */
+        readonly _font: SdfFont;
+        /**
+         * Gets the font scale value
+         */
+        readonly scale: number;
+        /**
+         * Gets the list of used textures
+         */
+        readonly textures: BABYLON.Texture[];
+        /**
+         * Creates a new FontAsset instance.
+         * @param definitionData defines the font data in JSON format.
+         * @param textureUrl defines the url of the texture to use for the font.
+         * @param scene defines the hosting scene.
+         */
+        constructor(definitionData: string, textureUrl: string, scene?: BABYLON.Scene);
+        dispose(): void;
+        private _updateFallbacks;
+        /** @internal */
+        _getChar(charCode: number): BMFontChar;
+        /** @internal */
+        _getKerning(first: number, second: number): number;
+        /** @internal */
+        _unsupportedChars(text: string): string;
+    }
+
+
+    /** @internal */
+    export var msdfVertexShaderWGSL: {
+        name: string;
+        shader: string;
+    };
+
+
+    /** @internal */
+    export var msdfPixelShaderWGSL: {
+        name: string;
+        shader: string;
+    };
+
+
+    /** @internal */
+    export var msdfVertexShader: {
+        name: string;
+        shader: string;
+    };
+
+
+    /** @internal */
+    export var msdfPixelShader: {
+        name: string;
+        shader: string;
+    };
+
+
+    /** @internal */
+    export class SdfTextParagraph {
+        readonly text: string;
+        readonly fontAsset: FontAsset;
+        readonly options: ParagraphOptions;
+        get lineHeight(): number;
+        readonly paragraph: string;
+        readonly lines: SdfTextLine[];
+        readonly width: number;
+        readonly height: number;
+        readonly glyphs: SdfGlyph[];
+        constructor(text: string, fontAsset: FontAsset, options?: Partial<ParagraphOptions>);
+        private _computeMetrics;
+        private _breakLines;
+        private _collapse;
+        private _wrap;
+    }
+
+
+    /** @internal */
+    export type SdfTextLine = {
+        text: string;
+        glyphs: SdfGlyph[];
+        start: number;
+        end: number;
+        width: number;
+    };
+
+
+
+
+    /** @internal */
+    export type SdfGlyph = {
+        char: BMFontChar;
+        /** index of the line */
+        line: number;
+        /** position within the line */
+        position: number;
+        x: number;
+        y: number;
+    };
+
+
+    export type SdfFontDistanceField = {
+        fieldType: "sdf" | "msdf";
+        distanceRange: number;
+    };
+    export type SdfFont = BMFont & {
+        distanceField: SdfFontDistanceField;
+    };
+
+
+    /**
+     * Holds information on how the font was generated.
+     */
+    export type BMFontInfo = {
+        /** The name of the font */
+        face: string;
+        /** The size of the font */
+        size: number;
+        /** The font is bold */
+        bold: number;
+        /** The font is italic */
+        italic: number;
+        /** The charset of the font */
+        charset: string[];
+        /** The charset is unicode  */
+        unicode: number;
+        /** The font height stretch in percentage. 100% means no stretch. */
+        stretchH: number;
+        /** Set to 1 if smoothing was turned on. */
+        smooth: number;
+        /** The supersampling level used. 1 means no supersampling was used. */
+        aa: number;
+        /** The padding for each character (up, right, down, left). */
+        padding: [number, number, number, number];
+        /** The spacing for each character (horizontal, vertical). */
+        spacing: [number, number];
+        /**
+         * The outline thickness for the characters.
+         *
+         * @remark missing in msdf-bmfont-xml
+         */
+        outline?: number;
+    };
+    /**
+     * Holds information common to all characters.
+     */
+    export type BMFontCommon = {
+        /** Distance in pixels between each line of text */
+        lineHeight: number;
+        /** The number of pixels from the absolute top of the line to the base of the characters */
+        base: number;
+        /** The width of the texture, normally used to scale the x pos of the character image */
+        scaleW: number;
+        /** The height of the texture, normally used to scale the y pos of the character image */
+        scaleH: number;
+        /** The number of pages in the font */
+        pages: number;
+        /** Set to 1 if the monochrome characters have been packed into each of the texture channels. In this case alphaChnl describes what is stored in each channel. */
+        packed: number;
+        /** Set to 0 if the channel holds the glyph data, 1 if it holds the outline, 2 if it holds the glyph and the outline, 3 if its set to zero, and 4 if its set to one. */
+        alphaChnl: number;
+        /** Set to 0 if the channel holds the glyph data, 1 if it holds the outline, 2 if it holds the glyph and the outline, 3 if its set to zero, and 4 if its set to one. */
+        redChnl: number;
+        /** Set to 0 if the channel holds the glyph data, 1 if it holds the outline, 2 if it holds the glyph and the outline, 3 if its set to zero, and 4 if its set to one. */
+        greenChnl: number;
+        /** Set to 0 if the channel holds the glyph data, 1 if it holds the outline, 2 if it holds the glyph and the outline, 3 if its set to zero, and 4 if its set to one. */
+        blueChnl: number;
+    };
+    /** Name of a texture file. There is one for each page in the font. */
+    export type BMFontPages = {
+        [id: number]: string;
+    } & Array<string>;
+    /**
+     * Describes a single character in the font
+     */
+    export type BMFontChar = {
+        /** Character id (charCode) */
+        id: number;
+        /** Left position of the character image in the texture. */
+        x: number;
+        /** Right position of the character image in the texture */
+        y: number;
+        /** Width of the chracter image in the texture */
+        width: number;
+        /** Height of the chracter image in the texture */
+        height: number;
+        /** Horizontal offset to be applied on screen */
+        xoffset: number;
+        /** Vertical offset to be applied on screen */
+        yoffset: number;
+        /** Horizontal advance after the character */
+        xadvance: number;
+        /** Page index where the character image is found */
+        page: number;
+        /** Texture channel where the chracter image is found
+         * - 1 = blue
+         * - 2 = green
+         * - 3 = red
+         * - 8 = alpha
+         * - 15 = all channels
+         */
+        chnl: number;
+    } & BMFontCharExtra;
+    /**
+     * additional context from msdf-bmfont-xml
+     */
+    export type BMFontCharExtra = {
+        /** index of opentype.js glyph */
+        index: number;
+        /** actual character*/
+        char: string;
+    };
+    /**
+     * The kerning information is used to adjust the distance between certain characters, e.g. some characters should be placed closer to each other than others.
+     */
+    export type BMFontKerning = {
+        /** The first character id. */
+        first: number;
+        /** The second character id. */
+        second: number;
+        /** How much the x position should be adjusted when drawing the second character immediately following the first. */
+        amount: number;
+    };
+    /**
+     * Compatible with [msdf-bmfont-xml](https://github.com/soimy/msdf-bmfont-xml)
+     * @see https://www.angelcode.com/products/bmfont/doc/file_format.html
+     */
+    export type BMFont = {
+        /** {@inheritDoc BMFontInfo} */
+        info: BMFontInfo;
+        /** {@inheritDoc BMFontCommon} */
+        common: BMFontCommon;
+        /** {@inheritDoc BMFontPages} */
+        pages: BMFontPages;
+        /** {@inheritDoc BMFontChar} */
+        chars: BMFontChar[];
+        /** {@inheritDoc BMFontKerning} */
+        kernings: BMFontKerning[];
+    };
+
+
+    /**
+     * BABYLON.Behavior for any content that can capture pointer events, i.e. bypass the Babylon pointer event handling
+     * and receive pointer events directly.  It will register the capture triggers and negotiate the capture and
+     * release of pointer events.  Curerntly this applies only to HtmlMesh
+     */
+    export class PointerEventsCaptureBehavior implements BABYLON.Behavior<BABYLON.AbstractMesh> {
+        private _captureCallback;
+        private _releaseCallback;
+        /** gets or sets behavior's name */
+        name: string;
+        private _attachedMesh;
+        /** @internal */
+        _captureOnPointerEnter: boolean;
+        /**
+         * Gets or sets the mesh that the behavior is attached to
+         */
+        get attachedMesh(): BABYLON.AbstractMesh | null;
+        set attachedMesh(value: BABYLON.AbstractMesh | null);
+        constructor(_captureCallback: () => void, _releaseCallback: () => void, { captureOnPointerEnter }?: {
+            captureOnPointerEnter?: boolean | undefined;
+        });
+        /**
+         * Set if the behavior should capture pointer events when the pointer enters the mesh
+         */
+        set captureOnPointerEnter(captureOnPointerEnter: boolean);
+        /**
+         * Function called when the behavior needs to be initialized (before attaching it to a target)
+         */
+        init(): void;
+        /**
+         * Called when the behavior is attached to a target
+         * @param mesh defines the target where the behavior is attached to
+         */
+        attach(mesh: BABYLON.AbstractMesh): void;
+        /**
+         * Called when the behavior is detached from its target
+         */
+        detach(): void;
+        /**
+         * Dispose the behavior
+         */
+        dispose(): void;
+        releasePointerEvents(): void;
+        capturePointerEvents(): void;
+    }
+
+
+    type CaptureReleaseCallback = () => void;
+    /**
+     * Get the id of the object currently capturing pointer events
+     * @returns The id of the object currently capturing pointer events
+     * or null if no object is capturing pointer events
+     */
+    export const getCapturingId: () => string | null;
+    /**
+     * Request that the object with the given id capture pointer events.  If there is no current
+     * owner, then the request is granted immediately.  If there is a current owner, then the request
+     * is queued until the current owner releases pointer events.
+     * @param requestId An id to identify the request.  This id will be used to match the capture
+     * request with the release request.
+     * @param captureCallback The callback to call when the request is granted and the object is capturing
+     * @param releaseCallback The callback to call when the object is no longer capturing pointer events
+     */
+    export const requestCapture: (requestId: string, captureCallback: CaptureReleaseCallback, releaseCallback: CaptureReleaseCallback) => void;
+    /**
+     * Release pointer events from the object with the given id.  If the object is the current owner
+     * then pointer events are released immediately.  If the object is not the current owner, then the
+     * associated capture request is removed from the queue.  If there is no matching capture request
+     * in the queue, then the release request is added to a list of unmatched release requests and will
+     * negate the next capture request with the same id.  This is to guard against the possibility that
+     * the release request arrived before the capture request.
+     * @param requestId The id which should match the id of the capture request
+     */
+    export const requestRelease: (requestId: string | null) => void;
+    /**
+     * Release pointer events from the current owner
+     */
+    export const releaseCurrent: () => void;
+   }
+
+        interface Window {
+            "pointer-events-capture-debug": boolean | null;
+        }
+    declare module ADDONS {
+    
+
+
+
+    /**
+     * A function that compares two submeshes and returns a number indicating which
+     * should be rendered first.
+     */
+    type RenderOrderFunction = (subMeshA: BABYLON.SubMesh, subMeshB: BABYLON.SubMesh) => number;
+    /**
+     * An instance of this is required to render HtmlMeshes in the scene.
+     * if using HtmlMeshes, you must not set render order for group 0 using
+     * scene.setRenderingOrder.  You must instead pass the compare functions
+     * to the HtmlMeshRenderer constructor.  If you do not, then your render
+     * order will be overwritten if the HtmlMeshRenderer is created after and
+     * the HtmlMeshes will not render correctly (they will appear in front of
+     * meshes that are actually in front of them) if the HtmlMeshRenderer is
+     * created before.
+     */
+    export class HtmlMeshRenderer {
+        /**
+         * Global scale factor applied to the homogeneous `w` component (m[15]) of the
+         * transformation matrix when projecting 3D objects into pixel space.
+         *
+         * This value is used to balance Babylon units against screen pixels, ensuring
+         * that HTML-mapped or screen-space objects appear with the correct relative
+         * size. Adjust with care, as changing it affects the projection scale of all
+         * transformed objects.
+         *
+         *  The default value is `0.00001`, which works well when 1 Babylon unit
+         *  corresponds to 1 meter, and the typical screen resolution is around
+         * 100 pixels per meter (i.e., 1 pixel per centimeter).
+         */
+        static PROJECTION_SCALE_FACTOR: number;
+        private _containerId?;
+        private _inSceneElements?;
+        private _overlayElements?;
+        private _engine;
+        private _cache;
+        private _width;
+        private _height;
+        private _heightHalf;
+        private _cameraWorldMatrix?;
+        private _temp;
+        private _lastDevicePixelRatio;
+        private _cameraMatrixUpdated;
+        private _previousCanvasDocumentPosition;
+        private _renderObserver;
+        /**
+         * Contruct an instance of HtmlMeshRenderer
+         * @param scene
+         * @param options object containing the following optional properties:
+         * @returns
+         */
+        constructor(scene: BABYLON.Scene, { parentContainerId, _containerId, enableOverlayRender, defaultOpaqueRenderOrder, defaultAlphaTestRenderOrder, defaultTransparentRenderOrder, }?: {
+            parentContainerId?: string | null;
+            _containerId?: string;
+            defaultOpaqueRenderOrder?: RenderOrderFunction;
+            defaultAlphaTestRenderOrder?: RenderOrderFunction;
+            defaultTransparentRenderOrder?: RenderOrderFunction;
+            enableOverlayRender?: boolean;
+        });
+        /**
+         * Dispose of the HtmlMeshRenderer
+         */
+        dispose(): void;
+        protected _init(scene: BABYLON.Scene, parentContainerId: string | null, enableOverlayRender: boolean, defaultOpaqueRenderOrder: RenderOrderFunction, defaultAlphaTestRenderOrder: RenderOrderFunction, defaultTransparentRenderOrder: RenderOrderFunction): void;
+        private _createRenderLayerElements;
+        protected _getSize(): {
+            width: number;
+            height: number;
+        };
+        protected _setSize(width: number, height: number): void;
+        protected _getCameraCssMatrix(matrix: BABYLON.Matrix): string;
+        protected _getHtmlContentCssMatrix(matrix: BABYLON.Matrix, useRightHandedSystem: boolean): string;
+        protected _getTransformationMatrix(htmlMesh: HtmlMesh, useRightHandedSystem: boolean): BABYLON.Matrix;
+        protected _renderHtmlMesh(htmlMesh: HtmlMesh, useRightHandedSystem: boolean): void;
+        protected _render(scene: BABYLON.Scene, camera: BABYLON.Camera): void;
+        protected _updateBaseScaleFactor(htmlMesh: HtmlMesh): void;
+        protected _updateContainerPositionIfNeeded(): void;
+        protected _onCameraMatrixChanged: (camera: BABYLON.Camera) => void;
+        private _epsilon;
+        private _getAncestorMarginsAndPadding;
+    }
+
 
-declare module "babylonjs-addons" {
-    export * from "babylonjs-addons/index";
-}
+    /**
+     * This class represents HTML content that we want to render as though it is part of the scene.  The HTML content is actually
+     * rendered below the canvas, but a depth mask is created by this class that writes to the depth buffer but does not
+     * write to the color buffer, effectively punching a hole in the canvas.  CSS transforms are used to scale, translate, and rotate
+     * the HTML content so that it matches the camera and mesh orientation.  The class supports interactions in editable and non-editable mode.
+     * In non-editable mode (the default), events are passed to the HTML content when the pointer is over the mask (and not occluded by other meshes
+     * in the scene).
+     * @see https://playground.babylonjs.com/#HVHYJC#5
+     * @see https://playground.babylonjs.com/#B17TC7#112
+     */
+    export class HtmlMesh extends BABYLON.Mesh {
+        /**
+         * Helps identifying a html mesh from a regular mesh
+         */
+        get isHtmlMesh(): boolean;
+        private _enabled;
+        private _ready;
+        /**
+         * @internal
+         */
+        _isCanvasOverlay: boolean;
+        private _requiresUpdate;
+        private _element?;
+        private _width?;
+        private _height?;
+        private _inverseScaleMatrix;
+        private _captureOnPointerEnter;
+        private _pointerEventCaptureBehavior;
+        private _sourceWidth;
+        private _sourceHeight;
+        /**
+         * Return the source width of the content in pixels
+         */
+        get sourceWidth(): number | null;
+        /**
+         * Return the source height of the content in pixels
+         */
+        get sourceHeight(): number | null;
+        private _worldMatrixUpdateObserver;
+        private _fitStrategy;
+        /**
+         * Contruct an instance of HtmlMesh
+         * @param scene
+         * @param id The id of the mesh.  Will be used as the id of the HTML element as well.
+         * @param options object with optional parameters
+         */
+        constructor(scene: BABYLON.Scene, id: string, { captureOnPointerEnter, isCanvasOverlay, fitStrategy }?: {
+            captureOnPointerEnter?: boolean | undefined;
+            isCanvasOverlay?: boolean | undefined;
+            fitStrategy?: FitStrategyType | undefined;
+        });
+        /**
+         * The width of the content in pixels
+         */
+        get width(): number | undefined;
+        /**
+         * The height of the content in pixels
+         */
+        get height(): number | undefined;
+        /**
+         * The HTML element that is being rendered as a mesh
+         */
+        get element(): HTMLElement | undefined;
+        /**
+         * True if the mesh has been moved, rotated, or scaled since the last time this
+         * property was read.  This property is reset to false after reading.
+         */
+        get requiresUpdate(): boolean;
+        /**
+         * Enable capture for the pointer when entering the mesh area
+         */
+        set captureOnPointerEnter(captureOnPointerEnter: boolean);
+        /**
+         * Disposes of the mesh and the HTML element
+         */
+        dispose(): void;
+        /**
+         * @internal
+         */
+        _markAsUpdated(): void;
+        /**
+         * Sets the content of the element to the specified content adjusting the mesh scale to match and making it visible.
+         * If the the specified content is undefined, then it will make the mesh invisible.  In either case it will clear the
+         * element content first.
+         * @param element The element to render as a mesh
+         * @param width The width of the mesh in Babylon units
+         * @param height The height of the mesh in Babylon units
+         */
+        setContent(element: HTMLElement, width: number, height: number): void;
+        setEnabled(enabled: boolean): void;
+        /**
+         * Sets the content size in pixels
+         * @param width width of the source
+         * @param height height of the source
+         */
+        setContentSizePx(width: number, height: number): void;
+        protected _setAsReady(ready: boolean): void;
+        protected _doSetEnabled(enabled: boolean): void;
+        protected _updateScaleIfNecessary(): void;
+        protected _createMask(): void;
+        protected _setElementzIndex(zIndex: number): void;
+        /**
+         * Callback used by the PointerEventsCaptureBehavior to capture pointer events
+         */
+        capturePointerEvents(): void;
+        /**
+         * Callback used by the PointerEventsCaptureBehavior to release pointer events
+         */
+        releasePointerEvents(): void;
+        protected _createElement(): HTMLDivElement | undefined;
+    }
 
 
-declare module ADDONS {
+    export type FitStrategyType = {
+        wrapElement(element: HTMLElement): HTMLElement;
+        updateSize(sizingElement: HTMLElement, width: number, height: number): void;
+    };
+    export var FitStrategy: {
+        CONTAIN: FitStrategyType;
+        COVER: FitStrategyType;
+        STRETCH: FitStrategyType;
+        NONE: FitStrategyType;
+    };
 
 
     /**
-     * Abstract Node class from Babylon.js
+     * The transmittance LUT can be used to get the radiance from an external light source arriving a given point, accounting for atmospheric scattering.
      */
-    export interface INodeLike {
-        getWorldMatrix(): BABYLON.IMatrixLike;
+    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;
     }
+
+
     /**
-     * Class used to render text using MSDF (Multi-channel Signed Distance Field) technique
-     * Thanks a lot to the work of Bhushan_Wagh and zb_sj for their amazing work on MSDF for Babylon.js
-     * #6RLCWP#16
-     * Star wars scroller: #6RLCWP#29
-     * With metrics: #6RLCWP#35
-     * Thickness: #IABMEZ#3
-     * Solar system: #9YCDYC#9
-     * Stroke: #6RLCWP#37
+     * 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 class TextRenderer implements BABYLON.IDisposable {
-        private readonly _useVAO;
-        private _engine;
-        private _shaderLanguage;
-        private _vertexBuffers;
-        private _spriteBuffer;
-        private _worldBuffer;
-        private _uvBuffer;
-        private _drawWrapperBase;
-        private _vertexArrayObject;
-        private _font;
-        private _charMatrices;
-        private _charUvs;
+    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 _baseLine;
-        private _scalingMatrix;
-        private _fontScaleMatrix;
-        private _offsetMatrix;
-        private _translationMatrix;
-        private _baseMatrix;
-        private _scaledMatrix;
-        private _localMatrix;
-        private _finalMatrix;
-        private _lineMatrix;
-        private _parentWorldMatrix;
+        private _isDisposed;
+        private _lutData;
         /**
-         * Gets or sets the color of the text
+         * True if the LUT needs to be rendered.
          */
-        color: BABYLON.IColor4Like;
+        get isDirty(): boolean;
         /**
-         * Gets or sets the color of the stroke around the text
+         * True if the LUT has been disposed.
          */
-        strokeColor: BABYLON.IColor4Like;
+        get isDisposed(): boolean;
         /**
-         * Gets or sets the width of the stroke around the text (inset)
+         * The render target used for this LUT.
+         * @throws if the LUT has been disposed.
          */
-        strokeInsetWidth: number;
+        get renderTarget(): BABYLON.RenderTargetTexture;
         /**
-         * Gets or sets the width of the stroke around the text (outset)
+         * True if the LUT data has been read back from the GPU.
          */
-        strokeOutsetWidth: number;
+        get hasLutData(): boolean;
         /**
-         * Gets or sets the thickness of the text (0 means as defined in the font)
-         * Value must be between -0.5 and 0.5
+         * Constructs the {@link DiffuseSkyIrradianceLut}.
+         * @param atmosphere - The atmosphere to use.
          */
-        thicknessControl: number;
-        private _parent;
+        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;
         /**
-         * Gets or sets the parent of the text renderer
+         * Horizon distance from the planet's surface to the outer edge of the atmosphere in kilometers.
          */
-        get parent(): BABYLON.Nullable<INodeLike>;
-        set parent(value: BABYLON.Nullable<INodeLike>);
-        private _transformMatrix;
+        get horizonDistanceToAtmosphereEdge(): number;
         /**
-         * Gets or sets the transform matrix of the text renderer
-         * It will be applied in that order:
-         * parent x transform x paragraph world
+         * Horizon distance from the planet's surface to the outer edge of the atmosphere, squared, in kilometers.
          */
-        get transformMatrix(): BABYLON.IMatrixLike;
-        set transformMatrix(value: BABYLON.IMatrixLike);
+        get horizonDistanceToAtmosphereEdgeSquared(): number;
         /**
-         * Gets or sets if the text is billboarded
+         * The scale applied to {@link peakRayleighScattering}.
          */
-        isBillboard: boolean;
+        get rayleighScatteringScale(): number;
+        set rayleighScatteringScale(value: number);
         /**
-         * Gets or sets if the text is screen projected
-         * This will work only if the text is billboarded
+         * The Rayleigh scattering per kilometer at sea level for red, green, and blue wavelengths.
          */
-        isBillboardScreenProjected: boolean;
+        get peakRayleighScattering(): BABYLON.Vector3;
+        set peakRayleighScattering(value: BABYLON.Vector3);
         /**
-         * Gets the number of characters in the text renderer
+         * 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 characterCount(): number;
+        get rayleighScattering(): BABYLON.Vector3;
         /**
-         * Gets or sets if the text renderer should ignore the depth buffer
-         * Default is false
+         * The scale applied to {@link peakMieScattering}.
          */
-        ignoreDepthBuffer: boolean;
-        private constructor();
-        private _resizeBuffers;
-        private _setShaders;
+        get mieScatteringScale(): number;
+        set mieScatteringScale(value: number);
         /**
-         * Add a paragraph of text to the renderer
-         * @param text define the text to add
-         * @param options define the options to use for the paragraph (optional)
-         * @param worldMatrix define the world matrix to use for the paragraph (optional)
+         * The Mie scattering per kilometer at sea level for red, green, and blue wavelengths.
          */
-        addParagraph(text: string, options?: Partial<ParagraphOptions>, worldMatrix?: BABYLON.IMatrixLike): void;
+        get peakMieScattering(): BABYLON.Vector3;
+        set peakMieScattering(value: BABYLON.Vector3);
         /**
-         * Render the text using the provided view and projection matrices
-         * @param viewMatrix define the view matrix to use
-         * @param projectionMatrix define the projection matrix to use
+         * 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}.
          */
-        render(viewMatrix: BABYLON.IMatrixLike, projectionMatrix: BABYLON.IMatrixLike): void;
+        get mieScattering(): BABYLON.Vector3;
         /**
-         * Release associated resources
+         * The scale applied to {@link peakMieAbsorption}.
          */
-        dispose(): void;
+        get mieAbsorptionScale(): number;
+        set mieAbsorptionScale(value: number);
         /**
-         * Creates a new TextRenderer instance asynchronously
-         * @param font define the font asset to use
-         * @param engine define the engine to use
-         * @returns a promise that resolves to the created TextRenderer instance
+         * The Mie absorption per kilometer at sea level for red, green, and blue wavelengths.
          */
-        static CreateTextRendererAsync(font: FontAsset, engine: BABYLON.AbstractEngine): Promise<TextRenderer>;
-    }
-
-
-    /** @internal */
-    export type ParagraphOptions = {
-        maxWidth: number;
-        lineHeight: number;
-        letterSpacing: number;
-        tabSize: number;
-        whiteSpace: "pre-line";
-        textAlign: "left" | "right" | "center";
-        translate: BABYLON.IVector2Like | undefined;
-    };
-    /** @internal */
-    export var DefaultParagraphOptions: ParagraphOptions;
-
-
-
-
-    /**
-     * Class representing a font asset for SDF (Signed Distance Field) rendering.
-     */
-    export class FontAsset implements BABYLON.IDisposable {
-        private readonly _chars;
-        private readonly _charsRegex;
-        private readonly _kernings;
-        /** @internal */
-        readonly _font: SdfFont;
+        get peakMieAbsorption(): BABYLON.Vector3;
+        set peakMieAbsorption(value: BABYLON.Vector3);
         /**
-         * Gets the font scale value
+         * 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}.
          */
-        readonly scale: number;
+        get mieAbsorption(): BABYLON.Vector3;
         /**
-         * Gets the list of used textures
+         * 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}.
          */
-        readonly textures: BABYLON.Texture[];
+        get mieExtinction(): BABYLON.Vector3;
         /**
-         * Creates a new FontAsset instance.
-         * @param definitionData defines the font data in JSON format.
-         * @param textureUrl defines the url of the texture to use for the font.
-         * @param scene defines the hosting scene.
+         * The scale applied to {@link peakOzoneAbsorption}.
          */
-        constructor(definitionData: string, textureUrl: string, scene?: BABYLON.Scene);
-        dispose(): void;
-        private _updateFallbacks;
-        /** @internal */
-        _getChar(charCode: number): BMFontChar;
-        /** @internal */
-        _getKerning(first: number, second: number): number;
-        /** @internal */
-        _unsupportedChars(text: string): string;
-    }
-
-
-    /** @internal */
-    export var msdfVertexShaderWGSL: {
-        name: string;
-        shader: string;
-    };
-
-
-    /** @internal */
-    export var msdfPixelShaderWGSL: {
-        name: string;
-        shader: string;
-    };
-
-
-    /** @internal */
-    export var msdfVertexShader: {
-        name: string;
-        shader: string;
-    };
-
-
-    /** @internal */
-    export var msdfPixelShader: {
-        name: string;
-        shader: string;
-    };
-
-
-    /** @internal */
-    export class SdfTextParagraph {
-        readonly text: string;
-        readonly fontAsset: FontAsset;
-        readonly options: ParagraphOptions;
-        get lineHeight(): number;
-        readonly paragraph: string;
-        readonly lines: SdfTextLine[];
-        readonly width: number;
-        readonly height: number;
-        readonly glyphs: SdfGlyph[];
-        constructor(text: string, fontAsset: FontAsset, options?: Partial<ParagraphOptions>);
-        private _computeMetrics;
-        private _breakLines;
-        private _collapse;
-        private _wrap;
-    }
-
-
-    /** @internal */
-    export type SdfTextLine = {
-        text: string;
-        glyphs: SdfGlyph[];
-        start: number;
-        end: number;
-        width: number;
-    };
-
-
-
-
-    /** @internal */
-    export type SdfGlyph = {
-        char: BMFontChar;
-        /** index of the line */
-        line: number;
-        /** position within the line */
-        position: number;
-        x: number;
-        y: number;
-    };
-
-
-    export type SdfFontDistanceField = {
-        fieldType: "sdf" | "msdf";
-        distanceRange: number;
-    };
-    export type SdfFont = BMFont & {
-        distanceField: SdfFontDistanceField;
-    };
-
-
-    /**
-     * Holds information on how the font was generated.
-     */
-    export type BMFontInfo = {
-        /** The name of the font */
-        face: string;
-        /** The size of the font */
-        size: number;
-        /** The font is bold */
-        bold: number;
-        /** The font is italic */
-        italic: number;
-        /** The charset of the font */
-        charset: string[];
-        /** The charset is unicode  */
-        unicode: number;
-        /** The font height stretch in percentage. 100% means no stretch. */
-        stretchH: number;
-        /** Set to 1 if smoothing was turned on. */
-        smooth: number;
-        /** The supersampling level used. 1 means no supersampling was used. */
-        aa: number;
-        /** The padding for each character (up, right, down, left). */
-        padding: [number, number, number, number];
-        /** The spacing for each character (horizontal, vertical). */
-        spacing: [number, number];
+        get ozoneAbsorptionScale(): number;
+        set ozoneAbsorptionScale(value: number);
         /**
-         * The outline thickness for the characters.
-         *
-         * @remark missing in msdf-bmfont-xml
+         * The ozone absorption per kilometer measured at a height corresponding to it's peak concentration,
+         * for red, green, and blue wavelengths.
          */
-        outline?: number;
-    };
-    /**
-     * Holds information common to all characters.
-     */
-    export type BMFontCommon = {
-        /** Distance in pixels between each line of text */
-        lineHeight: number;
-        /** The number of pixels from the absolute top of the line to the base of the characters */
-        base: number;
-        /** The width of the texture, normally used to scale the x pos of the character image */
-        scaleW: number;
-        /** The height of the texture, normally used to scale the y pos of the character image */
-        scaleH: number;
-        /** The number of pages in the font */
-        pages: number;
-        /** Set to 1 if the monochrome characters have been packed into each of the texture channels. In this case alphaChnl describes what is stored in each channel. */
-        packed: number;
-        /** Set to 0 if the channel holds the glyph data, 1 if it holds the outline, 2 if it holds the glyph and the outline, 3 if its set to zero, and 4 if its set to one. */
-        alphaChnl: number;
-        /** Set to 0 if the channel holds the glyph data, 1 if it holds the outline, 2 if it holds the glyph and the outline, 3 if its set to zero, and 4 if its set to one. */
-        redChnl: number;
-        /** Set to 0 if the channel holds the glyph data, 1 if it holds the outline, 2 if it holds the glyph and the outline, 3 if its set to zero, and 4 if its set to one. */
-        greenChnl: number;
-        /** Set to 0 if the channel holds the glyph data, 1 if it holds the outline, 2 if it holds the glyph and the outline, 3 if its set to zero, and 4 if its set to one. */
-        blueChnl: number;
-    };
-    /** Name of a texture file. There is one for each page in the font. */
-    export type BMFontPages = {
-        [id: number]: string;
-    } & Array<string>;
-    /**
-     * Describes a single character in the font
-     */
-    export type BMFontChar = {
-        /** Character id (charCode) */
-        id: number;
-        /** Left position of the character image in the texture. */
-        x: number;
-        /** Right position of the character image in the texture */
-        y: number;
-        /** Width of the chracter image in the texture */
-        width: number;
-        /** Height of the chracter image in the texture */
-        height: number;
-        /** Horizontal offset to be applied on screen */
-        xoffset: number;
-        /** Vertical offset to be applied on screen */
-        yoffset: number;
-        /** Horizontal advance after the character */
-        xadvance: number;
-        /** Page index where the character image is found */
-        page: number;
-        /** Texture channel where the chracter image is found
-         * - 1 = blue
-         * - 2 = green
-         * - 3 = red
-         * - 8 = alpha
-         * - 15 = all channels
+        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}.
          */
-        chnl: number;
-    } & BMFontCharExtra;
-    /**
-     * additional context from msdf-bmfont-xml
-     */
-    export type BMFontCharExtra = {
-        /** index of opentype.js glyph */
-        index: number;
-        /** actual character*/
-        char: string;
-    };
-    /**
-     * The kerning information is used to adjust the distance between certain characters, e.g. some characters should be placed closer to each other than others.
-     */
-    export type BMFontKerning = {
-        /** The first character id. */
-        first: number;
-        /** The second character id. */
-        second: number;
-        /** How much the x position should be adjusted when drawing the second character immediately following the first. */
-        amount: number;
-    };
-    /**
-     * Compatible with [msdf-bmfont-xml](https://github.com/soimy/msdf-bmfont-xml)
-     * @see https://www.angelcode.com/products/bmfont/doc/file_format.html
-     */
-    export type BMFont = {
-        /** {@inheritDoc BMFontInfo} */
-        info: BMFontInfo;
-        /** {@inheritDoc BMFontCommon} */
-        common: BMFontCommon;
-        /** {@inheritDoc BMFontPages} */
-        pages: BMFontPages;
-        /** {@inheritDoc BMFontChar} */
-        chars: BMFontChar[];
-        /** {@inheritDoc BMFontKerning} */
-        kernings: BMFontKerning[];
-    };
+        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;
+    }
 
 
     /**
-     * BABYLON.Behavior for any content that can capture pointer events, i.e. bypass the Babylon pointer event handling
-     * and receive pointer events directly.  It will register the capture triggers and negotiate the capture and
-     * release of pointer events.  Curerntly this applies only to HtmlMesh
+     * Variables that are used to render the atmosphere and are computed per-camera.
      */
-    export class PointerEventsCaptureBehavior implements BABYLON.Behavior<BABYLON.AbstractMesh> {
-        private _captureCallback;
-        private _releaseCallback;
-        /** gets or sets behavior's name */
-        name: string;
-        private _attachedMesh;
-        /** @internal */
-        _captureOnPointerEnter: boolean;
+    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;
         /**
-         * Gets or sets the mesh that the behavior is attached to
+         * The inverse view projection matrix is used to unproject rays.
+         * To avoid precision issues, the translation part of the matrix has been removed.
          */
-        get attachedMesh(): BABYLON.AbstractMesh | null;
-        set attachedMesh(value: BABYLON.AbstractMesh | null);
-        constructor(_captureCallback: () => void, _releaseCallback: () => void, { captureOnPointerEnter }?: {
-            captureOnPointerEnter?: boolean | undefined;
-        });
+        get inverseViewProjectionMatrixWithoutTranslation(): BABYLON.IMatrixLike;
         /**
-         * Set if the behavior should capture pointer events when the pointer enters the mesh
+         * The direction to the light relative to the geocentric normal under the camera.
          */
-        set captureOnPointerEnter(captureOnPointerEnter: boolean);
+        get directionToLightRelativeToCameraGeocentricNormal(): BABYLON.IVector3Like;
         /**
-         * Function called when the behavior needs to be initialized (before attaching it to a target)
+         * The cosine of the angle between the light direction and zenith.
          */
-        init(): void;
+        get cosAngleLightToZenith(): number;
         /**
-         * Called when the behavior is attached to a target
-         * @param mesh defines the target where the behavior is attached to
+         * The distance from the camera to the planet origin in kilometers.
          */
-        attach(mesh: BABYLON.AbstractMesh): void;
+        get cameraRadius(): number;
         /**
-         * Called when the behavior is detached from its target
+         * The distance from the camera to the planet origin, clamped to the planet radius offset, in kilometers.
          */
-        detach(): void;
+        get clampedCameraRadius(): number;
         /**
-         * Dispose the behavior
+         * The height of the camera above the planet surface in kilometers.
          */
-        dispose(): void;
-        releasePointerEvents(): void;
-        capturePointerEvents(): void;
+        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;
     }
 
 
-    type CaptureReleaseCallback = () => void;
-    /**
-     * Get the id of the object currently capturing pointer events
-     * @returns The id of the object currently capturing pointer events
-     * or null if no object is capturing pointer events
-     */
-    export const getCapturingId: () => string | null;
-    /**
-     * Request that the object with the given id capture pointer events.  If there is no current
-     * owner, then the request is granted immediately.  If there is a current owner, then the request
-     * is queued until the current owner releases pointer events.
-     * @param requestId An id to identify the request.  This id will be used to match the capture
-     * request with the release request.
-     * @param captureCallback The callback to call when the request is granted and the object is capturing
-     * @param releaseCallback The callback to call when the object is no longer capturing pointer events
-     */
-    export const requestCapture: (requestId: string, captureCallback: CaptureReleaseCallback, releaseCallback: CaptureReleaseCallback) => void;
-    /**
-     * Release pointer events from the object with the given id.  If the object is the current owner
-     * then pointer events are released immediately.  If the object is not the current owner, then the
-     * associated capture request is removed from the queue.  If there is no matching capture request
-     * in the queue, then the release request is added to a list of unmatched release requests and will
-     * negate the next capture request with the same id.  This is to guard against the possibility that
-     * the release request arrived before the capture request.
-     * @param requestId The id which should match the id of the capture request
-     */
-    export const requestRelease: (requestId: string | null) => 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);
+    }
     /**
-     * Release pointer events from the current owner
+     * Adds shading logic to a PBRMaterial that provides radiance, diffuse sky irradiance, and aerial perspective from the atmosphere.
      */
-    export const releaseCurrent: () => void;
-   }
-
-        interface Window {
-            "pointer-events-capture-debug": boolean | null;
-        }
-    declare module ADDONS {
-    
-
+    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>>;
+    }
 
 
     /**
-     * A function that compares two submeshes and returns a number indicating which
-     * should be rendered first.
-     */
-    type RenderOrderFunction = (subMeshA: BABYLON.SubMesh, subMeshB: BABYLON.SubMesh) => number;
-    /**
-     * An instance of this is required to render HtmlMeshes in the scene.
-     * if using HtmlMeshes, you must not set render order for group 0 using
-     * scene.setRenderingOrder.  You must instead pass the compare functions
-     * to the HtmlMeshRenderer constructor.  If you do not, then your render
-     * order will be overwritten if the HtmlMeshRenderer is created after and
-     * the HtmlMeshes will not render correctly (they will appear in front of
-     * meshes that are actually in front of them) if the HtmlMeshRenderer is
-     * created before.
+     * Creation options for the {@link Atmosphere}.
      */
-    export class HtmlMeshRenderer {
+    export interface IAtmosphereOptions {
         /**
-         * Global scale factor applied to the homogeneous `w` component (m[15]) of the
-         * transformation matrix when projecting 3D objects into pixel space.
-         *
-         * This value is used to balance Babylon units against screen pixels, ensuring
-         * that HTML-mapped or screen-space objects appear with the correct relative
-         * size. Adjust with care, as changing it affects the projection scale of all
-         * transformed objects.
-         *
-         *  The default value is `0.00001`, which works well when 1 Babylon unit
-         *  corresponds to 1 meter, and the typical screen resolution is around
-         * 100 pixels per meter (i.e., 1 pixel per centimeter).
+         * The properties that define the atmosphere's composition and size.
          */
-        static PROJECTION_SCALE_FACTOR: number;
-        private _containerId?;
-        private _inSceneElements?;
-        private _overlayElements?;
-        private _engine;
-        private _cache;
-        private _width;
-        private _height;
-        private _heightHalf;
-        private _cameraWorldMatrix?;
-        private _temp;
-        private _lastDevicePixelRatio;
-        private _cameraMatrixUpdated;
-        private _previousCanvasDocumentPosition;
-        private _renderObserver;
+        physicalProperties?: AtmospherePhysicalProperties;
         /**
-         * Contruct an instance of HtmlMeshRenderer
-         * @param scene
-         * @param options object containing the following optional properties:
-         * @returns
+         * 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.
          */
-        constructor(scene: BABYLON.Scene, { parentContainerId, _containerId, enableOverlayRender, defaultOpaqueRenderOrder, defaultAlphaTestRenderOrder, defaultTransparentRenderOrder, }?: {
-            parentContainerId?: string | null;
-            _containerId?: string;
-            defaultOpaqueRenderOrder?: RenderOrderFunction;
-            defaultAlphaTestRenderOrder?: RenderOrderFunction;
-            defaultTransparentRenderOrder?: RenderOrderFunction;
-            enableOverlayRender?: boolean;
-        });
+        depthTexture?: BABYLON.BaseTexture;
         /**
-         * Dispose of the HtmlMeshRenderer
+         * Controls the overall brightness of the atmosphere rendering.
+         * A value of 1.0 is physically correct.
          */
-        dispose(): void;
-        protected _init(scene: BABYLON.Scene, parentContainerId: string | null, enableOverlayRender: boolean, defaultOpaqueRenderOrder: RenderOrderFunction, defaultAlphaTestRenderOrder: RenderOrderFunction, defaultTransparentRenderOrder: RenderOrderFunction): void;
-        private _createRenderLayerElements;
-        protected _getSize(): {
-            width: number;
-            height: number;
-        };
-        protected _setSize(width: number, height: number): void;
-        protected _getCameraCssMatrix(matrix: BABYLON.Matrix): string;
-        protected _getHtmlContentCssMatrix(matrix: BABYLON.Matrix, useRightHandedSystem: boolean): string;
-        protected _getTransformationMatrix(htmlMesh: HtmlMesh, useRightHandedSystem: boolean): BABYLON.Matrix;
-        protected _renderHtmlMesh(htmlMesh: HtmlMesh, useRightHandedSystem: boolean): void;
-        protected _render(scene: BABYLON.Scene, camera: BABYLON.Camera): void;
-        protected _updateBaseScaleFactor(htmlMesh: HtmlMesh): void;
-        protected _updateContainerPositionIfNeeded(): void;
-        protected _onCameraMatrixChanged: (camera: BABYLON.Camera) => void;
-        private _epsilon;
-        private _getAncestorMarginsAndPadding;
+        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;
     }
 
 
     /**
-     * This class represents HTML content that we want to render as though it is part of the scene.  The HTML content is actually
-     * rendered below the canvas, but a depth mask is created by this class that writes to the depth buffer but does not
-     * write to the color buffer, effectively punching a hole in the canvas.  CSS transforms are used to scale, translate, and rotate
-     * the HTML content so that it matches the camera and mesh orientation.  The class supports interactions in editable and non-editable mode.
-     * In non-editable mode (the default), events are passed to the HTML content when the pointer is over the mask (and not occluded by other meshes
-     * in the scene).
-     * @see https://playground.babylonjs.com/#HVHYJC#5
-     * @see https://playground.babylonjs.com/#B17TC7#112
+     * Renders a physically based atmosphere.
+     * Use {@link IsSupported} to check if the atmosphere is supported before creating an instance.
+     * @experimental
      */
-    export class HtmlMesh extends BABYLON.Mesh {
+    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;
         /**
-         * Helps identifying a html mesh from a regular mesh
+         * Checks if the {@link Atmosphere} is supported.
+         * @param engine - The engine to check.
+         * @returns True if the atmosphere is supported, false otherwise.
          */
-        get isHtmlMesh(): boolean;
-        private _enabled;
-        private _ready;
+        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
          */
-        _isCanvasOverlay: boolean;
-        private _requiresUpdate;
-        private _element?;
-        private _width?;
-        private _height?;
-        private _inverseScaleMatrix;
-        private _captureOnPointerEnter;
-        private _pointerEventCaptureBehavior;
-        private _sourceWidth;
-        private _sourceHeight;
+        readonly depthTexture: BABYLON.Nullable<BABYLON.BaseTexture>;
         /**
-         * Return the source width of the content in pixels
+         * Controls the overall brightness of the atmosphere rendering.
          */
-        get sourceWidth(): number | null;
+        get exposure(): number;
+        set exposure(value: number);
         /**
-         * Return the source height of the content in pixels
+         * Affects the overall intensity of the multiple scattering.
          */
-        get sourceHeight(): number | null;
-        private _worldMatrixUpdateObserver;
-        private _fitStrategy;
+        get multiScatteringIntensity(): number;
+        set multiScatteringIntensity(value: number);
         /**
-         * Contruct an instance of HtmlMesh
-         * @param scene
-         * @param id The id of the mesh.  Will be used as the id of the HTML element as well.
-         * @param options object with optional parameters
+         * Affects the multiply scattered light contribution in the atmosphere by describing the average light color reflected off the ground.
          */
-        constructor(scene: BABYLON.Scene, id: string, { captureOnPointerEnter, isCanvasOverlay, fitStrategy }?: {
-            captureOnPointerEnter?: boolean | undefined;
-            isCanvasOverlay?: boolean | undefined;
-            fitStrategy?: FitStrategyType | undefined;
-        });
+        get groundAlbedo(): BABYLON.DeepImmutable<BABYLON.IColor3Like>;
+        set groundAlbedo(value: BABYLON.DeepImmutable<BABYLON.IColor3Like>);
         /**
-         * The width of the content in pixels
+         * Can be used to clamp the multiple scattering to a minimum value.
          */
-        get width(): number | undefined;
+        get minimumMultiScatteringColor(): BABYLON.DeepImmutable<BABYLON.IColor3Like>;
+        set minimumMultiScatteringColor(value: BABYLON.DeepImmutable<BABYLON.IColor3Like>);
         /**
-         * The height of the content in pixels
+         * This is an additional scaling factor applied to the {@link minimumMultiScatteringColor}.
          */
-        get height(): number | undefined;
+        get minimumMultiScatteringIntensity(): number;
+        set minimumMultiScatteringIntensity(value: number);
         /**
-         * The HTML element that is being rendered as a mesh
+         * Can be used to force the diffuse irradiance towards a gray color.
          */
-        get element(): HTMLElement | undefined;
+        get diffuseSkyIrradianceDesaturationFactor(): number;
+        set diffuseSkyIrradianceDesaturationFactor(value: number);
         /**
-         * True if the mesh has been moved, rotated, or scaled since the last time this
-         * property was read.  This property is reset to false after reading.
+         * This is an additional amount of irradiance added to the diffuse irradiance.
          */
-        get requiresUpdate(): boolean;
+        get additionalDiffuseSkyIrradianceIntensity(): number;
+        set additionalDiffuseSkyIrradianceIntensity(value: number);
         /**
-         * Enable capture for the pointer when entering the mesh area
+         * This is the color for the additional amount of irradiance added to the diffuse irradiance.
          */
-        set captureOnPointerEnter(captureOnPointerEnter: boolean);
+        get additionalDiffuseSkyIrradianceColor(): BABYLON.DeepImmutable<BABYLON.IColor3Like>;
+        set additionalDiffuseSkyIrradianceColor(value: BABYLON.DeepImmutable<BABYLON.IColor3Like>);
         /**
-         * Disposes of the mesh and the HTML element
+         * 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;
         /**
-         * @internal
+         * True if the atmosphere is enabled.
+         * @returns - True if the atmosphere is enabled.
          */
-        _markAsUpdated(): void;
+        isEnabled(): boolean;
         /**
-         * Sets the content of the element to the specified content adjusting the mesh scale to match and making it visible.
-         * If the the specified content is undefined, then it will make the mesh invisible.  In either case it will clear the
-         * element content first.
-         * @param element The element to render as a mesh
-         * @param width The width of the mesh in Babylon units
-         * @param height The height of the mesh in Babylon units
+         * Sets the enabled state of the atmosphere.
+         * @param enabled - True to enable the atmosphere, false to disable it.
          */
-        setContent(element: HTMLElement, width: number, height: number): void;
         setEnabled(enabled: boolean): void;
         /**
-         * Sets the content size in pixels
-         * @param width width of the source
-         * @param height height of the source
+         * The class name of the {@link Atmosphere}.
+         * @returns - The class name of the atmosphere.
          */
-        setContentSizePx(width: number, height: number): void;
-        protected _setAsReady(ready: boolean): void;
-        protected _doSetEnabled(enabled: boolean): void;
-        protected _updateScaleIfNecessary(): void;
-        protected _createMask(): void;
-        protected _setElementzIndex(zIndex: number): void;
+        getClassName(): string;
         /**
-         * Callback used by the PointerEventsCaptureBehavior to capture pointer events
+         * 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.
          */
-        capturePointerEvents(): void;
+        getTransmittedColorToRef: <T extends BABYLON.IColor3Like>(directionToLight: BABYLON.IVector3Like, pointRadius: number, pointGeocentricNormal: BABYLON.IVector3Like, result: T) => T;
         /**
-         * Callback used by the PointerEventsCaptureBehavior to release pointer events
+         * 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.
          */
-        releasePointerEvents(): void;
-        protected _createElement(): HTMLDivElement | undefined;
+        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;
     }
 
 
-    export type FitStrategyType = {
-        wrapElement(element: HTMLElement): HTMLElement;
-        updateSize(sizingElement: HTMLElement, width: number, height: number): void;
+    /** @internal */
+    export var transmittancePixelShader: {
+        name: string;
+        shader: string;
     };
-    export var FitStrategy: {
-        CONTAIN: FitStrategyType;
-        COVER: FitStrategyType;
-        STRETCH: FitStrategyType;
-        NONE: FitStrategyType;
+
+
+    /** @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;
     };