@takram/three-atmosphere/types/AerialPerspectiveEffect.d.ts

A Three.js and R3F implementation of Precomputed Atmospheric Scattering

import { BlendFunction, Effect } from 'postprocessing';
import { Camera, Matrix4, Uniform, Vector2, Vector3, Data3DTexture, Texture, WebGLRenderer, WebGLRenderTarget } from 'three';
import { Ellipsoid, UniformMap } from '@takram/three-geospatial';
import { AtmosphereParameters, AtmosphereParametersUniform } from './AtmosphereParameters';
import { AtmosphereLightingMask, AtmosphereOverlay, AtmosphereShadow, AtmosphereShadowLength } from './types';
export 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;
}
export 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>;
    cosSunAngularRadius: Uniform<number>;
    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>;
}
export declare const aerialPerspectiveEffectOptionsDefaults: {
    blendFunction: BlendFunction;
    octEncodedNormal: false;
    reconstructNormal: false;
    ellipsoid: Ellipsoid;
    correctAltitude: true;
    correctGeometricError: true;
    sunLight: false;
    skyLight: false;
    transmittance: true;
    inscatter: true;
    albedoScale: number;
    sky: false;
    sun: true;
    moon: true;
    moonAngularRadius: number;
    lunarRadianceScale: number;
    ground: true;
};
export 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;
    get sunAngularRadius(): number;
    set sunAngularRadius(value: number);
    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;
}