@takram/three-clouds 0.1.0

package/types/CloudsMaterial.d.ts

@@ -0,0 +1,86 @@
+import { AtmosphereUniforms, CloudLayerUniforms, CloudParameterUniforms } from './uniforms';
+import { AtmosphereMaterialBase, AtmosphereParameters, AtmosphereMaterialBaseUniforms } from '@takram/three-atmosphere';
+import { Matrix4, Uniform, Vector2, Vector3, BufferGeometry, Camera, Data3DTexture, DataArrayTexture, Group, Object3D, Scene, Texture, WebGLRenderer } from 'three';
+
+declare module 'three' {
+    interface Camera {
+        isPerspectiveCamera?: boolean;
+    }
+}
+export interface CloudsMaterialParameters {
+    parameterUniforms: CloudParameterUniforms;
+    layerUniforms: CloudLayerUniforms;
+    atmosphereUniforms: AtmosphereUniforms;
+}
+export interface CloudsMaterialUniforms extends CloudParameterUniforms, CloudLayerUniforms, AtmosphereUniforms {
+    depthBuffer: Uniform<Texture | null>;
+    viewMatrix: Uniform<Matrix4>;
+    inverseProjectionMatrix: Uniform<Matrix4>;
+    inverseViewMatrix: Uniform<Matrix4>;
+    reprojectionMatrix: 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>;
+    albedo: Uniform<Vector3>;
+    skyIrradianceScale: Uniform<number>;
+    groundIrradianceScale: 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>;
+}
+export 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;
+    accurateSunSkyIrradiance: boolean;
+    accuratePhaseFunction: boolean;
+    shadowCascadeCount: number;
+    shadowSampleCount: number;
+    scatterAnisotropy1: number;
+    scatterAnisotropy2: number;
+    scatterAnisotropyMix: number;
+}

package/types/CloudsPass.d.ts

@@ -0,0 +1,44 @@
+import { AtmosphereUniforms, CloudLayerUniforms, CloudParameterUniforms } from './uniforms';
+import { PassBase, PassBaseOptions } from './PassBase';
+import { CloudsResolveMaterial } from './CloudsResolveMaterial';
+import { CloudsMaterial } from './CloudsMaterial';
+import { AtmosphereParameters } from '@takram/three-atmosphere';
+import { Camera, DataArrayTexture, DepthPackingStrategies, Texture, TextureDataType, WebGLRenderer } from 'three';
+import { ShaderPass } from 'postprocessing';
+
+export interface CloudsPassOptions extends PassBaseOptions {
+    parameterUniforms: CloudParameterUniforms;
+    layerUniforms: CloudLayerUniforms;
+    atmosphereUniforms: AtmosphereUniforms;
+}
+export 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);
+}

package/types/CloudsResolveMaterial.d.ts

@@ -0,0 +1,30 @@
+import { RawShaderMaterial, Uniform, Vector2, BufferGeometry, Camera, Group, Object3D, Scene, Texture, WebGLRenderer } from 'three';
+
+export interface CloudsResolveMaterialParameters {
+    colorBuffer?: Texture | null;
+    depthVelocityBuffer?: Texture | null;
+    shadowLengthBuffer?: Texture | null;
+    colorHistoryBuffer?: Texture | null;
+    shadowLengthHistoryBuffer?: Texture | null;
+}
+export 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>;
+}
+export 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;
+}

package/types/DensityProfile.d.ts

@@ -0,0 +1,12 @@
+export interface DensityProfileLike extends Partial<Pick<DensityProfile, 'expTerm' | 'exponent' | 'linearTerm' | 'constantTerm'>> {
+}
+export declare class DensityProfile {
+    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;
+    copy(other: DensityProfile): this;
+}

package/types/LocalWeather.d.ts

@@ -0,0 +1,5 @@
+import { ProceduralTextureBase } from './ProceduralTexture';
+
+export declare class LocalWeather extends ProceduralTextureBase {
+    constructor();
+}

package/types/PassBase.d.ts

@@ -0,0 +1,14 @@
+import { CascadedShadowMaps } from './CascadedShadowMaps';
+import { Camera } from 'three';
+import { Pass } from 'postprocessing';
+
+export interface PassBaseOptions {
+    shadow: CascadedShadowMaps;
+}
+export declare abstract class PassBase extends Pass {
+    shadow: CascadedShadowMaps;
+    private _mainCamera;
+    constructor(name: string, options: PassBaseOptions);
+    get mainCamera(): Camera;
+    set mainCamera(value: Camera);
+}

package/types/Procedural3DTexture.d.ts

@@ -0,0 +1,20 @@
+import { ProceduralTexture } from './ProceduralTexture';
+import { Data3DTexture, WebGLRenderer } from 'three';
+
+export type Procedural3DTexture = ProceduralTexture<Data3DTexture>;
+export interface Procedural3DTextureBaseParameters {
+    size: number;
+    fragmentShader: string;
+}
+export declare class Procedural3DTextureBase implements Procedural3DTexture {
+    readonly size: number;
+    needsRender: boolean;
+    private readonly material;
+    private readonly mesh;
+    private readonly renderTarget;
+    private readonly camera;
+    constructor({ size, fragmentShader }: Procedural3DTextureBaseParameters);
+    dispose(): void;
+    render(renderer: WebGLRenderer, deltaTime?: number): void;
+    get texture(): Data3DTexture;
+}

package/types/ProceduralTexture.d.ts

@@ -0,0 +1,24 @@
+import { Texture, WebGLRenderer } from 'three';
+
+export interface ProceduralTexture<T extends Texture = Texture> {
+    readonly size: number;
+    readonly texture: T;
+    dispose: () => void;
+    render: (renderer: WebGLRenderer, deltaTime?: number) => void;
+}
+export interface ProceduralTextureBaseParameters {
+    size: number;
+    fragmentShader: string;
+}
+export declare class ProceduralTextureBase implements ProceduralTexture {
+    readonly size: number;
+    needsRender: boolean;
+    private readonly material;
+    private readonly mesh;
+    private readonly renderTarget;
+    private readonly camera;
+    constructor({ size, fragmentShader }: ProceduralTextureBaseParameters);
+    dispose(): void;
+    render(renderer: WebGLRenderer, deltaTime?: number): void;
+    get texture(): Texture;
+}

package/types/ShaderArrayPass.d.ts

@@ -0,0 +1,7 @@
+import { WebGLArrayRenderTarget, WebGLRenderer, WebGLRenderTarget } from 'three';
+import { ShaderPass } from 'postprocessing';
+
+export declare class ShaderArrayPass extends ShaderPass {
+    input: string;
+    render(renderer: WebGLRenderer, inputBuffer: WebGLRenderTarget | null, outputBuffer: WebGLArrayRenderTarget, deltaTime?: number, stencilTest?: boolean): void;
+}

package/types/ShadowMaterial.d.ts

@@ -0,0 +1,34 @@
+import { AtmosphereUniforms, CloudLayerUniforms, CloudParameterUniforms } from './uniforms';
+import { Matrix4, RawShaderMaterial, Uniform, Vector2, Data3DTexture } from 'three';
+
+export interface ShadowMaterialParameters {
+    parameterUniforms: CloudParameterUniforms;
+    layerUniforms: CloudLayerUniforms;
+    atmosphereUniforms: AtmosphereUniforms;
+}
+export 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>;
+}
+export 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;
+}

package/types/ShadowPass.d.ts

@@ -0,0 +1,34 @@
+import { AtmosphereUniforms, CloudLayerUniforms, CloudParameterUniforms } from './uniforms';
+import { ShadowResolveMaterial } from './ShadowResolveMaterial';
+import { ShadowMaterial } from './ShadowMaterial';
+import { ShaderArrayPass } from './ShaderArrayPass';
+import { PassBase, PassBaseOptions } from './PassBase';
+import { DataArrayTexture, TextureDataType, WebGLRenderer } from 'three';
+
+export interface ShadowPassOptions extends PassBaseOptions {
+    parameterUniforms: CloudParameterUniforms;
+    layerUniforms: CloudLayerUniforms;
+    atmosphereUniforms: AtmosphereUniforms;
+}
+export 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);
+}

package/types/ShadowResolveMaterial.d.ts

@@ -0,0 +1,20 @@
+import { RawShaderMaterial, Uniform, Vector2, DataArrayTexture } from 'three';
+
+export interface ShadowResolveMaterialParameters {
+    inputBuffer?: DataArrayTexture | null;
+    historyBuffer?: DataArrayTexture | null;
+}
+export interface ShadowResolveMaterialUniforms {
+    [key: string]: Uniform<unknown>;
+    inputBuffer: Uniform<DataArrayTexture | null>;
+    historyBuffer: Uniform<DataArrayTexture | null>;
+    texelSize: Uniform<Vector2>;
+    varianceGamma: Uniform<number>;
+    temporalAlpha: Uniform<number>;
+}
+export declare class ShadowResolveMaterial extends RawShaderMaterial {
+    uniforms: ShadowResolveMaterialUniforms;
+    constructor({ inputBuffer, historyBuffer }?: ShadowResolveMaterialParameters);
+    setSize(width: number, height: number): void;
+    cascadeCount: number;
+}

package/types/Turbulence.d.ts

@@ -0,0 +1,5 @@
+import { ProceduralTextureBase } from './ProceduralTexture';
+
+export declare class Turbulence extends ProceduralTextureBase {
+    constructor();
+}

package/types/bayer.d.ts

@@ -0,0 +1,4 @@
+import { Vector2 } from 'three';
+
+export declare const bayerIndices: number[];
+export declare const bayerOffsets: Vector2[];

package/types/constants.d.ts

@@ -0,0 +1,6 @@
+export declare const CLOUD_SHAPE_TEXTURE_SIZE = 128;
+export declare const CLOUD_SHAPE_DETAIL_TEXTURE_SIZE = 32;
+export declare const DEFAULT_LOCAL_WEATHER_URL = "https://media.githubusercontent.com/media/takram-design-engineering/three-geospatial/45a1c6c1bb9fd38b3680fd120795ff4c32df68ff/packages/clouds/assets/local_weather.png";
+export declare const DEFAULT_SHAPE_URL = "https://media.githubusercontent.com/media/takram-design-engineering/three-geospatial/45a1c6c1bb9fd38b3680fd120795ff4c32df68ff/packages/clouds/assets/shape.bin";
+export declare const DEFAULT_SHAPE_DETAIL_URL = "https://media.githubusercontent.com/media/takram-design-engineering/three-geospatial/45a1c6c1bb9fd38b3680fd120795ff4c32df68ff/packages/clouds/assets/shape_detail.bin";
+export declare const DEFAULT_TURBULENCE_URL = "https://media.githubusercontent.com/media/takram-design-engineering/three-geospatial/45a1c6c1bb9fd38b3680fd120795ff4c32df68ff/packages/clouds/assets/turbulence.png";

package/types/helpers/FrustumCorners.d.ts

@@ -0,0 +1,18 @@
+import { Vector3, Camera, Matrix4 } from 'three';
+
+declare module 'three' {
+    interface Camera {
+        isOrthographicCamera?: boolean;
+    }
+}
+export declare class FrustumCorners {
+    readonly near: Vector3[];
+    readonly far: Vector3[];
+    constructor();
+    constructor(camera: Camera, far: number);
+    clone(): FrustumCorners;
+    copy(other: FrustumCorners): this;
+    setFromCamera(camera: Camera, far: number): this;
+    split(clipDepths: readonly number[], result?: FrustumCorners[]): FrustumCorners[];
+    applyMatrix4(matrix: Matrix4): this;
+}

package/types/helpers/setArrayRenderTargetLayers.d.ts

@@ -0,0 +1,3 @@
+import { WebGLArrayRenderTarget, WebGLRenderer } from 'three';
+
+export declare function setArrayRenderTargetLayers(renderer: WebGLRenderer, outputBuffer: WebGLArrayRenderTarget): void;

package/types/helpers/splitFrustum.d.ts

@@ -0,0 +1,9 @@
+export type FrustumSplitFunction = (length: number, near: number, far: number, lambda?: number, result?: number[]) => number[];
+export interface FrustumSplitFunctions {
+    uniform: FrustumSplitFunction;
+    logarithmic: FrustumSplitFunction;
+    practical: FrustumSplitFunction;
+}
+export type FrustumSplitMode = keyof FrustumSplitFunctions;
+export declare const frustumSplitFunctions: FrustumSplitFunctions;
+export declare function splitFrustum(mode: FrustumSplitMode, count: number, near: number, far: number, lambda?: number, result?: number[]): number[];

package/types/index.d.ts

@@ -0,0 +1,13 @@
+export type { QualityPreset as CloudsQualityPreset } from './qualityPresets';
+export type { FrustumSplitMode } from './helpers/splitFrustum';
+export * from './CloudLayer';
+export * from './CloudLayers';
+export * from './CloudsEffect';
+export * from './CloudShape';
+export * from './CloudShapeDetail';
+export * from './constants';
+export * from './DensityProfile';
+export * from './LocalWeather';
+export * from './Procedural3DTexture';
+export * from './ProceduralTexture';
+export * from './Turbulence';

package/types/qualityPresets.d.ts

@@ -0,0 +1,46 @@
+import { CloudsEffect } from './CloudsEffect';
+import { SharedUnionFieldsDeep } from 'type-fest';
+import { Vector2 } from 'three';
+
+export type QualityPreset = 'low' | 'medium' | 'high' | 'ultra';
+declare const values: {
+    resolutionScale: number;
+    lightShafts: true;
+    shapeDetail: true;
+    turbulence: true;
+    haze: true;
+    clouds: {
+        multiScatteringOctaves: number;
+        accurateSunSkyIrradiance: true;
+        accuratePhaseFunction: false;
+        maxIterationCount: number;
+        minStepSize: number;
+        maxStepSize: number;
+        maxRayDistance: number;
+        perspectiveStepScale: number;
+        minDensity: number;
+        minExtinction: number;
+        minTransmittance: number;
+        maxIterationCountToGround: number;
+        maxIterationCountToSun: number;
+        minSecondaryStepSize: number;
+        secondaryStepScale: number;
+        maxShadowLengthIterationCount: number;
+        minShadowLengthStepSize: number;
+        maxShadowLengthRayDistance: number;
+    };
+    shadow: {
+        cascadeCount: number;
+        mapSize: Vector2;
+        maxIterationCount: number;
+        minStepSize: number;
+        maxStepSize: number;
+        minDensity: number;
+        minExtinction: number;
+        minTransmittance: number;
+    };
+};
+type Schema = SharedUnionFieldsDeep<typeof values | CloudsEffect>;
+export declare const defaults: Schema;
+export declare const qualityPresets: Record<QualityPreset, Schema>;
+export {};

package/types/r3f/CloudLayer.d.ts

@@ -0,0 +1,7 @@
+import { CloudLayer as CloudLayerImpl, CloudLayerLike } from '../CloudLayer';
+import { ExpandNestedProps } from '@takram/three-geospatial/r3f';
+
+export interface CloudLayerProps extends CloudLayerLike, ExpandNestedProps<CloudLayerLike, 'densityProfile'> {
+    index?: number;
+}
+export declare const CloudLayer: import('react').ForwardRefExoticComponent<CloudLayerProps & import('react').RefAttributes<CloudLayerImpl>>;

package/types/r3f/CloudLayers.d.ts

@@ -0,0 +1,15 @@
+import { CloudLayers as CloudLayersImpl } from '../CloudLayers';
+import { FC, ReactNode } from 'react';
+
+export interface CloudLayersContextValue {
+    layers: CloudLayersImpl;
+    indexPool: number[];
+    disableDefault: boolean;
+}
+export declare const CloudLayersContext: import('react').Context<CloudLayersContextValue | null>;
+export interface CloudLayersProps {
+    layers: CloudLayersImpl;
+    disableDefault?: boolean;
+    children?: ReactNode;
+}
+export declare const CloudLayers: FC<CloudLayersProps>;

package/types/r3f/Clouds.d.ts

@@ -0,0 +1,16 @@
+import { ProceduralTexture } from '../ProceduralTexture';
+import { Procedural3DTexture } from '../Procedural3DTexture';
+import { CloudsEffect } from '../CloudsEffect';
+import { ExpandNestedProps, PassThoughInstanceProps } from '@takram/three-geospatial/r3f';
+import { Data3DTexture, Texture } from 'three';
+
+export interface CloudsProps extends Omit<PassThoughInstanceProps<CloudsEffect, [
+], Partial<CloudsEffect & ExpandNestedProps<CloudsEffect, 'clouds'> & ExpandNestedProps<CloudsEffect, 'shadow'>>>, 'localWeatherTexture' | 'shapeTexture' | 'shapeDetailTexture' | 'turbulenceTexture' | 'stbnTexture'> {
+    disableDefaultLayers?: boolean;
+    localWeatherTexture?: Texture | ProceduralTexture | string;
+    shapeTexture?: Data3DTexture | Procedural3DTexture | string;
+    shapeDetailTexture?: Data3DTexture | Procedural3DTexture | string;
+    turbulenceTexture?: Texture | ProceduralTexture | string;
+    stbnTexture?: Data3DTexture | string;
+}
+export declare const Clouds: import('react').ForwardRefExoticComponent<Omit<CloudsProps, "ref"> & import('react').RefAttributes<CloudsEffect>>;

package/types/r3f/index.d.ts

@@ -0,0 +1,2 @@
+export * from './Clouds';
+export * from './CloudLayer';

package/types/uniforms.d.ts

@@ -0,0 +1,66 @@
+import { CloudLayers } from './CloudLayers';
+import { AtmosphereParameters } from '@takram/three-atmosphere';
+import { Primitive } from 'type-fest';
+import { Uniform, Vector3, Vector4, Data3DTexture, Matrix4, Texture, Vector2 } from 'three';
+
+export 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>;
+}
+export type CloudParameterUniformInstances = {
+    [K in keyof CloudParameterUniforms as CloudParameterUniforms[K]['value'] extends Primitive ? never : K]: CloudParameterUniforms[K]['value'];
+};
+export declare function createCloudParameterUniforms(instances: CloudParameterUniformInstances): CloudParameterUniforms;
+interface DensityProfileVectors {
+    expTerms: Vector4;
+    exponents: Vector4;
+    linearTerms: Vector4;
+    constantTerms: Vector4;
+}
+export 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>;
+}
+export declare function createCloudLayerUniforms(): CloudLayerUniforms;
+export declare function updateCloudLayerUniforms(uniforms: CloudLayerUniforms, layers: CloudLayers): void;
+export interface AtmosphereUniforms {
+    bottomRadius: Uniform<number>;
+    topRadius: Uniform<number>;
+    ellipsoidCenter: Uniform<Vector3>;
+    ellipsoidMatrix: Uniform<Matrix4>;
+    inverseEllipsoidMatrix: Uniform<Matrix4>;
+    altitudeCorrection: Uniform<Vector3>;
+    sunDirection: Uniform<Vector3>;
+}
+export type AtmosphereUniformInstances = {
+    [K in keyof AtmosphereUniforms as AtmosphereUniforms[K]['value'] extends Primitive ? never : K]: AtmosphereUniforms[K]['value'];
+};
+export declare function createAtmosphereUniforms(atmosphere: AtmosphereParameters, instances: AtmosphereUniformInstances): AtmosphereUniforms;
+export {};