@soonspacejs/plugin-atmosphere 2.16.8 → 3.0.0-alpha.0

package/dist/index.d.ts

@@ -1,65 +1,1312 @@
-import { default as SoonSpace, IColor } from 'soonspacejs';
-import { BufferGeometry, CubeCamera, Matrix4, Mesh, Vector3, WebGLCubeRenderTarget } from 'three';
-import { Effect } from 'postprocessing';
-import { AerialPerspectiveEffect, SkyLightProbe, SkyMaterial, SunDirectionalLight, PrecomputedTexturesGenerator, LightingMaskPass } from '@takram/three-atmosphere';
-import { CloudsEffect, CloudsEffectChangeEvent } from '@takram/three-clouds';
-import { ArrayBufferLoader } from '@takram/three-geospatial';
-import { LensFlareEffect, DitheringEffect } from '@takram/three-geospatial-effects';
-type EffectState<T = Effect> = {
-    enabled: boolean;
-    effect: T;
-};
-declare class AtmospherePlugin {
-    readonly ssp: SoonSpace;
-    cacheKey: string;
-    date: Date;
-    longitude: number;
-    latitude: number;
-    altitude: number;
-    distance: number;
-    target: Vector3;
-    ground: boolean;
-    groundAlbedo: IColor;
-    castShadow: boolean;
-    cloudCoverage: number;
-    cloudQuality: 'low' | 'medium' | 'high' | 'ultra';
-    set neesUpdate(value: boolean);
-    atmosphereProps: {
-        inertialToECEFMatrix: Matrix4;
-        sunDirection: Vector3;
-        moonDirection: Vector3;
-        worldToECEFMatrix: Matrix4;
-    };
-    texturesGenerator: PrecomputedTexturesGenerator;
-    arrayBufferLoader: ArrayBufferLoader;
-    skyMaterial: SkyMaterial;
-    skyMesh: Mesh<BufferGeometry, SkyMaterial>;
-    skyLight: SkyLightProbe;
-    sunLight: SunDirectionalLight;
-    aerialPerspectiveEffect: AerialPerspectiveEffect;
-    aerialPerspective: EffectState<AerialPerspectiveEffect>;
-    lensFlareEffect: LensFlareEffect;
-    lensFlare: EffectState<LensFlareEffect>;
-    ditheringEffect: DitheringEffect;
-    dithering: EffectState<DitheringEffect>;
-    lightingMaskPass: LightingMaskPass;
-    cubeRenderTarget: WebGLCubeRenderTarget;
-    cubeCamera: CubeCamera;
-    cloudsEffect: CloudsEffect;
-    clouds: EffectState<CloudsEffect>;
-    _started: boolean;
-    constructor(ssp: SoonSpace);
-    onCloudsChange: (event: CloudsEffectChangeEvent) => void;
-    update: () => void;
-    protected getCacheKey(): string;
-    start(): void;
-    updateModelLightingMask(): void;
-    loadCloudTextures(basePath: string): void;
-    setCloudLayer(options: {
-        coverage?: number;
-        quality?: 'low' | 'medium' | 'high' | 'ultra';
-    }): void;
-    stop(): void;
-    dispose(): void;
-}
-export default AtmospherePlugin;
+import { BlendFunction } from 'postprocessing';
+import { BufferGeometry } from 'three';
+import { Camera } from 'three';
+import { Color } from 'three';
+import { CubeCamera } from 'three';
+import { Data3DTexture } from 'three';
+import { DataArrayTexture } from 'three';
+import { default as default_2 } from 'soonspacejs';
+import { DepthPackingStrategies } from 'three';
+import { DirectionalLight } from 'three';
+import { Effect } from 'postprocessing';
+import { EventDispatcher } from 'three';
+import { FloatType } from 'three';
+import { Group } from 'three';
+import { HalfFloatType } from 'three';
+import { IColor } from 'soonspacejs';
+import { KawaseBlurPass } from 'postprocessing';
+import { LightProbe } from 'three';
+import { Loader } from 'three';
+import { Matrix3 } from 'three';
+import { Matrix4 } from 'three';
+import { Mesh } from 'three';
+import { MipmapBlurPass } from 'postprocessing';
+import { Object3D } from 'three';
+import { Pass } from 'postprocessing';
+import { PerspectiveCamera } from 'three';
+import { RawShaderMaterial } from 'three';
+import { Ray } from 'three';
+import { Resolution } from 'postprocessing';
+import { Scene } from 'three';
+import { Selection as Selection_2 } from 'postprocessing';
+import { ShaderMaterial } from 'three';
+import { ShaderMaterialParameters } from 'three';
+import { ShaderPass } from 'postprocessing';
+import { Texture } from 'three';
+import { TextureDataType } from 'three';
+import { Uniform } from 'three';
+import { Vector2 } from 'three';
+import { Vector3 } from 'three';
+import { Vector4 } from 'three';
+import { WebGL3DRenderTarget } from 'three';
+import { WebGLArrayRenderTarget } from 'three';
+import { WebGLCubeRenderTarget } from 'three';
+import { WebGLProgramParametersWithUniforms } from 'three';
+import { WebGLRenderer } from 'three';
+import { WebGLRenderTarget } from 'three';
+
+declare class AerialPerspectiveEffect extends Effect {
+    private camera;
+    private readonly atmosphere;
+    uniforms: UniformMap<AerialPerspectiveEffectUniforms>;
+    private _ellipsoid;
+    correctAltitude: boolean;
+    overlay: AtmosphereOverlay | null;
+    shadow: AtmosphereShadow | null;
+    shadowLength: AtmosphereShadowLength | null;
+    lightingMask: AtmosphereLightingMask | null;
+    constructor(camera?: Camera, options?: AerialPerspectiveEffectOptions, atmosphere?: AtmosphereParameters);
+    get mainCamera(): Camera;
+    set mainCamera(value: Camera);
+    private copyCameraSettings;
+    private updateOverlay;
+    private updateShadow;
+    private updateShadowLength;
+    private updateLightingMask;
+    update(renderer: WebGLRenderer, inputBuffer: WebGLRenderTarget, deltaTime?: number): void;
+    get normalBuffer(): Texture | null;
+    set normalBuffer(value: Texture | null);
+    octEncodedNormal: boolean;
+    reconstructNormal: boolean;
+    hasNormals: boolean;
+    get irradianceTexture(): Texture | null;
+    set irradianceTexture(value: Texture | null);
+    get scatteringTexture(): Data3DTexture | null;
+    set scatteringTexture(value: Data3DTexture | null);
+    get transmittanceTexture(): Texture | null;
+    set transmittanceTexture(value: Texture | null);
+    /** @private */
+    combinedScatteringTextures: boolean;
+    get singleMieScatteringTexture(): Data3DTexture | null;
+    set singleMieScatteringTexture(value: Data3DTexture | null);
+    /** @private */
+    hasHigherOrderScatteringTexture: boolean;
+    get higherOrderScatteringTexture(): Data3DTexture | null;
+    set higherOrderScatteringTexture(value: Data3DTexture | null);
+    get ellipsoid(): Ellipsoid;
+    set ellipsoid(value: Ellipsoid);
+    get worldToECEFMatrix(): Matrix4;
+    correctGeometricError: boolean;
+    get sunDirection(): Vector3;
+    sunLight: boolean;
+    skyLight: boolean;
+    transmittance: boolean;
+    inscatter: boolean;
+    get albedoScale(): number;
+    set albedoScale(value: number);
+    sky: boolean;
+    sun: boolean;
+    moon: boolean;
+    get moonDirection(): Vector3;
+    get moonAngularRadius(): number;
+    set moonAngularRadius(value: number);
+    get lunarRadianceScale(): number;
+    set lunarRadianceScale(value: number);
+    ground: boolean;
+    get stbnTexture(): Data3DTexture | null;
+    set stbnTexture(value: Data3DTexture | null);
+    get shadowRadius(): number;
+    set shadowRadius(value: number);
+    shadowSampleCount: number;
+}
+
+declare interface AerialPerspectiveEffectOptions {
+    blendFunction?: BlendFunction;
+    normalBuffer?: Texture | null;
+    octEncodedNormal?: boolean;
+    reconstructNormal?: boolean;
+    irradianceTexture?: Texture | null;
+    scatteringTexture?: Data3DTexture | null;
+    transmittanceTexture?: Texture | null;
+    singleMieScatteringTexture?: Data3DTexture | null;
+    higherOrderScatteringTexture?: Data3DTexture | null;
+    ellipsoid?: Ellipsoid;
+    correctAltitude?: boolean;
+    correctGeometricError?: boolean;
+    sunDirection?: Vector3;
+    sunLight?: boolean;
+    skyLight?: boolean;
+    transmittance?: boolean;
+    inscatter?: boolean;
+    albedoScale?: number;
+    sky?: boolean;
+    sun?: boolean;
+    moon?: boolean;
+    moonDirection?: Vector3;
+    moonAngularRadius?: number;
+    lunarRadianceScale?: number;
+    ground?: boolean;
+}
+
+declare interface AerialPerspectiveEffectUniforms {
+    normalBuffer: Uniform<Texture | null>;
+    projectionMatrix: Uniform<Matrix4>;
+    viewMatrix: Uniform<Matrix4>;
+    inverseProjectionMatrix: Uniform<Matrix4>;
+    inverseViewMatrix: Uniform<Matrix4>;
+    cameraPosition: Uniform<Vector3>;
+    bottomRadius: Uniform<number>;
+    ellipsoidRadii: Uniform<Vector3>;
+    worldToECEFMatrix: Uniform<Matrix4>;
+    altitudeCorrection: Uniform<Vector3>;
+    geometricErrorCorrectionAmount: Uniform<number>;
+    sunDirection: Uniform<Vector3>;
+    albedoScale: Uniform<number>;
+    moonDirection: Uniform<Vector3>;
+    moonAngularRadius: Uniform<number>;
+    lunarRadianceScale: Uniform<number>;
+    overlayBuffer: Uniform<Texture | null>;
+    shadowBuffer: Uniform<Texture | null>;
+    shadowMapSize: Uniform<Vector2>;
+    shadowIntervals: Uniform<Vector2[]>;
+    shadowMatrices: Uniform<Matrix4[]>;
+    inverseShadowMatrices: Uniform<Matrix4[]>;
+    shadowFar: Uniform<number>;
+    shadowTopHeight: Uniform<number>;
+    shadowRadius: Uniform<number>;
+    stbnTexture: Uniform<Data3DTexture | null>;
+    frame: Uniform<number>;
+    shadowLengthBuffer: Uniform<Texture | null>;
+    lightingMaskBuffer: Uniform<Texture | null>;
+    ATMOSPHERE: AtmosphereParametersUniform;
+    SUN_SPECTRAL_RADIANCE_TO_LUMINANCE: Uniform<Vector3>;
+    SKY_SPECTRAL_RADIANCE_TO_LUMINANCE: Uniform<Vector3>;
+    irradiance_texture: Uniform<Texture | null>;
+    scattering_texture: Uniform<Data3DTexture | null>;
+    transmittance_texture: Uniform<Texture | null>;
+    single_mie_scattering_texture: Uniform<Data3DTexture | null>;
+    higher_order_scattering_texture: Uniform<Data3DTexture | null>;
+}
+
+declare type AnyFloatType = typeof FloatType | typeof HalfFloatType;
+
+declare class ArrayBufferLoader extends Loader<ArrayBuffer> {
+    load(url: string, onLoad: (data: ArrayBuffer) => void, onProgress?: (event: ProgressEvent) => void, onError?: (error: unknown) => void): void;
+}
+
+declare interface AtmosphereLightingMask {
+    map: Texture;
+    channel: 'r' | 'g' | 'b' | 'a';
+}
+
+declare abstract class AtmosphereMaterialBase extends RawShaderMaterial {
+    protected readonly atmosphere: AtmosphereParameters;
+    uniforms: AtmosphereMaterialBaseUniforms;
+    ellipsoid: Ellipsoid;
+    correctAltitude: boolean;
+    private _renderTargetCount;
+    constructor(params?: AtmosphereMaterialBaseParameters, atmosphere?: AtmosphereParameters);
+    copyCameraSettings(camera: Camera): void;
+    onBeforeCompile(parameters: WebGLProgramParametersWithUniforms, renderer: WebGLRenderer): void;
+    onBeforeRender(renderer: WebGLRenderer, scene: Scene, camera: Camera, geometry: BufferGeometry, object: Object3D, group: Group): void;
+    get irradianceTexture(): Texture | null;
+    set irradianceTexture(value: Texture | null);
+    get scatteringTexture(): Data3DTexture | null;
+    set scatteringTexture(value: Data3DTexture | null);
+    get transmittanceTexture(): Texture | null;
+    set transmittanceTexture(value: Texture | null);
+    /** @private */
+    combinedScatteringTextures: boolean;
+    get singleMieScatteringTexture(): Data3DTexture | null;
+    set singleMieScatteringTexture(value: Data3DTexture | null);
+    /** @private */
+    hasHigherOrderScatteringTexture: boolean;
+    get higherOrderScatteringTexture(): Data3DTexture | null;
+    set higherOrderScatteringTexture(value: Data3DTexture | null);
+    get worldToECEFMatrix(): Matrix4;
+    get sunDirection(): Vector3;
+    get sunAngularRadius(): number;
+    set sunAngularRadius(value: number);
+    /** @package */
+    get renderTargetCount(): number;
+    /** @package */
+    set renderTargetCount(value: number);
+}
+
+declare interface AtmosphereMaterialBaseParameters extends Partial<ShaderMaterialParameters>, AtmosphereMaterialProps {
+}
+
+declare interface AtmosphereMaterialBaseUniforms {
+    [key: string]: Uniform<unknown>;
+    cameraPosition: Uniform<Vector3>;
+    worldToECEFMatrix: Uniform<Matrix4>;
+    altitudeCorrection: Uniform<Vector3>;
+    sunDirection: Uniform<Vector3>;
+    ATMOSPHERE: AtmosphereParametersUniform;
+    SUN_SPECTRAL_RADIANCE_TO_LUMINANCE: Uniform<Vector3>;
+    SKY_SPECTRAL_RADIANCE_TO_LUMINANCE: Uniform<Vector3>;
+    irradiance_texture: Uniform<Texture | null>;
+    scattering_texture: Uniform<Data3DTexture | null>;
+    transmittance_texture: Uniform<Texture | null>;
+    single_mie_scattering_texture: Uniform<Data3DTexture | null>;
+    higher_order_scattering_texture: Uniform<Data3DTexture | null>;
+}
+
+declare interface AtmosphereMaterialProps {
+    irradianceTexture?: Texture | null;
+    scatteringTexture?: Data3DTexture | null;
+    transmittanceTexture?: Texture | null;
+    singleMieScatteringTexture?: Data3DTexture | null;
+    higherOrderScatteringTexture?: Data3DTexture | null;
+    ellipsoid?: Ellipsoid;
+    correctAltitude?: boolean;
+    sunDirection?: Vector3;
+    sunAngularRadius?: number;
+    ground?: boolean;
+    renderTargetCount?: number;
+}
+
+declare interface AtmosphereOverlay {
+    map: Texture;
+}
+
+declare class AtmosphereParameters {
+    static readonly DEFAULT: AtmosphereParameters;
+    solarIrradiance: Vector3;
+    sunAngularRadius: number;
+    bottomRadius: number;
+    topRadius: number;
+    rayleighDensity: DensityProfile;
+    rayleighScattering: Vector3;
+    mieDensity: DensityProfile;
+    mieScattering: Vector3;
+    mieExtinction: Vector3;
+    miePhaseFunctionG: number;
+    absorptionDensity: DensityProfile;
+    absorptionExtinction: Vector3;
+    groundAlbedo: Color;
+    muSMin: number;
+    sunRadianceToLuminance: Vector3;
+    skyRadianceToLuminance: Vector3;
+    sunRadianceToRelativeLuminance: Vector3;
+    skyRadianceToRelativeLuminance: Vector3;
+    constructor(options?: AtmosphereParametersOptions);
+    toUniform(): Uniform<{
+        solar_irradiance: Vector3;
+        sun_angular_radius: number;
+        bottom_radius: number;
+        top_radius: number;
+        rayleigh_density: {
+            layers: {
+                width: number;
+                exp_term: number;
+                exp_scale: number;
+                linear_term: number;
+                constant_term: number;
+            }[];
+        };
+        rayleigh_scattering: Vector3;
+        mie_density: {
+            layers: {
+                width: number;
+                exp_term: number;
+                exp_scale: number;
+                linear_term: number;
+                constant_term: number;
+            }[];
+        };
+        mie_scattering: Vector3;
+        mie_extinction: Vector3;
+        mie_phase_function_g: number;
+        absorption_density: {
+            layers: {
+                width: number;
+                exp_term: number;
+                exp_scale: number;
+                linear_term: number;
+                constant_term: number;
+            }[];
+        };
+        absorption_extinction: Vector3;
+        ground_albedo: Color;
+        mu_s_min: number;
+    }>;
+}
+
+declare interface AtmosphereParametersOptions extends Partial<Pick<AtmosphereParameters, (typeof paramKeys)[number]>> {
+}
+
+declare type AtmosphereParametersUniform = ReturnType<AtmosphereParameters['toUniform']>;
+
+declare class AtmospherePlugin {
+    readonly ssp: default_2;
+    cacheKey: string;
+    date: Date;
+    longitude: number;
+    latitude: number;
+    altitude: number;
+    distance: number;
+    target: Vector3;
+    ground: boolean;
+    groundAlbedo: IColor;
+    castShadow: boolean;
+    cloudCoverage: number;
+    cloudQuality: 'low' | 'medium' | 'high' | 'ultra';
+    set neesUpdate(value: boolean);
+    atmosphereProps: {
+        inertialToECEFMatrix: Matrix4;
+        sunDirection: Vector3;
+        moonDirection: Vector3;
+        worldToECEFMatrix: Matrix4;
+    };
+    texturesGenerator: PrecomputedTexturesGenerator;
+    arrayBufferLoader: ArrayBufferLoader;
+    skyMaterial: SkyMaterial;
+    skyMesh: Mesh<BufferGeometry, SkyMaterial>;
+    skyLight: SkyLightProbe;
+    sunLight: SunDirectionalLight;
+    aerialPerspectiveEffect: AerialPerspectiveEffect;
+    aerialPerspective: EffectState<AerialPerspectiveEffect>;
+    lensFlareEffect: LensFlareEffect;
+    lensFlare: EffectState<LensFlareEffect>;
+    ditheringEffect: DitheringEffect;
+    dithering: EffectState<DitheringEffect>;
+    lightingMaskPass: LightingMaskPass;
+    cubeRenderTarget: WebGLCubeRenderTarget;
+    cubeCamera: CubeCamera;
+    cloudsEffect: CloudsEffect;
+    clouds: EffectState<CloudsEffect>;
+    _started: boolean;
+    constructor(ssp: default_2);
+    onCloudsChange: (event: CloudsEffectChangeEvent) => void;
+    update: () => void;
+    protected getCacheKey(): string;
+    start(): void;
+    updateModelLightingMask(): void;
+    loadCloudTextures(basePath: string): void;
+    setCloudLayer(options: {
+        coverage?: number;
+        quality?: 'low' | 'medium' | 'high' | 'ultra';
+    }): void;
+    stop(): void;
+    dispose(): void;
+}
+export default AtmospherePlugin;
+
+declare interface AtmosphereShadow {
+    map: DataArrayTexture;
+    mapSize: Vector2;
+    cascadeCount: number;
+    intervals: Vector2[];
+    matrices: Matrix4[];
+    inverseMatrices: Matrix4[];
+    far: number;
+    topHeight: number;
+}
+
+declare interface AtmosphereShadowLength {
+    map: Texture;
+}
+
+declare interface AtmosphereUniforms {
+    bottomRadius: Uniform<number>;
+    topRadius: Uniform<number>;
+    worldToECEFMatrix: Uniform<Matrix4>;
+    ecefToWorldMatrix: Uniform<Matrix4>;
+    altitudeCorrection: Uniform<Vector3>;
+    sunDirection: Uniform<Vector3>;
+}
+
+declare interface Cascade {
+    readonly interval: Vector2;
+    readonly matrix: Matrix4;
+    readonly inverseMatrix: Matrix4;
+    readonly projectionMatrix: Matrix4;
+    readonly inverseProjectionMatrix: Matrix4;
+    readonly viewMatrix: Matrix4;
+    readonly inverseViewMatrix: Matrix4;
+}
+
+declare class CascadedShadowMaps {
+    readonly cascades: Cascade[];
+    readonly mapSize: Vector2;
+    maxFar: number | null;
+    farScale: number;
+    splitMode: FrustumSplitMode;
+    splitLambda: number;
+    margin: number;
+    fade: boolean;
+    private readonly cameraFrustum;
+    private readonly frusta;
+    private readonly splits;
+    private _far;
+    constructor(options: CascadedShadowMapsOptions);
+    get cascadeCount(): number;
+    set cascadeCount(value: number);
+    get far(): number;
+    private updateIntervals;
+    private getFrustumRadius;
+    private updateMatrices;
+    update(camera: PerspectiveCamera, sunDirection: Vector3, distance?: number): void;
+}
+
+declare interface CascadedShadowMapsOptions {
+    cascadeCount: number;
+    mapSize: Vector2;
+    maxFar?: number | null;
+    farScale?: number;
+    splitMode?: FrustumSplitMode;
+    splitLambda?: number;
+    margin?: number;
+    fade?: boolean;
+}
+
+declare class CloudLayer {
+    static readonly DEFAULT: CloudLayer;
+    channel: TextureChannel;
+    altitude: number;
+    height: number;
+    densityScale: number;
+    shapeAmount: number;
+    shapeDetailAmount: number;
+    weatherExponent: number;
+    shapeAlteringBias: number;
+    coverageFilterWidth: number;
+    densityProfile: DensityProfile_2;
+    shadow: boolean;
+    constructor(options?: CloudLayerLike);
+    set(options?: CloudLayerLike): this;
+    clone(): CloudLayer;
+    copy(other: CloudLayer): this;
+}
+
+declare interface CloudLayerLike extends Partial<Pick<CloudLayer, Exclude<(typeof paramKeys_2)[number], 'densityProfile'>>> {
+    densityProfile?: DensityProfileLike;
+}
+
+declare class CloudLayers extends Array<CloudLayer> {
+    static readonly DEFAULT: CloudLayers;
+    constructor(options?: readonly CloudLayerLike[]);
+    set(options?: readonly CloudLayerLike[]): this;
+    reset(): this;
+    clone(): CloudLayers;
+    copy(other: CloudLayers): this;
+    get localWeatherChannels(): string;
+    packValues<K extends NumericKey>(key: K, result: Vector4): Vector4;
+    packSums<A extends NumericKey, B extends NumericKey>(a: A, b: B, result: Vector4): Vector4;
+    packDensityProfiles<K extends keyof DensityProfileLike>(key: K, result: Vector4): Vector4;
+    packIntervalHeights(minIntervals: Vector3, maxIntervals: Vector3): void;
+}
+
+declare interface CloudLayerUniforms {
+    minLayerHeights: Uniform<Vector4>;
+    maxLayerHeights: Uniform<Vector4>;
+    minIntervalHeights: Uniform<Vector3>;
+    maxIntervalHeights: Uniform<Vector3>;
+    densityScales: Uniform<Vector4>;
+    shapeAmounts: Uniform<Vector4>;
+    shapeDetailAmounts: Uniform<Vector4>;
+    weatherExponents: Uniform<Vector4>;
+    shapeAlteringBiases: Uniform<Vector4>;
+    coverageFilterWidths: Uniform<Vector4>;
+    minHeight: Uniform<number>;
+    maxHeight: Uniform<number>;
+    shadowTopHeight: Uniform<number>;
+    shadowBottomHeight: Uniform<number>;
+    shadowLayerMask: Uniform<Vector4>;
+    densityProfile: Uniform<DensityProfileVectors>;
+}
+
+declare interface CloudParameterUniforms {
+    scatteringCoefficient: Uniform<number>;
+    absorptionCoefficient: Uniform<number>;
+    coverage: Uniform<number>;
+    localWeatherTexture: Uniform<Texture | null>;
+    localWeatherRepeat: Uniform<Vector2>;
+    localWeatherOffset: Uniform<Vector2>;
+    shapeTexture: Uniform<Data3DTexture | null>;
+    shapeRepeat: Uniform<Vector3>;
+    shapeOffset: Uniform<Vector3>;
+    shapeDetailTexture: Uniform<Data3DTexture | null>;
+    shapeDetailRepeat: Uniform<Vector3>;
+    shapeDetailOffset: Uniform<Vector3>;
+    turbulenceTexture: Uniform<Texture | null>;
+    turbulenceRepeat: Uniform<Vector2>;
+    turbulenceDisplacement: Uniform<number>;
+}
+
+declare class CloudsEffect extends Effect {
+    private camera;
+    private readonly atmosphere;
+    uniforms: UniformMap<CloudsEffectUniforms>;
+    readonly cloudLayers: CloudLayers;
+    correctAltitude: boolean;
+    readonly localWeatherRepeat: Vector2;
+    readonly localWeatherOffset: Vector2;
+    readonly shapeRepeat: Vector3;
+    readonly shapeOffset: Vector3;
+    readonly shapeDetailRepeat: Vector3;
+    readonly shapeDetailOffset: Vector3;
+    readonly turbulenceRepeat: Vector2;
+    readonly worldToECEFMatrix: Matrix4;
+    private readonly ecefToWorldMatrix;
+    private readonly altitudeCorrection;
+    readonly sunDirection: Vector3;
+    private readonly parameterUniforms;
+    private readonly layerUniforms;
+    private readonly atmosphereUniforms;
+    readonly localWeatherVelocity: Vector2;
+    readonly shapeVelocity: Vector3;
+    readonly shapeDetailVelocity: Vector3;
+    private proceduralLocalWeather?;
+    private proceduralShape?;
+    private proceduralShapeDetail?;
+    private proceduralTurbulence?;
+    readonly shadowMaps: CascadedShadowMaps;
+    readonly shadowPass: ShadowPass;
+    readonly cloudsPass: CloudsPass;
+    readonly clouds: CloudsShorthand;
+    readonly shadow: ShadowShorthand;
+    private _atmosphereOverlay;
+    private _atmosphereShadow;
+    private _atmosphereShadowLength;
+    readonly resolution: Resolution;
+    readonly events: EventDispatcher<{
+        change: CloudsEffectChangeEvent;
+    }>;
+    private frame;
+    private shadowCascadeCount;
+    private readonly shadowMapSize;
+    constructor(camera?: Camera, options?: CloudsEffectOptions, atmosphere?: AtmosphereParameters);
+    private readonly onResolutionChange;
+    get mainCamera(): Camera;
+    set mainCamera(value: Camera);
+    initialize(renderer: WebGLRenderer, alpha: boolean, frameBufferType: TextureDataType): void;
+    private updateSharedUniforms;
+    private updateWeatherTextureChannels;
+    private updateAtmosphereComposition;
+    update(renderer: WebGLRenderer, inputBuffer: WebGLRenderTarget, deltaTime?: number): void;
+    setSize(baseWidth: number, baseHeight: number): void;
+    setDepthTexture(depthTexture: Texture, depthPacking?: DepthPackingStrategies): void;
+    skipRendering: boolean;
+    set qualityPreset(value: QualityPreset);
+    get localWeatherTexture(): Texture | ProceduralTexture | null;
+    set localWeatherTexture(value: Texture | ProceduralTexture | null);
+    get shapeTexture(): Data3DTexture | Procedural3DTexture | null;
+    set shapeTexture(value: Data3DTexture | Procedural3DTexture | null);
+    get shapeDetailTexture(): Data3DTexture | Procedural3DTexture | null;
+    set shapeDetailTexture(value: Data3DTexture | Procedural3DTexture | null);
+    get turbulenceTexture(): Texture | ProceduralTexture | null;
+    set turbulenceTexture(value: Texture | ProceduralTexture | null);
+    get stbnTexture(): Data3DTexture | null;
+    set stbnTexture(value: Data3DTexture | null);
+    get resolutionScale(): number;
+    set resolutionScale(value: number);
+    get temporalUpscale(): boolean;
+    set temporalUpscale(value: boolean);
+    get lightShafts(): boolean;
+    set lightShafts(value: boolean);
+    get shapeDetail(): boolean;
+    set shapeDetail(value: boolean);
+    get turbulence(): boolean;
+    set turbulence(value: boolean);
+    get haze(): boolean;
+    set haze(value: boolean);
+    get scatteringCoefficient(): number;
+    set scatteringCoefficient(value: number);
+    get absorptionCoefficient(): number;
+    set absorptionCoefficient(value: number);
+    get coverage(): number;
+    set coverage(value: number);
+    get turbulenceDisplacement(): number;
+    set turbulenceDisplacement(value: number);
+    get scatterAnisotropy1(): number;
+    set scatterAnisotropy1(value: number);
+    get scatterAnisotropy2(): number;
+    set scatterAnisotropy2(value: number);
+    get scatterAnisotropyMix(): number;
+    set scatterAnisotropyMix(value: number);
+    get skyLightScale(): number;
+    set skyLightScale(value: number);
+    get groundBounceScale(): number;
+    set groundBounceScale(value: number);
+    get powderScale(): number;
+    set powderScale(value: number);
+    get powderExponent(): number;
+    set powderExponent(value: number);
+    get atmosphereOverlay(): AtmosphereOverlay | null;
+    get atmosphereShadow(): AtmosphereShadow | null;
+    get atmosphereShadowLength(): AtmosphereShadowLength | null;
+    get irradianceTexture(): Texture | null;
+    set irradianceTexture(value: Texture | null);
+    get scatteringTexture(): Data3DTexture | null;
+    set scatteringTexture(value: Data3DTexture | null);
+    get transmittanceTexture(): Texture | null;
+    set transmittanceTexture(value: Texture | null);
+    get singleMieScatteringTexture(): Data3DTexture | null;
+    set singleMieScatteringTexture(value: Data3DTexture | null);
+    get higherOrderScatteringTexture(): Data3DTexture | null;
+    set higherOrderScatteringTexture(value: Data3DTexture | null);
+    get ellipsoid(): Ellipsoid;
+    set ellipsoid(value: Ellipsoid);
+    get sunAngularRadius(): number;
+    set sunAngularRadius(value: number);
+}
+
+declare interface CloudsEffectChangeEvent {
+    type: 'change';
+    target?: CloudsEffect;
+    property?: 'atmosphereOverlay' | 'atmosphereShadow' | 'atmosphereShadowLength';
+}
+
+declare interface CloudsEffectOptions {
+    resolutionScale?: number;
+    width?: number;
+    height?: number;
+    resolutionX?: number;
+    resolutionY?: number;
+}
+
+declare interface CloudsEffectUniforms {
+    cloudsBuffer: Uniform<Texture | null>;
+}
+
+declare class CloudsMaterial extends AtmosphereMaterialBase {
+    uniforms: AtmosphereMaterialBaseUniforms & CloudsMaterialUniforms;
+    temporalUpscale: boolean;
+    private previousProjectionMatrix?;
+    private previousViewMatrix?;
+    constructor({ parameterUniforms, layerUniforms, atmosphereUniforms }: CloudsMaterialParameters, atmosphere?: AtmosphereParameters);
+    onBeforeRender(renderer: WebGLRenderer, scene: Scene, camera: Camera, geometry: BufferGeometry, object: Object3D, group: Group): void;
+    copyCameraSettings(camera: Camera): void;
+    copyReprojectionMatrix(camera: Camera): void;
+    setSize(width: number, height: number, targetWidth?: number, targetHeight?: number): void;
+    setShadowSize(width: number, height: number): void;
+    get depthBuffer(): Texture | null;
+    set depthBuffer(value: Texture | null);
+    depthPacking: number;
+    localWeatherChannels: string;
+    shapeDetail: boolean;
+    turbulence: boolean;
+    shadowLength: boolean;
+    haze: boolean;
+    multiScatteringOctaves: number;
+    accurateSunSkyLight: boolean;
+    accuratePhaseFunction: boolean;
+    shadowCascadeCount: number;
+    shadowSampleCount: number;
+    scatterAnisotropy1: number;
+    scatterAnisotropy2: number;
+    scatterAnisotropyMix: number;
+}
+
+declare const cloudsMaterialParameterKeys: ["multiScatteringOctaves", "accurateSunSkyLight", "accuratePhaseFunction"];
+
+declare interface CloudsMaterialParameters {
+    parameterUniforms: CloudParameterUniforms;
+    layerUniforms: CloudLayerUniforms;
+    atmosphereUniforms: AtmosphereUniforms;
+}
+
+declare interface CloudsMaterialUniforms extends CloudParameterUniforms, CloudLayerUniforms, AtmosphereUniforms {
+    depthBuffer: Uniform<Texture | null>;
+    viewMatrix: Uniform<Matrix4>;
+    inverseProjectionMatrix: Uniform<Matrix4>;
+    inverseViewMatrix: Uniform<Matrix4>;
+    reprojectionMatrix: Uniform<Matrix4>;
+    viewReprojectionMatrix: Uniform<Matrix4>;
+    resolution: Uniform<Vector2>;
+    cameraNear: Uniform<number>;
+    cameraFar: Uniform<number>;
+    cameraHeight: Uniform<number>;
+    frame: Uniform<number>;
+    temporalJitter: Uniform<Vector2>;
+    targetUvScale: Uniform<Vector2>;
+    mipLevelScale: Uniform<number>;
+    stbnTexture: Uniform<Data3DTexture | null>;
+    skyLightScale: Uniform<number>;
+    groundBounceScale: Uniform<number>;
+    powderScale: Uniform<number>;
+    powderExponent: Uniform<number>;
+    maxIterationCount: Uniform<number>;
+    minStepSize: Uniform<number>;
+    maxStepSize: Uniform<number>;
+    maxRayDistance: Uniform<number>;
+    perspectiveStepScale: Uniform<number>;
+    minDensity: Uniform<number>;
+    minExtinction: Uniform<number>;
+    minTransmittance: Uniform<number>;
+    maxIterationCountToSun: Uniform<number>;
+    maxIterationCountToGround: Uniform<number>;
+    minSecondaryStepSize: Uniform<number>;
+    secondaryStepScale: Uniform<number>;
+    shadowBuffer: Uniform<DataArrayTexture | null>;
+    shadowTexelSize: Uniform<Vector2>;
+    shadowIntervals: Uniform<Vector2[]>;
+    shadowMatrices: Uniform<Matrix4[]>;
+    shadowFar: Uniform<number>;
+    maxShadowFilterRadius: Uniform<number>;
+    maxShadowLengthIterationCount: Uniform<number>;
+    minShadowLengthStepSize: Uniform<number>;
+    maxShadowLengthRayDistance: Uniform<number>;
+    hazeDensityScale: Uniform<number>;
+    hazeExponent: Uniform<number>;
+    hazeScatteringCoefficient: Uniform<number>;
+    hazeAbsorptionCoefficient: Uniform<number>;
+}
+
+declare class CloudsPass extends PassBase {
+    private readonly atmosphere;
+    private currentRenderTarget;
+    readonly currentMaterial: CloudsMaterial;
+    readonly currentPass: ShaderPass;
+    private resolveRenderTarget;
+    readonly resolveMaterial: CloudsResolveMaterial;
+    readonly resolvePass: ShaderPass;
+    private historyRenderTarget;
+    private width;
+    private height;
+    constructor({ parameterUniforms, layerUniforms, atmosphereUniforms, ...options }: CloudsPassOptions, atmosphere: AtmosphereParameters);
+    copyCameraSettings(camera: Camera): void;
+    initialize(renderer: WebGLRenderer, alpha: boolean, frameBufferType: TextureDataType): void;
+    private initRenderTargets;
+    private copyShadow;
+    private copyReprojection;
+    private swapBuffers;
+    update(renderer: WebGLRenderer, frame: number, deltaTime: number): void;
+    setSize(width: number, height: number): void;
+    setShadowSize(width: number, height: number, depth: number): void;
+    setDepthTexture(depthTexture: Texture, depthPacking?: DepthPackingStrategies): void;
+    get outputBuffer(): Texture;
+    get shadowBuffer(): DataArrayTexture | null;
+    set shadowBuffer(value: DataArrayTexture | null);
+    get shadowLengthBuffer(): Texture | null;
+    get temporalUpscale(): boolean;
+    set temporalUpscale(value: boolean);
+    get lightShafts(): boolean;
+    set lightShafts(value: boolean);
+}
+
+declare interface CloudsPassOptions extends PassBaseOptions {
+    parameterUniforms: CloudParameterUniforms;
+    layerUniforms: CloudLayerUniforms;
+    atmosphereUniforms: AtmosphereUniforms;
+}
+
+declare class CloudsResolveMaterial extends RawShaderMaterial {
+    uniforms: CloudsResolveMaterialUniforms;
+    constructor({ colorBuffer, depthVelocityBuffer, shadowLengthBuffer, colorHistoryBuffer, shadowLengthHistoryBuffer }?: CloudsResolveMaterialParameters);
+    setSize(width: number, height: number): void;
+    onBeforeRender(renderer: WebGLRenderer, scene: Scene, camera: Camera, geometry: BufferGeometry, object: Object3D, group: Group): void;
+    temporalUpscale: boolean;
+    shadowLength: boolean;
+}
+
+declare interface CloudsResolveMaterialParameters {
+    colorBuffer?: Texture | null;
+    depthVelocityBuffer?: Texture | null;
+    shadowLengthBuffer?: Texture | null;
+    colorHistoryBuffer?: Texture | null;
+    shadowLengthHistoryBuffer?: Texture | null;
+}
+
+declare interface CloudsResolveMaterialUniforms {
+    [key: string]: Uniform<unknown>;
+    colorBuffer: Uniform<Texture | null>;
+    depthVelocityBuffer: Uniform<Texture | null>;
+    shadowLengthBuffer: Uniform<Texture | null>;
+    colorHistoryBuffer: Uniform<Texture | null>;
+    shadowLengthHistoryBuffer: Uniform<Texture | null>;
+    texelSize: Uniform<Vector2>;
+    frame: Uniform<number>;
+    jitterOffset: Uniform<Vector2>;
+    varianceGamma: Uniform<number>;
+    temporalAlpha: Uniform<number>;
+}
+
+declare interface CloudsShorthand extends UniformShorthand<CloudsMaterial, (typeof cloudsUniformKeys)[number]>, PropertyShorthand<[CloudsMaterial, typeof cloudsMaterialParameterKeys]> {
+}
+
+declare const cloudsUniformKeys: ["maxIterationCount", "minStepSize", "maxStepSize", "maxRayDistance", "perspectiveStepScale", "minDensity", "minExtinction", "minTransmittance", "maxIterationCountToSun", "maxIterationCountToGround", "minSecondaryStepSize", "secondaryStepScale", "maxShadowFilterRadius", "maxShadowLengthIterationCount", "minShadowLengthStepSize", "maxShadowLengthRayDistance", "hazeDensityScale", "hazeExponent", "hazeScatteringCoefficient", "hazeAbsorptionCoefficient"];
+
+declare class Context {
+    lambdas: Vector3;
+    luminanceFromRadiance: Matrix3;
+    opticalDepth?: WebGLRenderTarget;
+    deltaIrradiance: WebGLRenderTarget;
+    deltaRayleighScattering: WebGL3DRenderTarget;
+    deltaMieScattering: WebGL3DRenderTarget;
+    deltaScatteringDensity: WebGL3DRenderTarget;
+    deltaMultipleScattering: WebGL3DRenderTarget;
+    constructor(type: AnyFloatType);
+    dispose(): void;
+}
+
+declare type DensityProfile = [DensityProfileLayer, DensityProfileLayer];
+
+declare class DensityProfile_2 {
+    expTerm: number;
+    exponent: number;
+    linearTerm: number;
+    constantTerm: number;
+    constructor(expTerm?: number, exponent?: number, linearTerm?: number, constantTerm?: number);
+    set(expTerm?: number, exponent?: number, linearTerm?: number, constantTerm?: number): this;
+    clone(): DensityProfile_2;
+    copy(other: DensityProfile_2): this;
+}
+
+declare class DensityProfileLayer {
+    width: number;
+    expTerm: number;
+    expScale: number;
+    linearTerm: number;
+    constantTerm: number;
+    constructor(width: number, expTerm: number, expScale: number, linearTerm: number, constantTerm: number);
+    toUniform(): Uniform<{
+        width: number;
+        exp_term: number;
+        exp_scale: number;
+        linear_term: number;
+        constant_term: number;
+    }>;
+}
+
+declare interface DensityProfileLike extends Partial<Pick<DensityProfile_2, 'expTerm' | 'exponent' | 'linearTerm' | 'constantTerm'>> {
+}
+
+declare interface DensityProfileVectors {
+    expTerms: Vector4;
+    exponents: Vector4;
+    linearTerms: Vector4;
+    constantTerms: Vector4;
+}
+
+declare class DitheringEffect extends Effect {
+    constructor(options?: DitheringEffectOptions);
+}
+
+declare interface DitheringEffectOptions {
+    blendFunction?: BlendFunction;
+}
+
+declare class DownsampleThresholdMaterial extends ShaderMaterial {
+    constructor(params?: DownsampleThresholdMaterialParameters);
+    setSize(width: number, height: number): void;
+    get inputBuffer(): Texture | null;
+    set inputBuffer(value: Texture | null);
+    get thresholdLevel(): number;
+    set thresholdLevel(value: number);
+    get thresholdRange(): number;
+    set thresholdRange(value: number);
+}
+
+declare interface DownsampleThresholdMaterialParameters extends ShaderMaterialParameters {
+    inputBuffer?: Texture | null;
+    thresholdLevel?: number;
+    thresholdRange?: number;
+}
+
+declare type EffectState<T = Effect> = {
+    enabled: boolean;
+    effect: T;
+};
+
+declare class Ellipsoid {
+    static readonly WGS84: Ellipsoid;
+    readonly radii: Vector3;
+    constructor(x: number, y: number, z: number);
+    get minimumRadius(): number;
+    get maximumRadius(): number;
+    get flattening(): number;
+    get eccentricity(): number;
+    get eccentricitySquared(): number;
+    reciprocalRadii(result?: Vector3): Vector3;
+    reciprocalRadiiSquared(result?: Vector3): Vector3;
+    projectOnSurface(position: Vector3, result?: Vector3, options?: ProjectOnEllipsoidSurfaceOptions): Vector3 | undefined;
+    getSurfaceNormal(position: Vector3, result?: Vector3): Vector3;
+    getEastNorthUpVectors(position: Vector3, east?: Vector3, north?: Vector3, up?: Vector3): void;
+    getEastNorthUpFrame(position: Vector3, result?: Matrix4): Matrix4;
+    getNorthUpEastFrame(position: Vector3, result?: Matrix4): Matrix4;
+    getIntersection(ray: Ray, result?: Vector3): Vector3 | undefined;
+    getOsculatingSphereCenter(surfacePosition: Vector3, radius: number, result?: Vector3): Vector3;
+    getNormalAtHorizon(position: Vector3, direction: Vector3, result?: Vector3): Vector3;
+}
+
+declare type FrustumSplitFunction = (length: number, near: number, far: number, lambda?: number, result?: number[]) => number[];
+
+declare interface FrustumSplitFunctions {
+    uniform: FrustumSplitFunction;
+    logarithmic: FrustumSplitFunction;
+    practical: FrustumSplitFunction;
+}
+
+declare type FrustumSplitMode = keyof FrustumSplitFunctions;
+
+declare class LensFlareEffect extends Effect {
+    uniforms: UniformMap<LensFlareEffectUniforms>;
+    readonly resolution: Resolution;
+    readonly renderTarget1: WebGLRenderTarget;
+    readonly renderTarget2: WebGLRenderTarget;
+    readonly thresholdMaterial: DownsampleThresholdMaterial;
+    readonly thresholdPass: ShaderPass;
+    readonly blurPass: MipmapBlurPass;
+    readonly preBlurPass: KawaseBlurPass;
+    readonly featuresMaterial: LensFlareFeaturesMaterial;
+    readonly featuresPass: ShaderPass;
+    constructor(options?: LensFlareEffectOptions);
+    private readonly onResolutionChange;
+    initialize(renderer: WebGLRenderer, alpha: boolean, frameBufferType: TextureDataType): void;
+    update(renderer: WebGLRenderer, inputBuffer: WebGLRenderTarget, deltaTime?: number): void;
+    setSize(baseWidth: number, baseHeight: number): void;
+    get intensity(): number;
+    set intensity(value: number);
+    get thresholdLevel(): number;
+    set thresholdLevel(value: number);
+    get thresholdRange(): number;
+    set thresholdRange(value: number);
+}
+
+declare interface LensFlareEffectOptions {
+    blendFunction?: BlendFunction;
+    resolutionScale?: number;
+    width?: number;
+    height?: number;
+    resolutionX?: number;
+    resolutionY?: number;
+    intensity?: number;
+}
+
+declare interface LensFlareEffectUniforms {
+    bloomBuffer: Uniform<Texture | null>;
+    featuresBuffer: Uniform<Texture | null>;
+    intensity: Uniform<number>;
+}
+
+declare class LensFlareFeaturesMaterial extends ShaderMaterial {
+    constructor(params?: LensFlareFeaturesMaterialParameters);
+    setSize(width: number, height: number): void;
+    get inputBuffer(): Texture | null;
+    set inputBuffer(value: Texture | null);
+    get ghostAmount(): number;
+    set ghostAmount(value: number);
+    get haloAmount(): number;
+    set haloAmount(value: number);
+    get chromaticAberration(): number;
+    set chromaticAberration(value: number);
+}
+
+declare interface LensFlareFeaturesMaterialParameters extends ShaderMaterialParameters {
+    inputBuffer?: Texture | null;
+    lensColorTexture?: Texture | null;
+    ghostAmount?: number;
+    haloAmount?: number;
+    chromaticAberration?: number;
+}
+
+declare class LightingMaskPass extends Pass {
+    private readonly renderPass;
+    private readonly depthTexture;
+    private readonly renderTarget;
+    private readonly depthCopyPass0;
+    private readonly depthCopyPass1;
+    private readonly clearPass;
+    private readonly depthMaskMaterial;
+    private readonly depthMaskPass;
+    readonly selection: Selection_2;
+    constructor(scene: Scene, camera: Camera);
+    set mainScene(value: Scene);
+    set mainCamera(value: Camera);
+    initialize(renderer: WebGLRenderer, alpha: boolean, frameBufferType: TextureDataType): void;
+    setDepthTexture(depthTexture: Texture, depthPacking?: DepthPackingStrategies): void;
+    render(renderer: WebGLRenderer, inputBuffer: WebGLRenderTarget | null, outputBuffer: WebGLRenderTarget | null, deltaTime?: number, stencilTest?: boolean): void;
+    setSize(width: number, height: number): void;
+    get texture(): Texture;
+    get selectionLayer(): number;
+    set selectionLayer(value: number);
+    get inverted(): boolean;
+    set inverted(value: boolean);
+}
+
+declare type NumericKey = keyof {
+    [P in keyof CloudLayer as number extends CloudLayer[P] ? P : never]: any;
+};
+
+declare const paramKeys: readonly ["solarIrradiance", "sunAngularRadius", "bottomRadius", "topRadius", "rayleighDensity", "rayleighScattering", "mieDensity", "mieScattering", "mieExtinction", "miePhaseFunctionG", "absorptionDensity", "absorptionExtinction", "groundAlbedo", "muSMin", "skyRadianceToLuminance", "sunRadianceToLuminance"];
+
+declare const paramKeys_2: readonly ["channel", "altitude", "height", "densityScale", "shapeAmount", "shapeDetailAmount", "weatherExponent", "shapeAlteringBias", "coverageFilterWidth", "shadow", "densityProfile"];
+
+declare abstract class PassBase extends Pass {
+    shadow: CascadedShadowMaps;
+    private _mainCamera;
+    constructor(name: string, options: PassBaseOptions);
+    get mainCamera(): Camera;
+    set mainCamera(value: Camera);
+}
+
+declare interface PassBaseOptions {
+    shadow: CascadedShadowMaps;
+}
+
+declare interface PrecomputedTextures {
+    irradianceTexture: Texture;
+    scatteringTexture: Data3DTexture;
+    transmittanceTexture: Texture;
+    singleMieScatteringTexture?: Data3DTexture;
+    higherOrderScatteringTexture?: Data3DTexture;
+}
+
+declare class PrecomputedTexturesGenerator {
+    readonly transmittanceRenderTarget: WebGLRenderTarget;
+    readonly scatteringRenderTarget: WebGL3DRenderTarget;
+    readonly irradianceRenderTarget: WebGLRenderTarget;
+    readonly singleMieScatteringRenderTarget?: WebGL3DRenderTarget;
+    readonly higherOrderScatteringRenderTarget?: WebGL3DRenderTarget;
+    readonly textures: PrecomputedTextures;
+    transmittanceMaterial: PrecomputeMaterial;
+    directIrradianceMaterial: PrecomputeMaterial;
+    singleScatteringMaterial: PrecomputeMaterial;
+    scatteringDensityMaterial: PrecomputeMaterial;
+    indirectIrradianceMaterial: PrecomputeMaterial;
+    multipleScatteringMaterial: PrecomputeMaterial;
+    private readonly renderer;
+    private readonly type;
+    private readonly mesh;
+    private readonly scene;
+    private readonly camera;
+    private updating;
+    private disposeQueue;
+    constructor(renderer: WebGLRenderer, { type, combinedScattering, higherOrderScattering }?: PrecomputedTexturesGeneratorOptions);
+    private render3DRenderTarget;
+    private computeTransmittance;
+    private computeOpticalDepth;
+    private computeDirectIrradiance;
+    private computeSingleScattering;
+    private computeScatteringDensity;
+    private computeIndirectIrradiance;
+    private computeMultipleScattering;
+    private precompute;
+    update(atmosphere?: AtmosphereParameters): Promise<PrecomputedTextures>;
+    dispose(options?: {
+        textures?: boolean;
+    }): void;
+}
+
+declare interface PrecomputedTexturesGeneratorOptions {
+    type?: AnyFloatType;
+    combinedScattering?: boolean;
+    higherOrderScattering?: boolean;
+}
+
+declare class PrecomputeMaterial extends RawShaderMaterial {
+    constructor(params: ShaderMaterialParameters);
+    set additive(value: boolean);
+    setUniforms(context: Context): void;
+}
+
+declare type Procedural3DTexture = ProceduralTexture<Data3DTexture>;
+
+declare interface ProceduralTexture<T extends Texture = Texture> {
+    readonly size: number;
+    readonly texture: T;
+    dispose: () => void;
+    render: (renderer: WebGLRenderer, deltaTime?: number) => void;
+}
+
+declare interface ProjectOnEllipsoidSurfaceOptions {
+    centerTolerance?: number;
+}
+
+declare type PropertyShorthand<Args extends readonly unknown[]> = Args extends readonly [infer T, infer K, ...infer Rest] ? K extends readonly string[] ? K[number] extends keyof T ? Rest extends readonly unknown[] ? {
+    [P in K[number]]: T[P];
+} & PropertyShorthand<Rest> : {
+    [P in K[number]]: T[P];
+} : never : never : {};
+
+declare type QualityPreset = 'low' | 'medium' | 'high' | 'ultra';
+
+declare class ShaderArrayPass extends ShaderPass {
+    input: string;
+    render(renderer: WebGLRenderer, inputBuffer: WebGLRenderTarget | null, outputBuffer: WebGLArrayRenderTarget, deltaTime?: number, stencilTest?: boolean): void;
+}
+
+declare const shadowMapsParameterKeys: ["cascadeCount", "mapSize", "maxFar", "farScale", "splitMode", "splitLambda"];
+
+declare class ShadowMaterial extends RawShaderMaterial {
+    uniforms: ShadowMaterialUniforms;
+    constructor({ parameterUniforms, layerUniforms, atmosphereUniforms }: ShadowMaterialParameters);
+    setSize(width: number, height: number): void;
+    localWeatherChannels: string;
+    cascadeCount: number;
+    temporalPass: boolean;
+    temporalJitter: boolean;
+    shapeDetail: boolean;
+    turbulence: boolean;
+}
+
+declare const shadowMaterialParameterKeys: ["temporalJitter"];
+
+declare interface ShadowMaterialParameters {
+    parameterUniforms: CloudParameterUniforms;
+    layerUniforms: CloudLayerUniforms;
+    atmosphereUniforms: AtmosphereUniforms;
+}
+
+declare interface ShadowMaterialUniforms extends CloudParameterUniforms, CloudLayerUniforms, AtmosphereUniforms {
+    [key: string]: Uniform<unknown>;
+    inverseShadowMatrices: Uniform<Matrix4[]>;
+    reprojectionMatrices: Uniform<Matrix4[]>;
+    resolution: Uniform<Vector2>;
+    frame: Uniform<number>;
+    stbnTexture: Uniform<Data3DTexture | null>;
+    maxIterationCount: Uniform<number>;
+    minStepSize: Uniform<number>;
+    maxStepSize: Uniform<number>;
+    minDensity: Uniform<number>;
+    minExtinction: Uniform<number>;
+    minTransmittance: Uniform<number>;
+    opticalDepthTailScale: Uniform<number>;
+}
+
+declare class ShadowPass extends PassBase {
+    private currentRenderTarget;
+    readonly currentMaterial: ShadowMaterial;
+    readonly currentPass: ShaderArrayPass;
+    private resolveRenderTarget;
+    readonly resolveMaterial: ShadowResolveMaterial;
+    readonly resolvePass: ShaderArrayPass;
+    private historyRenderTarget;
+    private width;
+    private height;
+    constructor({ parameterUniforms, layerUniforms, atmosphereUniforms, ...options }: ShadowPassOptions);
+    initialize(renderer: WebGLRenderer, alpha: boolean, frameBufferType: TextureDataType): void;
+    private initRenderTargets;
+    private copyShadow;
+    private copyReprojection;
+    private swapBuffers;
+    update(renderer: WebGLRenderer, frame: number, deltaTime: number): void;
+    setSize(width: number, height: number, depth?: number): void;
+    get outputBuffer(): DataArrayTexture;
+    get temporalPass(): boolean;
+    set temporalPass(value: boolean);
+}
+
+declare interface ShadowPassOptions extends PassBaseOptions {
+    parameterUniforms: CloudParameterUniforms;
+    layerUniforms: CloudLayerUniforms;
+    atmosphereUniforms: AtmosphereUniforms;
+}
+
+declare const shadowPassParameterKeys: ["temporalPass"];
+
+declare class ShadowResolveMaterial extends RawShaderMaterial {
+    uniforms: ShadowResolveMaterialUniforms;
+    constructor({ inputBuffer, historyBuffer }?: ShadowResolveMaterialParameters);
+    setSize(width: number, height: number): void;
+    cascadeCount: number;
+}
+
+declare interface ShadowResolveMaterialParameters {
+    inputBuffer?: DataArrayTexture | null;
+    historyBuffer?: DataArrayTexture | null;
+}
+
+declare interface ShadowResolveMaterialUniforms {
+    [key: string]: Uniform<unknown>;
+    inputBuffer: Uniform<DataArrayTexture | null>;
+    historyBuffer: Uniform<DataArrayTexture | null>;
+    texelSize: Uniform<Vector2>;
+    varianceGamma: Uniform<number>;
+    temporalAlpha: Uniform<number>;
+}
+
+declare interface ShadowShorthand extends UniformShorthand<ShadowMaterial, (typeof shadowUniformKeys)[number]>, PropertyShorthand<[
+ShadowMaterial,
+typeof shadowMaterialParameterKeys,
+ShadowPass,
+typeof shadowPassParameterKeys,
+CascadedShadowMaps,
+typeof shadowMapsParameterKeys
+]> {
+}
+
+declare const shadowUniformKeys: ["maxIterationCount", "minStepSize", "maxStepSize", "minDensity", "minExtinction", "minTransmittance", "opticalDepthTailScale"];
+
+declare class SkyLightProbe extends LightProbe {
+    private readonly atmosphere;
+    irradianceTexture: Texture | null;
+    ellipsoid: Ellipsoid;
+    readonly worldToECEFMatrix: Matrix4;
+    correctAltitude: boolean;
+    readonly sunDirection: Vector3;
+    constructor(params?: SkyLightProbeParameters, atmosphere?: AtmosphereParameters);
+    update(): void;
+}
+
+declare interface SkyLightProbeParameters {
+    irradianceTexture?: Texture | null;
+    ellipsoid?: Ellipsoid;
+    correctAltitude?: boolean;
+    sunDirection?: Vector3;
+}
+
+declare class SkyMaterial extends AtmosphereMaterialBase {
+    uniforms: AtmosphereMaterialBaseUniforms & SkyMaterialUniforms;
+    shadowLength: AtmosphereShadowLength | null;
+    constructor(params?: SkyMaterialParameters);
+    onBeforeRender(renderer: WebGLRenderer, scene: Scene, camera: Camera, geometry: BufferGeometry, object: Object3D, group: Group): void;
+    sun: boolean;
+    moon: boolean;
+    ground: boolean;
+    get moonDirection(): Vector3;
+    get moonAngularRadius(): number;
+    set moonAngularRadius(value: number);
+    get lunarRadianceScale(): number;
+    set lunarRadianceScale(value: number);
+    get groundAlbedo(): Color;
+}
+
+declare interface SkyMaterialParameters extends AtmosphereMaterialBaseParameters {
+    sun?: boolean;
+    moon?: boolean;
+    moonDirection?: Vector3;
+    moonAngularRadius?: number;
+    lunarRadianceScale?: number;
+    ground?: boolean;
+    groundAlbedo?: Color;
+}
+
+declare interface SkyMaterialUniforms {
+    [key: string]: Uniform<unknown>;
+    inverseProjectionMatrix: Uniform<Matrix4>;
+    inverseViewMatrix: Uniform<Matrix4>;
+    moonDirection: Uniform<Vector3>;
+    moonAngularRadius: Uniform<number>;
+    lunarRadianceScale: Uniform<number>;
+    groundAlbedo: Uniform<Color>;
+    shadowLengthBuffer: Uniform<Texture | null>;
+}
+
+declare class SunDirectionalLight extends DirectionalLight {
+    private readonly atmosphere;
+    transmittanceTexture: Texture | null;
+    ellipsoid: Ellipsoid;
+    readonly worldToECEFMatrix: Matrix4;
+    correctAltitude: boolean;
+    readonly sunDirection: Vector3;
+    distance: number;
+    constructor(params?: SunDirectionalLightParameters, atmosphere?: AtmosphereParameters);
+    update(): void;
+}
+
+declare interface SunDirectionalLightParameters {
+    transmittanceTexture?: Texture | null;
+    ellipsoid?: Ellipsoid;
+    correctAltitude?: boolean;
+    sunDirection?: Vector3;
+    distance?: number;
+}
+
+declare type TextureChannel = 'r' | 'g' | 'b' | 'a';
+
+declare type UniformMap<T> = Omit<Map<string, Uniform>, 'get'> & {
+    get: <K extends keyof T>(key: K) => T[K];
+    set: <K extends keyof T>(key: K, value: T[K]) => void;
+};
+
+declare type UniformShorthand<T extends {
+    uniforms: Record<K, Uniform>;
+}, K extends keyof T['uniforms']> = {
+    [P in K]: T['uniforms'][P] extends Uniform<infer U> ? U : never;
+};
+
+export { }