@takram/three-clouds 0.1.0

package/src/shaders/turbulence.frag

@@ -0,0 +1,51 @@
+precision highp float;
+precision highp int;
+
+#include "core/math"
+#include "perlin"
+#include "tileableNoise"
+
+in vec2 vUv;
+
+layout(location = 0) out vec4 outputColor;
+
+const vec3 frequency = vec3(12.0);
+const int octaveCount = 3;
+
+float perlin(const vec3 point) {
+  return getPerlinNoise(point, frequency, octaveCount);
+}
+
+vec3 perlin3d(const vec3 point) {
+  float perlin1 = perlin(point);
+  float perlin2 = perlin(point.yzx + vec3(-19.1, 33.4, 47.2));
+  float perlin3 = perlin(point.zxy + vec3(74.2, -124.5, 99.4));
+  return vec3(perlin1, perlin2, perlin3);
+}
+
+vec3 curl(vec3 point) {
+  const float delta = 0.1;
+  vec3 dx = vec3(delta, 0.0, 0.0);
+  vec3 dy = vec3(0.0, delta, 0.0);
+  vec3 dz = vec3(0.0, 0.0, delta);
+
+  vec3 px0 = perlin3d(point - dx);
+  vec3 px1 = perlin3d(point + dx);
+  vec3 py0 = perlin3d(point - dy);
+  vec3 py1 = perlin3d(point + dy);
+  vec3 pz0 = perlin3d(point - dz);
+  vec3 pz1 = perlin3d(point + dz);
+
+  float x = py1.z - py0.z - pz1.y + pz0.y;
+  float y = pz1.x - pz0.x - px1.z + px0.z;
+  float z = px1.y - px0.y - py1.x + py0.x;
+
+  const float divisor = 1.0 / (2.0 * delta);
+  return normalize(vec3(x, y, z) * divisor);
+}
+
+void main() {
+  vec3 point = vec3(vUv.x, vUv.y, 0.0);
+  outputColor.rgb = 0.5 * curl(point) + 0.5;
+  outputColor.a = 1.0;
+}

package/src/shaders/types.glsl

@@ -0,0 +1,18 @@
+struct GroundIrradiance {
+  vec3 sun;
+  vec3 sky;
+};
+
+struct CloudsIrradiance {
+  vec3 minSun;
+  vec3 minSky;
+  vec3 maxSun;
+  vec3 maxSky;
+};
+
+struct DensityProfile {
+  vec4 expTerms;
+  vec4 exponents;
+  vec4 linearTerms;
+  vec4 constantTerms;
+};

package/src/shaders/varianceClipping.glsl

@@ -0,0 +1,114 @@
+#ifdef VARIANCE_9_SAMPLES
+#define VARIANCE_OFFSET_COUNT (8)
+const ivec2 varianceOffsets[8] = ivec2[8](
+  ivec2(-1, -1),
+  ivec2(-1, 1),
+  ivec2(1, -1),
+  ivec2(1, 1),
+  ivec2(1, 0),
+  ivec2(0, -1),
+  ivec2(0, 1),
+  ivec2(-1, 0)
+);
+#else // VARIANCE_9_SAMPLES
+#define VARIANCE_OFFSET_COUNT (4)
+const ivec2 varianceOffsets[4] = ivec2[4](ivec2(1, 0), ivec2(0, -1), ivec2(0, 1), ivec2(-1, 0));
+#endif // VARIANCE_9_SAMPLES
+
+// Reference: https://github.com/playdeadgames/temporal
+vec4 clipAABB(const vec4 current, const vec4 history, const vec4 minColor, const vec4 maxColor) {
+  vec3 pClip = 0.5 * (maxColor.rgb + minColor.rgb);
+  vec3 eClip = 0.5 * (maxColor.rgb - minColor.rgb) + 1e-7;
+  vec4 vClip = history - vec4(pClip, current.a);
+  vec3 vUnit = vClip.xyz / eClip;
+  vec3 aUnit = abs(vUnit);
+  float maUnit = max(aUnit.x, max(aUnit.y, aUnit.z));
+  if (maUnit > 1.0) {
+    return vec4(pClip, current.a) + vClip / maUnit;
+  }
+  return history;
+}
+
+#ifdef VARIANCE_SAMPLER_ARRAY
+#define VARIANCE_SAMPLER sampler2DArray
+#define VARIANCE_SAMPLER_COORD ivec3
+#else // VARIANCE_SAMPLER_ARRAY
+#define VARIANCE_SAMPLER sampler2D
+#define VARIANCE_SAMPLER_COORD ivec2
+#endif // VARIANCE_SAMPLER_ARRAY
+
+// Variance clipping
+// Reference: https://developer.download.nvidia.com/gameworks/events/GDC2016/msalvi_temporal_supersampling.pdf
+vec4 varianceClipping(
+  const VARIANCE_SAMPLER inputBuffer,
+  const VARIANCE_SAMPLER_COORD coord,
+  const vec4 current,
+  const vec4 history,
+  const float gamma
+) {
+  vec4 moment1 = current;
+  vec4 moment2 = current * current;
+  vec4 neighbor;
+  #pragma unroll_loop_start
+  for (int i = 0; i < 8; ++i) {
+    #if UNROLLED_LOOP_INDEX < VARIANCE_OFFSET_COUNT
+    neighbor = texelFetchOffset(inputBuffer, coord, 0, varianceOffsets[i]);
+    moment1 += neighbor;
+    moment2 += neighbor * neighbor;
+    #endif // UNROLLED_LOOP_INDEX < VARIANCE_OFFSET_COUNT
+  }
+  #pragma unroll_loop_end
+
+  const float N = float(VARIANCE_OFFSET_COUNT + 1);
+  vec4 mean = moment1 / N;
+  vec4 varianceGamma = sqrt(max(moment2 / N - mean * mean, 0.0)) * gamma;
+  vec4 minColor = mean - varianceGamma;
+  vec4 maxColor = mean + varianceGamma;
+  return clipAABB(clamp(mean, minColor, maxColor), history, minColor, maxColor);
+}
+
+vec4 varianceClipping(
+  const VARIANCE_SAMPLER inputBuffer,
+  const VARIANCE_SAMPLER_COORD coord,
+  const vec4 current,
+  const vec4 history
+) {
+  return varianceClipping(inputBuffer, coord, current, history, 1.0);
+}
+
+vec4 varianceClipping(
+  const sampler2D inputBuffer,
+  const vec2 coord,
+  const vec4 current,
+  const vec4 history,
+  const float gamma
+) {
+  vec4 moment1 = current;
+  vec4 moment2 = current * current;
+  vec4 neighbor;
+  #pragma unroll_loop_start
+  for (int i = 0; i < 8; ++i) {
+    #if UNROLLED_LOOP_INDEX < VARIANCE_OFFSET_COUNT
+    neighbor = textureOffset(inputBuffer, coord, varianceOffsets[i]);
+    moment1 += neighbor;
+    moment2 += neighbor * neighbor;
+    #endif // UNROLLED_LOOP_INDEX < VARIANCE_OFFSET_COUNT
+  }
+  #pragma unroll_loop_end
+
+  const float N = float(VARIANCE_OFFSET_COUNT + 1);
+  vec4 mean = moment1 / N;
+  vec4 varianceGamma = sqrt(max(moment2 / N - mean * mean, 0.0)) * gamma;
+  vec4 minColor = mean - varianceGamma;
+  vec4 maxColor = mean + varianceGamma;
+  return clipAABB(clamp(mean, minColor, maxColor), history, minColor, maxColor);
+}
+
+vec4 varianceClipping(
+  const sampler2D inputBuffer,
+  const vec2 coord,
+  const vec4 current,
+  const vec4 history
+) {
+  return varianceClipping(inputBuffer, coord, current, history, 1.0);
+}

package/src/uniforms.ts

@@ -0,0 +1,218 @@
+import {
+  Uniform,
+  Vector3,
+  Vector4,
+  type Data3DTexture,
+  type Matrix4,
+  type Texture,
+  type Vector2
+} from 'three'
+import invariant from 'tiny-invariant'
+import { type Primitive } from 'type-fest'
+
+import { type AtmosphereParameters } from '@takram/three-atmosphere'
+
+import { type CloudLayers } from './CloudLayers'
+
+export interface CloudParameterUniforms {
+  // Participating medium
+  scatteringCoefficient: Uniform<number>
+  absorptionCoefficient: Uniform<number>
+
+  // Weather and shape
+  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>
+}
+
+// prettier-ignore
+export type CloudParameterUniformInstances = {
+  [K in keyof CloudParameterUniforms as
+    CloudParameterUniforms[K]['value'] extends Primitive ? never : K
+  ]: CloudParameterUniforms[K]['value']
+}
+
+export function createCloudParameterUniforms(
+  instances: CloudParameterUniformInstances
+): CloudParameterUniforms {
+  return {
+    // Participating medium
+    scatteringCoefficient: new Uniform(1),
+    absorptionCoefficient: new Uniform(0),
+
+    // Weather and shape
+    coverage: new Uniform(0.3),
+    localWeatherTexture: new Uniform(instances.localWeatherTexture),
+    localWeatherRepeat: new Uniform(instances.localWeatherRepeat),
+    localWeatherOffset: new Uniform(instances.localWeatherOffset),
+    shapeTexture: new Uniform(instances.shapeTexture),
+    shapeRepeat: new Uniform(instances.shapeRepeat),
+    shapeOffset: new Uniform(instances.shapeOffset),
+    shapeDetailTexture: new Uniform(instances.shapeDetailTexture),
+    shapeDetailRepeat: new Uniform(instances.shapeDetailRepeat),
+    shapeDetailOffset: new Uniform(instances.shapeDetailOffset),
+    turbulenceTexture: new Uniform(instances.turbulenceTexture),
+    turbulenceRepeat: new Uniform(instances.turbulenceRepeat),
+    turbulenceDisplacement: new Uniform(350)
+  }
+}
+
+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 function createCloudLayerUniforms(): CloudLayerUniforms {
+  return {
+    minLayerHeights: new Uniform(new Vector4()),
+    maxLayerHeights: new Uniform(new Vector4()),
+    minIntervalHeights: new Uniform(new Vector3()),
+    maxIntervalHeights: new Uniform(new Vector3()),
+    densityScales: new Uniform(new Vector4()),
+    shapeAmounts: new Uniform(new Vector4()),
+    shapeDetailAmounts: new Uniform(new Vector4()),
+    weatherExponents: new Uniform(new Vector4()),
+    shapeAlteringBiases: new Uniform(new Vector4()),
+    coverageFilterWidths: new Uniform(new Vector4()),
+    minHeight: new Uniform(0),
+    maxHeight: new Uniform(0),
+    shadowTopHeight: new Uniform(0),
+    shadowBottomHeight: new Uniform(0),
+    shadowLayerMask: new Uniform(new Vector4()),
+    densityProfile: new Uniform({
+      expTerms: new Vector4(),
+      exponents: new Vector4(),
+      linearTerms: new Vector4(),
+      constantTerms: new Vector4()
+    })
+  }
+}
+
+const shadowLayerMask = [0, 0, 0, 0]
+
+export function updateCloudLayerUniforms(
+  uniforms: CloudLayerUniforms,
+  layers: CloudLayers
+): void {
+  layers.packValues('altitude', uniforms.minLayerHeights.value)
+  layers.packSums('altitude', 'height', uniforms.maxLayerHeights.value)
+  layers.packIntervalHeights(
+    uniforms.minIntervalHeights.value,
+    uniforms.maxIntervalHeights.value
+  )
+  layers.packValues('densityScale', uniforms.densityScales.value)
+  layers.packValues('shapeAmount', uniforms.shapeAmounts.value)
+  layers.packValues('shapeDetailAmount', uniforms.shapeDetailAmounts.value)
+  layers.packValues('weatherExponent', uniforms.weatherExponents.value)
+  layers.packValues('shapeAlteringBias', uniforms.shapeAlteringBiases.value)
+  layers.packValues('coverageFilterWidth', uniforms.coverageFilterWidths.value)
+
+  const densityProfile = uniforms.densityProfile.value
+  layers.packDensityProfiles('expTerm', densityProfile.expTerms)
+  layers.packDensityProfiles('exponent', densityProfile.exponents)
+  layers.packDensityProfiles('linearTerm', densityProfile.linearTerms)
+  layers.packDensityProfiles('constantTerm', densityProfile.constantTerms)
+
+  let totalMinHeight = Infinity
+  let totalMaxHeight = 0
+  let shadowBottomHeight = Infinity
+  let shadowTopHeight = 0
+  shadowLayerMask.fill(0)
+  for (let i = 0; i < layers.length; ++i) {
+    const { altitude, height, shadow } = layers[i]
+    const maxHeight = altitude + height
+    if (height > 0) {
+      if (altitude < totalMinHeight) {
+        totalMinHeight = altitude
+      }
+      if (shadow && altitude < shadowBottomHeight) {
+        shadowBottomHeight = altitude
+      }
+      if (maxHeight > totalMaxHeight) {
+        totalMaxHeight = maxHeight
+      }
+      if (shadow && maxHeight > shadowTopHeight) {
+        shadowTopHeight = maxHeight
+      }
+    }
+    shadowLayerMask[i] = shadow ? 1 : 0
+  }
+  if (totalMinHeight !== Infinity) {
+    uniforms.minHeight.value = totalMinHeight
+    uniforms.maxHeight.value = totalMaxHeight
+  } else {
+    invariant(totalMaxHeight === 0)
+    uniforms.minHeight.value = 0
+  }
+  if (shadowBottomHeight !== Infinity) {
+    uniforms.shadowBottomHeight.value = shadowBottomHeight
+    uniforms.shadowTopHeight.value = shadowTopHeight
+  } else {
+    invariant(shadowTopHeight === 0)
+    uniforms.shadowBottomHeight.value = 0
+  }
+  uniforms.shadowLayerMask.value.fromArray(shadowLayerMask)
+}
+
+export interface AtmosphereUniforms {
+  bottomRadius: Uniform<number>
+  topRadius: Uniform<number>
+  ellipsoidCenter: Uniform<Vector3>
+  ellipsoidMatrix: Uniform<Matrix4>
+  inverseEllipsoidMatrix: Uniform<Matrix4>
+  altitudeCorrection: Uniform<Vector3>
+  sunDirection: Uniform<Vector3>
+}
+
+// prettier-ignore
+export type AtmosphereUniformInstances = {
+  [K in keyof AtmosphereUniforms as
+    AtmosphereUniforms[K]['value'] extends Primitive ? never : K
+  ]: AtmosphereUniforms[K]['value']
+}
+
+export function createAtmosphereUniforms(
+  atmosphere: AtmosphereParameters,
+  instances: AtmosphereUniformInstances
+): AtmosphereUniforms {
+  return {
+    bottomRadius: new Uniform(atmosphere.bottomRadius),
+    topRadius: new Uniform(atmosphere.topRadius),
+    ellipsoidCenter: new Uniform(instances.ellipsoidCenter),
+    ellipsoidMatrix: new Uniform(instances.ellipsoidMatrix),
+    inverseEllipsoidMatrix: new Uniform(instances.inverseEllipsoidMatrix),
+    altitudeCorrection: new Uniform(instances.altitudeCorrection),
+    sunDirection: new Uniform(instances.sunDirection)
+  }
+}

package/types/CascadedShadowMaps.d.ts

@@ -0,0 +1,52 @@
+import { FrustumSplitMode } from './helpers/splitFrustum';
+import { Matrix4, Vector2, Vector3, PerspectiveCamera } from 'three';
+
+export interface Cascade {
+    readonly interval: Vector2;
+    readonly matrix: Matrix4;
+    readonly inverseMatrix: Matrix4;
+    readonly projectionMatrix: Matrix4;
+    readonly inverseProjectionMatrix: Matrix4;
+    readonly viewMatrix: Matrix4;
+    readonly inverseViewMatrix: Matrix4;
+}
+export interface CascadedShadowMapsOptions {
+    cascadeCount: number;
+    mapSize: Vector2;
+    maxFar?: number | null;
+    farScale?: number;
+    splitMode?: FrustumSplitMode;
+    splitLambda?: number;
+    margin?: number;
+    fade?: boolean;
+}
+export declare const cascadedShadowMapsDefaults: {
+    maxFar: null;
+    farScale: number;
+    splitMode: "practical";
+    splitLambda: number;
+    margin: number;
+    fade: true;
+};
+export 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;
+}

package/types/CloudLayer.d.ts

@@ -0,0 +1,26 @@
+import { DensityProfile, DensityProfileLike } from './DensityProfile';
+
+declare const paramKeys: readonly ["channel", "altitude", "height", "densityScale", "shapeAmount", "shapeDetailAmount", "weatherExponent", "shapeAlteringBias", "coverageFilterWidth", "shadow", "densityProfile"];
+export interface CloudLayerLike extends Partial<Pick<CloudLayer, Exclude<(typeof paramKeys)[number], 'densityProfile'>>> {
+    densityProfile?: DensityProfileLike;
+}
+export type TextureChannel = 'r' | 'g' | 'b' | 'a';
+export 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;
+    shadow: boolean;
+    constructor(options?: CloudLayerLike);
+    set(options?: CloudLayerLike): this;
+    clone(): CloudLayer;
+    copy(other: CloudLayer): this;
+}
+export {};

package/types/CloudLayers.d.ts

@@ -0,0 +1,21 @@
+import { DensityProfileLike } from './DensityProfile';
+import { CloudLayer, CloudLayerLike } from './CloudLayer';
+import { Vector3, Vector4 } from 'three';
+
+type NumericKey = keyof {
+    [P in keyof CloudLayer as number extends CloudLayer[P] ? P : never]: any;
+};
+export 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;
+}
+export {};

package/types/CloudShape.d.ts

@@ -0,0 +1,5 @@
+import { Procedural3DTextureBase } from './Procedural3DTexture';
+
+export declare class CloudShape extends Procedural3DTextureBase {
+    constructor();
+}

package/types/CloudShapeDetail.d.ts

@@ -0,0 +1,5 @@
+import { Procedural3DTextureBase } from './Procedural3DTexture';
+
+export declare class CloudShapeDetail extends Procedural3DTextureBase {
+    constructor();
+}

package/types/CloudsEffect.d.ts

@@ -0,0 +1,170 @@
+import { ShadowPass } from './ShadowPass';
+import { ShadowMaterial } from './ShadowMaterial';
+import { QualityPreset } from './qualityPresets';
+import { ProceduralTexture } from './ProceduralTexture';
+import { Procedural3DTexture } from './Procedural3DTexture';
+import { CloudsPass } from './CloudsPass';
+import { CloudsMaterial } from './CloudsMaterial';
+import { CloudLayers } from './CloudLayers';
+import { CascadedShadowMaps } from './CascadedShadowMaps';
+import { UniformMap, Ellipsoid, PropertyShorthand, UniformShorthand } from '@takram/three-geospatial';
+import { AtmosphereParameters, AtmosphereOverlay, AtmosphereShadow, AtmosphereShadowLength } from '@takram/three-atmosphere';
+import { Camera, Data3DTexture, EventDispatcher, Matrix4, Texture, Uniform, Vector2, Vector3, DataTexture, DepthPackingStrategies, TextureDataType, WebGLRenderer, WebGLRenderTarget } from 'three';
+import { Effect, Resolution } from 'postprocessing';
+
+declare const cloudsUniformKeys: ["maxIterationCount", "minStepSize", "maxStepSize", "maxRayDistance", "perspectiveStepScale", "minDensity", "minExtinction", "minTransmittance", "maxIterationCountToSun", "maxIterationCountToGround", "minSecondaryStepSize", "secondaryStepScale", "maxShadowFilterRadius", "maxShadowLengthIterationCount", "minShadowLengthStepSize", "maxShadowLengthRayDistance", "hazeDensityScale", "hazeExponent"];
+declare const cloudsMaterialParameterKeys: ["multiScatteringOctaves", "accurateSunSkyIrradiance", "accuratePhaseFunction"];
+declare const shadowUniformKeys: ["maxIterationCount", "minStepSize", "maxStepSize", "minDensity", "minExtinction", "minTransmittance", "opticalDepthTailScale"];
+declare const shadowMaterialParameterKeys: ["temporalJitter"];
+declare const shadowPassParameterKeys: ["temporalPass"];
+declare const shadowMapsParameterKeys: ["cascadeCount", "mapSize", "maxFar", "farScale", "splitMode", "splitLambda"];
+interface CloudsShorthand extends UniformShorthand<CloudsMaterial, (typeof cloudsUniformKeys)[number]>, PropertyShorthand<[CloudsMaterial, typeof cloudsMaterialParameterKeys]> {
+}
+interface ShadowShorthand extends UniformShorthand<ShadowMaterial, (typeof shadowUniformKeys)[number]>, PropertyShorthand<[
+    ShadowMaterial,
+    typeof shadowMaterialParameterKeys,
+    ShadowPass,
+    typeof shadowPassParameterKeys,
+    CascadedShadowMaps,
+    typeof shadowMapsParameterKeys
+]> {
+}
+export interface CloudsEffectChangeEvent {
+    type: 'change';
+    target?: CloudsEffect;
+    property?: 'atmosphereOverlay' | 'atmosphereShadow' | 'atmosphereShadowLength';
+}
+export interface CloudsEffectUniforms {
+    cloudsBuffer: Uniform<Texture | null>;
+}
+export interface CloudsEffectOptions {
+    resolutionScale?: number;
+    width?: number;
+    height?: number;
+    resolutionX?: number;
+    resolutionY?: number;
+}
+export declare const cloudsPassOptionsDefaults: {
+    resolutionScale: number;
+    width: number;
+    height: number;
+};
+export 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 ellipsoidCenter: Vector3;
+    readonly ellipsoidMatrix: Matrix4;
+    private readonly inverseEllipsoidMatrix;
+    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 skyIrradianceScale(): number;
+    set skyIrradianceScale(value: number);
+    get groundIrradianceScale(): number;
+    set groundIrradianceScale(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(): DataTexture | null;
+    set irradianceTexture(value: DataTexture | null);
+    get scatteringTexture(): Data3DTexture | null;
+    set scatteringTexture(value: Data3DTexture | null);
+    get transmittanceTexture(): DataTexture | null;
+    set transmittanceTexture(value: DataTexture | null);
+    get useHalfFloat(): boolean;
+    set useHalfFloat(value: boolean);
+    get ellipsoid(): Ellipsoid;
+    set ellipsoid(value: Ellipsoid);
+    get photometric(): boolean;
+    set photometric(value: boolean);
+    get sunAngularRadius(): number;
+    set sunAngularRadius(value: number);
+}
+export {};