@takram/three-clouds 0.1.0

package/src/ShadowMaterial.ts

@@ -0,0 +1,141 @@
+import {
+  GLSL3,
+  Matrix4,
+  RawShaderMaterial,
+  Uniform,
+  Vector2,
+  type Data3DTexture
+} from 'three'
+
+import {
+  define,
+  defineExpression,
+  defineInt,
+  resolveIncludes,
+  unrollLoops
+} from '@takram/three-geospatial'
+import { math, raySphereIntersection } from '@takram/three-geospatial/shaders'
+
+import { defaults } from './qualityPresets'
+import {
+  type AtmosphereUniforms,
+  type CloudLayerUniforms,
+  type CloudParameterUniforms
+} from './uniforms'
+
+import clouds from './shaders/clouds.glsl?raw'
+import parameters from './shaders/parameters.glsl?raw'
+import fragmentShader from './shaders/shadow.frag?raw'
+import vertexShader from './shaders/shadow.vert?raw'
+import structuredSampling from './shaders/structuredSampling.glsl?raw'
+import types from './shaders/types.glsl?raw'
+
+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>
+
+  // Primary raymarch
+  maxIterationCount: Uniform<number>
+  minStepSize: Uniform<number>
+  maxStepSize: Uniform<number>
+  minDensity: Uniform<number>
+  minExtinction: Uniform<number>
+  minTransmittance: Uniform<number>
+  opticalDepthTailScale: Uniform<number>
+}
+
+export class ShadowMaterial extends RawShaderMaterial {
+  declare uniforms: ShadowMaterialUniforms
+
+  constructor({
+    parameterUniforms,
+    layerUniforms,
+    atmosphereUniforms
+  }: ShadowMaterialParameters) {
+    super({
+      name: 'ShadowMaterial',
+      glslVersion: GLSL3,
+      vertexShader,
+      fragmentShader: unrollLoops(
+        resolveIncludes(fragmentShader, {
+          core: {
+            math,
+            raySphereIntersection
+          },
+          types,
+          parameters,
+          structuredSampling,
+          clouds
+        })
+      ),
+      uniforms: {
+        ...parameterUniforms,
+        ...layerUniforms,
+        ...atmosphereUniforms,
+
+        inverseShadowMatrices: new Uniform(
+          Array.from({ length: 4 }, () => new Matrix4()) // Populate the max number of elements
+        ),
+        reprojectionMatrices: new Uniform(
+          Array.from({ length: 4 }, () => new Matrix4()) // Populate the max number of elements
+        ),
+        resolution: new Uniform(new Vector2()),
+        frame: new Uniform(0),
+        stbnTexture: new Uniform(null),
+
+        // Primary raymarch
+        maxIterationCount: new Uniform(defaults.shadow.maxIterationCount),
+        minStepSize: new Uniform(defaults.shadow.minStepSize),
+        maxStepSize: new Uniform(defaults.shadow.maxStepSize),
+        minDensity: new Uniform(defaults.shadow.minDensity),
+        minExtinction: new Uniform(defaults.shadow.minExtinction),
+        minTransmittance: new Uniform(defaults.shadow.minTransmittance),
+        opticalDepthTailScale: new Uniform(2)
+      } satisfies ShadowMaterialUniforms,
+      defines: {
+        SHADOW: '1',
+        TEMPORAL_PASS: '1',
+        TEMPORAL_JITTER: '1'
+      }
+    })
+
+    this.cascadeCount = defaults.shadow.cascadeCount
+  }
+
+  setSize(width: number, height: number): void {
+    this.uniforms.resolution.value.set(width, height)
+  }
+
+  @defineExpression('LOCAL_WEATHER_CHANNELS', {
+    validate: value => /^[rgba]{4}$/.test(value)
+  })
+  localWeatherChannels = 'rgba'
+
+  @defineInt('CASCADE_COUNT', { min: 1, max: 4 })
+  cascadeCount: number = defaults.shadow.cascadeCount
+
+  @define('TEMPORAL_PASS')
+  temporalPass = true
+
+  @define('TEMPORAL_JITTER')
+  temporalJitter = true
+
+  @define('SHAPE_DETAIL')
+  shapeDetail: boolean = defaults.shapeDetail
+
+  @define('TURBULENCE')
+  turbulence: boolean = defaults.turbulence
+}

package/src/ShadowPass.ts

@@ -0,0 +1,185 @@
+import {
+  HalfFloatType,
+  LinearFilter,
+  WebGLArrayRenderTarget,
+  type DataArrayTexture,
+  type TextureDataType,
+  type WebGLRenderer
+} from 'three'
+import invariant from 'tiny-invariant'
+
+import { PassBase, type PassBaseOptions } from './PassBase'
+import { ShaderArrayPass } from './ShaderArrayPass'
+import { ShadowMaterial } from './ShadowMaterial'
+import { ShadowResolveMaterial } from './ShadowResolveMaterial'
+import {
+  type AtmosphereUniforms,
+  type CloudLayerUniforms,
+  type CloudParameterUniforms
+} from './uniforms'
+
+function createRenderTarget(name: string): WebGLArrayRenderTarget {
+  const renderTarget = new WebGLArrayRenderTarget(1, 1, 1, {
+    depthBuffer: false,
+    stencilBuffer: false
+  })
+  // Constructor option doesn't work
+  renderTarget.texture.type = HalfFloatType
+  renderTarget.texture.minFilter = LinearFilter
+  renderTarget.texture.magFilter = LinearFilter
+  renderTarget.texture.name = name
+  return renderTarget
+}
+
+export interface ShadowPassOptions extends PassBaseOptions {
+  parameterUniforms: CloudParameterUniforms
+  layerUniforms: CloudLayerUniforms
+  atmosphereUniforms: AtmosphereUniforms
+}
+
+export class ShadowPass extends PassBase {
+  private currentRenderTarget!: WebGLArrayRenderTarget
+  readonly currentMaterial: ShadowMaterial
+  readonly currentPass: ShaderArrayPass
+  private resolveRenderTarget!: WebGLArrayRenderTarget | null
+  readonly resolveMaterial: ShadowResolveMaterial
+  readonly resolvePass: ShaderArrayPass
+  private historyRenderTarget!: WebGLArrayRenderTarget | null
+
+  private width = 0
+  private height = 0
+
+  constructor({
+    parameterUniforms,
+    layerUniforms,
+    atmosphereUniforms,
+    ...options
+  }: ShadowPassOptions) {
+    super('ShadowPass', options)
+
+    this.currentMaterial = new ShadowMaterial({
+      parameterUniforms,
+      layerUniforms,
+      atmosphereUniforms
+    })
+    this.currentPass = new ShaderArrayPass(this.currentMaterial)
+    this.resolveMaterial = new ShadowResolveMaterial()
+    this.resolvePass = new ShaderArrayPass(this.resolveMaterial)
+
+    this.initRenderTargets()
+  }
+
+  override initialize(
+    renderer: WebGLRenderer,
+    alpha: boolean,
+    frameBufferType: TextureDataType
+  ): void {
+    this.currentPass.initialize(renderer, alpha, frameBufferType)
+    this.resolvePass.initialize(renderer, alpha, frameBufferType)
+  }
+
+  private initRenderTargets(): void {
+    this.currentRenderTarget?.dispose()
+    this.resolveRenderTarget?.dispose()
+    this.historyRenderTarget?.dispose()
+    const current = createRenderTarget('Shadow')
+    const resolve = this.temporalPass ? createRenderTarget('Shadow.A') : null
+    const history = this.temporalPass ? createRenderTarget('Shadow.B') : null
+    this.currentRenderTarget = current
+    this.resolveRenderTarget = resolve
+    this.historyRenderTarget = history
+
+    const resolveUniforms = this.resolveMaterial.uniforms
+    resolveUniforms.inputBuffer.value = current.texture
+    resolveUniforms.historyBuffer.value = history?.texture ?? null
+  }
+
+  private copyShadow(): void {
+    const shadow = this.shadow
+    const currentUniforms = this.currentMaterial.uniforms
+    for (let i = 0; i < shadow.cascadeCount; ++i) {
+      const cascade = shadow.cascades[i]
+      currentUniforms.inverseShadowMatrices.value[i].copy(cascade.inverseMatrix)
+    }
+  }
+
+  private copyReprojection(): void {
+    const shadow = this.shadow
+    const uniforms = this.currentMaterial.uniforms
+    for (let i = 0; i < shadow.cascadeCount; ++i) {
+      const cascade = shadow.cascades[i]
+      uniforms.reprojectionMatrices.value[i].copy(cascade.matrix)
+    }
+  }
+
+  private swapBuffers(): void {
+    invariant(this.historyRenderTarget != null)
+    invariant(this.resolveRenderTarget != null)
+    const nextResolve = this.historyRenderTarget
+    const nextHistory = this.resolveRenderTarget
+    this.resolveRenderTarget = nextResolve
+    this.historyRenderTarget = nextHistory
+    this.resolveMaterial.uniforms.historyBuffer.value = nextHistory.texture
+  }
+
+  update(renderer: WebGLRenderer, frame: number, deltaTime: number): void {
+    this.currentMaterial.uniforms.frame.value = frame
+    this.copyShadow()
+
+    this.currentPass.render(renderer, null, this.currentRenderTarget)
+
+    if (this.temporalPass) {
+      invariant(this.resolveRenderTarget != null)
+      this.resolvePass.render(renderer, null, this.resolveRenderTarget)
+
+      // Store the current view and projection matrices for the next reprojection.
+      this.copyReprojection()
+
+      // Swap resolve and history render targets for the next render.
+      this.swapBuffers()
+    }
+  }
+
+  setSize(
+    width: number,
+    height: number,
+    depth = this.shadow.cascadeCount
+  ): void {
+    this.width = width
+    this.height = height
+
+    this.currentMaterial.cascadeCount = depth
+    this.resolveMaterial.cascadeCount = depth
+    this.currentMaterial.setSize(width, height)
+    this.resolveMaterial.setSize(width, height)
+
+    this.currentRenderTarget.setSize(
+      width,
+      height,
+      this.temporalPass ? depth * 2 : depth // For depth velocity
+    )
+    this.resolveRenderTarget?.setSize(width, height, depth)
+    this.historyRenderTarget?.setSize(width, height, depth)
+  }
+
+  get outputBuffer(): DataArrayTexture {
+    if (this.temporalPass) {
+      // Resolve and history render targets are already swapped.
+      invariant(this.historyRenderTarget != null)
+      return this.historyRenderTarget.texture
+    }
+    return this.currentRenderTarget.texture
+  }
+
+  get temporalPass(): boolean {
+    return this.currentMaterial.temporalPass
+  }
+
+  set temporalPass(value: boolean) {
+    if (value !== this.temporalPass) {
+      this.currentMaterial.temporalPass = value
+      this.initRenderTargets()
+      this.setSize(this.width, this.height)
+    }
+  }
+}

package/src/ShadowResolveMaterial.ts

@@ -0,0 +1,72 @@
+import {
+  GLSL3,
+  RawShaderMaterial,
+  Uniform,
+  Vector2,
+  type DataArrayTexture
+} from 'three'
+
+import {
+  defineInt,
+  resolveIncludes,
+  unrollLoops
+} from '@takram/three-geospatial'
+
+import { defaults } from './qualityPresets'
+
+import fragmentShader from './shaders/shadowResolve.frag?raw'
+import vertexShader from './shaders/shadowResolve.vert?raw'
+import varianceClipping from './shaders/varianceClipping.glsl?raw'
+
+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 class ShadowResolveMaterial extends RawShaderMaterial {
+  declare uniforms: ShadowResolveMaterialUniforms
+
+  constructor({
+    inputBuffer = null,
+    historyBuffer = null
+  }: ShadowResolveMaterialParameters = {}) {
+    super({
+      name: 'ShadowResolveMaterial',
+      glslVersion: GLSL3,
+      vertexShader,
+      fragmentShader: unrollLoops(
+        resolveIncludes(fragmentShader, {
+          varianceClipping
+        })
+      ),
+      uniforms: {
+        inputBuffer: new Uniform(inputBuffer),
+        historyBuffer: new Uniform(historyBuffer),
+        texelSize: new Uniform(new Vector2()),
+        varianceGamma: new Uniform(1),
+        // Use a very slow alpha because a single flickering pixel can be highly
+        // noticeable in shadow maps. This value can be increased if temporal
+        // jitter is turned off in the shadows rendering, but it will suffer
+        // from spatial aliasing.
+        temporalAlpha: new Uniform(0.01)
+      } satisfies ShadowResolveMaterialUniforms,
+      defines: {}
+    })
+  }
+
+  setSize(width: number, height: number): void {
+    this.uniforms.texelSize.value.set(1 / width, 1 / height)
+  }
+
+  @defineInt('CASCADE_COUNT', { min: 1, max: 4 })
+  cascadeCount: number = defaults.shadow.cascadeCount
+}

package/src/Turbulence.ts

@@ -0,0 +1,21 @@
+import { resolveIncludes } from '@takram/three-geospatial'
+import { math } from '@takram/three-geospatial/shaders'
+
+import { ProceduralTextureBase } from './ProceduralTexture'
+
+import perlin from './shaders/perlin.glsl?raw'
+import tileableNoise from './shaders/tileableNoise.glsl?raw'
+import fragmentShader from './shaders/turbulence.frag?raw'
+
+export class Turbulence extends ProceduralTextureBase {
+  constructor() {
+    super({
+      size: 128,
+      fragmentShader: resolveIncludes(fragmentShader, {
+        core: { math },
+        perlin,
+        tileableNoise
+      })
+    })
+  }
+}

package/src/bayer.ts

@@ -0,0 +1,23 @@
+import { Vector2 } from 'three'
+
+// prettier-ignore
+export const bayerIndices = [
+  0, 8, 2, 10,
+  12, 4, 14, 6,
+  3, 11, 1, 9,
+  15, 7, 13, 5
+]
+
+export const bayerOffsets = /*#__PURE__*/ bayerIndices.reduce<Vector2[]>(
+  (result, _, index) => {
+    const offset = new Vector2()
+    for (let i = 0; i < 16; ++i) {
+      if (bayerIndices[i] === index) {
+        offset.set(((i % 4) + 0.5) / 4, (Math.floor(i / 4) + 0.5) / 4)
+        break
+      }
+    }
+    return [...result, offset]
+  },
+  []
+)

package/src/constants.ts

@@ -0,0 +1,8 @@
+export const CLOUD_SHAPE_TEXTURE_SIZE = 128
+export const CLOUD_SHAPE_DETAIL_TEXTURE_SIZE = 32
+
+const ref = '45a1c6c1bb9fd38b3680fd120795ff4c32df68ff'
+export const DEFAULT_LOCAL_WEATHER_URL = `https://media.githubusercontent.com/media/takram-design-engineering/three-geospatial/${ref}/packages/clouds/assets/local_weather.png`
+export const DEFAULT_SHAPE_URL = `https://media.githubusercontent.com/media/takram-design-engineering/three-geospatial/${ref}/packages/clouds/assets/shape.bin`
+export const DEFAULT_SHAPE_DETAIL_URL = `https://media.githubusercontent.com/media/takram-design-engineering/three-geospatial/${ref}/packages/clouds/assets/shape_detail.bin`
+export const DEFAULT_TURBULENCE_URL = `https://media.githubusercontent.com/media/takram-design-engineering/three-geospatial/${ref}/packages/clouds/assets/turbulence.png`

package/src/helpers/FrustumCorners.ts

@@ -0,0 +1,138 @@
+// Based on the following work with slight modifications.
+// https://github.com/StrandedKitty/three-csm/
+// https://github.com/mrdoob/three.js/tree/r169/examples/jsm/csm
+
+/**
+ * MIT License
+ *
+ * Copyright (c) 2019 vtHawk
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+import { Vector3, type Camera, type Matrix4 } from 'three'
+
+declare module 'three' {
+  interface Camera {
+    isOrthographicCamera?: boolean
+  }
+}
+
+export class FrustumCorners {
+  readonly near = [new Vector3(), new Vector3(), new Vector3(), new Vector3()]
+  readonly far = [new Vector3(), new Vector3(), new Vector3(), new Vector3()]
+
+  constructor()
+  constructor(camera: Camera, far: number)
+  constructor(camera?: Camera, far?: number) {
+    if (camera != null && far != null) {
+      this.setFromCamera(camera, far)
+    }
+  }
+
+  clone(): FrustumCorners {
+    return new FrustumCorners().copy(this)
+  }
+
+  copy(other: FrustumCorners): this {
+    for (let i = 0; i < 4; ++i) {
+      this.near[i].copy(other.near[i])
+      this.far[i].copy(other.far[i])
+    }
+    return this
+  }
+
+  setFromCamera(camera: Camera, far: number): this {
+    const isOrthographic = camera.isOrthographicCamera === true
+    const inverseProjectionMatrix = camera.projectionMatrixInverse
+
+    // 3 --- 0
+    // |     |
+    // 2 --- 1
+    // Clip space spans from [-1, 1]
+    this.near[0].set(1, 1, -1)
+    this.near[1].set(1, -1, -1)
+    this.near[2].set(-1, -1, -1)
+    this.near[3].set(-1, 1, -1)
+    for (let i = 0; i < 4; ++i) {
+      this.near[i].applyMatrix4(inverseProjectionMatrix)
+    }
+
+    this.far[0].set(1, 1, 1)
+    this.far[1].set(1, -1, 1)
+    this.far[2].set(-1, -1, 1)
+    this.far[3].set(-1, 1, 1)
+    for (let i = 0; i < 4; ++i) {
+      const corner = this.far[i]
+      corner.applyMatrix4(inverseProjectionMatrix)
+      const absZ = Math.abs(corner.z)
+      if (isOrthographic) {
+        corner.z *= Math.min(far / absZ, 1)
+      } else {
+        corner.multiplyScalar(Math.min(far / absZ, 1))
+      }
+    }
+    return this
+  }
+
+  split(
+    clipDepths: readonly number[],
+    result: FrustumCorners[] = []
+  ): FrustumCorners[] {
+    for (let index = 0; index < clipDepths.length; ++index) {
+      const frustum = (result[index] ??= new FrustumCorners())
+      if (index === 0) {
+        for (let i = 0; i < 4; ++i) {
+          frustum.near[i].copy(this.near[i])
+        }
+      } else {
+        for (let i = 0; i < 4; ++i) {
+          frustum.near[i].lerpVectors(
+            this.near[i],
+            this.far[i],
+            clipDepths[index - 1]
+          )
+        }
+      }
+      if (index === clipDepths.length - 1) {
+        for (let i = 0; i < 4; ++i) {
+          frustum.far[i].copy(this.far[i])
+        }
+      } else {
+        for (let i = 0; i < 4; ++i) {
+          frustum.far[i].lerpVectors(
+            this.near[i],
+            this.far[i],
+            clipDepths[index]
+          )
+        }
+      }
+    }
+    result.length = clipDepths.length
+    return result
+  }
+
+  applyMatrix4(matrix: Matrix4): this {
+    for (let i = 0; i < 4; ++i) {
+      this.near[i].applyMatrix4(matrix)
+      this.far[i].applyMatrix4(matrix)
+    }
+    return this
+  }
+}

package/src/helpers/setArrayRenderTargetLayers.ts

@@ -0,0 +1,32 @@
+import { type WebGLArrayRenderTarget, type WebGLRenderer } from 'three'
+import invariant from 'tiny-invariant'
+
+export function setArrayRenderTargetLayers(
+  renderer: WebGLRenderer,
+  outputBuffer: WebGLArrayRenderTarget
+): void {
+  const glTexture = (
+    renderer.properties.get(outputBuffer.texture) as {
+      __webglTexture?: WebGLTexture
+    }
+  ).__webglTexture
+
+  const gl = renderer.getContext()
+  invariant(gl instanceof WebGL2RenderingContext)
+
+  renderer.setRenderTarget(outputBuffer)
+  const drawBuffers: number[] = []
+  if (glTexture != null) {
+    for (let layer = 0; layer < outputBuffer.depth; ++layer) {
+      gl.framebufferTextureLayer(
+        gl.FRAMEBUFFER,
+        gl.COLOR_ATTACHMENT0 + layer,
+        glTexture,
+        0,
+        layer
+      )
+      drawBuffers.push(gl.COLOR_ATTACHMENT0 + layer)
+    }
+  }
+  gl.drawBuffers(drawBuffers)
+}

package/src/helpers/splitFrustum.ts

@@ -0,0 +1,59 @@
+import { lerp } from '@takram/three-geospatial'
+
+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
+
+// See: https://developer.nvidia.com/gpugems/gpugems3/part-ii-light-and-shadows/chapter-10-parallel-split-shadow-maps-programmable-gpus
+const modes: FrustumSplitFunctions = {
+  uniform: (count, near, far, _, result = []) => {
+    for (let i = 0; i < count; ++i) {
+      result[i] = (near + ((far - near) * (i + 1)) / count) / far
+    }
+    result.length = count
+    return result
+  },
+
+  logarithmic: (count, near, far, _, result = []) => {
+    for (let i = 0; i < count; ++i) {
+      result[i] = (near * (far / near) ** ((i + 1) / count)) / far
+    }
+    result.length = count
+    return result
+  },
+
+  practical: (count, near, far, lambda = 0.5, result = []) => {
+    for (let i = 0; i < count; ++i) {
+      const uniform = (near + ((far - near) * (i + 1)) / count) / far
+      const logarithmic = (near * (far / near) ** ((i + 1) / count)) / far
+      result[i] = lerp(uniform, logarithmic, lambda)
+    }
+    result.length = count
+    return result
+  }
+}
+
+export const frustumSplitFunctions = modes
+
+export function splitFrustum(
+  mode: FrustumSplitMode,
+  count: number,
+  near: number,
+  far: number,
+  lambda?: number,
+  result: number[] = []
+): number[] {
+  return modes[mode](count, near, far, lambda, result)
+}

package/src/index.ts

@@ -0,0 +1,14 @@
+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'