@takram/three-clouds 0.1.0

package/src/shaders/clouds.frag

@@ -0,0 +1,996 @@
+precision highp float;
+precision highp sampler3D;
+precision highp sampler2DArray;
+
+#include <common>
+#include <packing>
+
+#include "core/depth"
+#include "core/math"
+#include "core/turbo"
+#include "core/generators"
+#include "core/raySphereIntersection"
+#include "core/cascadedShadowMaps"
+#include "core/interleavedGradientNoise"
+#include "core/vogelDisk"
+#include "atmosphere/parameters"
+#include "atmosphere/functions"
+#include "types"
+#include "parameters"
+#include "clouds"
+
+#if !defined(RECIPROCAL_PI4)
+#define RECIPROCAL_PI4 (0.07957747154594767)
+#endif // !defined(RECIPROCAL_PI4)
+
+uniform sampler2D depthBuffer;
+uniform mat4 viewMatrix;
+uniform mat4 reprojectionMatrix;
+uniform float cameraNear;
+uniform float cameraFar;
+uniform float cameraHeight;
+uniform vec2 temporalJitter;
+uniform vec2 targetUvScale;
+uniform float mipLevelScale;
+
+// Scattering
+const vec2 scatterAnisotropy = vec2(SCATTER_ANISOTROPY_1, SCATTER_ANISOTROPY_2);
+const float scatterAnisotropyMix = SCATTER_ANISOTROPY_MIX;
+uniform float skyIrradianceScale;
+uniform float groundIrradianceScale;
+uniform float powderScale;
+uniform float powderExponent;
+
+// Primary raymarch
+uniform int maxIterationCount;
+uniform float minStepSize;
+uniform float maxStepSize;
+uniform float maxRayDistance;
+uniform float perspectiveStepScale;
+
+// Secondary raymarch
+uniform int maxIterationCountToSun;
+uniform int maxIterationCountToGround;
+uniform float minSecondaryStepSize;
+uniform float secondaryStepScale;
+
+// Beer shadow map
+uniform sampler2DArray shadowBuffer;
+uniform vec2 shadowTexelSize;
+uniform vec2 shadowIntervals[SHADOW_CASCADE_COUNT];
+uniform mat4 shadowMatrices[SHADOW_CASCADE_COUNT];
+uniform float shadowFar;
+uniform float maxShadowFilterRadius;
+
+// Shadow length
+#ifdef SHADOW_LENGTH
+uniform int maxShadowLengthIterationCount;
+uniform float minShadowLengthStepSize;
+uniform float maxShadowLengthRayDistance;
+#endif // SHADOW_LENGTH
+
+in vec2 vUv;
+in vec3 vCameraPosition;
+in vec3 vCameraDirection; // Direction to the center of screen
+in vec3 vRayDirection; // Direction to the texel
+in vec3 vEllipsoidCenter;
+in GroundIrradiance vGroundIrradiance;
+in CloudsIrradiance vCloudsIrradiance;
+
+layout(location = 0) out vec4 outputColor;
+layout(location = 1) out vec3 outputDepthVelocity;
+#ifdef SHADOW_LENGTH
+layout(location = 2) out float outputShadowLength;
+#endif // SHADOW_LENGTH
+
+float readDepth(const vec2 uv) {
+  #if DEPTH_PACKING == 3201
+  return unpackRGBAToDepth(texture(depthBuffer, uv));
+  #else // DEPTH_PACKING == 3201
+  return texture(depthBuffer, uv).r;
+  #endif // DEPTH_PACKING == 3201
+}
+
+float getViewZ(const float depth) {
+  #ifdef PERSPECTIVE_CAMERA
+  return perspectiveDepthToViewZ(depth, cameraNear, cameraFar);
+  #else // PERSPECTIVE_CAMERA
+  return orthographicDepthToViewZ(depth, cameraNear, cameraFar);
+  #endif // PERSPECTIVE_CAMERA
+}
+
+vec3 ECEFToWorld(const vec3 positionECEF) {
+  return mat3(ellipsoidMatrix) * (positionECEF + vEllipsoidCenter);
+}
+
+vec2 getShadowUv(const vec3 worldPosition, const int cascadeIndex) {
+  vec4 clip = shadowMatrices[cascadeIndex] * vec4(worldPosition, 1.0);
+  clip /= clip.w;
+  return clip.xy * 0.5 + 0.5;
+}
+
+float getDistanceToShadowTop(const vec3 rayPosition) {
+  // Distance to the top of the shadows along the sun direction, which matches
+  // the ray origin of BSM.
+  return raySphereSecondIntersection(
+    rayPosition,
+    sunDirection,
+    vec3(0.0),
+    bottomRadius + shadowTopHeight
+  );
+}
+
+#ifdef DEBUG_SHOW_CASCADES
+
+const vec3 cascadeColors[4] = vec3[4](
+  vec3(1.0, 0.0, 0.0),
+  vec3(0.0, 1.0, 0.0),
+  vec3(0.0, 0.0, 1.0),
+  vec3(1.0, 1.0, 0.0)
+);
+
+vec3 getCascadeColor(const vec3 rayPosition) {
+  vec3 worldPosition = ECEFToWorld(rayPosition);
+  int cascadeIndex = getCascadeIndex(
+    viewMatrix,
+    worldPosition,
+    shadowIntervals,
+    cameraNear,
+    shadowFar
+  );
+  vec2 uv = getShadowUv(worldPosition, cascadeIndex);
+  if (uv.x < 0.0 || uv.x > 1.0 || uv.y < 0.0 || uv.y > 1.0) {
+    return vec3(1.0);
+  }
+  return cascadeColors[cascadeIndex];
+}
+
+vec3 getFadedCascadeColor(const vec3 rayPosition, const float jitter) {
+  vec3 worldPosition = ECEFToWorld(rayPosition);
+  int cascadeIndex = getFadedCascadeIndex(
+    viewMatrix,
+    worldPosition,
+    shadowIntervals,
+    cameraNear,
+    shadowFar,
+    jitter
+  );
+  return cascadeIndex >= 0
+    ? cascadeColors[cascadeIndex]
+    : vec3(1.0);
+}
+
+#endif // DEBUG_SHOW_CASCADES
+
+float readShadowOpticalDepth(
+  const vec2 uv,
+  const float distanceToTop,
+  const float distanceOffset,
+  const int cascadeIndex
+) {
+  // r: frontDepth, g: meanExtinction, b: maxOpticalDepth, a: maxOpticalDepthTail
+  // Also see the discussion here: https://x.com/shotamatsuda/status/1885322308908442106
+  vec4 shadow = texture(shadowBuffer, vec3(uv, float(cascadeIndex)));
+  float distanceToFront = max(0.0, distanceToTop - distanceOffset - shadow.r);
+  return min(shadow.b + shadow.a, shadow.g * distanceToFront);
+}
+
+float sampleShadowOpticalDepthPCF(
+  const vec3 worldPosition,
+  const float distanceToTop,
+  const float distanceOffset,
+  const float radius,
+  const int cascadeIndex
+) {
+  vec2 uv = getShadowUv(worldPosition, cascadeIndex);
+  if (uv.x < 0.0 || uv.x > 1.0 || uv.y < 0.0 || uv.y > 1.0) {
+    return 0.0;
+  }
+  if (radius < 0.1) {
+    return readShadowOpticalDepth(uv, distanceToTop, distanceOffset, cascadeIndex);
+  }
+  float sum = 0.0;
+  vec2 offset;
+  #pragma unroll_loop_start
+  for (int i = 0; i < 16; ++i) {
+    #if UNROLLED_LOOP_INDEX < SHADOW_SAMPLE_COUNT
+    offset = vogelDisk(
+      UNROLLED_LOOP_INDEX,
+      SHADOW_SAMPLE_COUNT,
+      interleavedGradientNoise(gl_FragCoord.xy + temporalJitter * resolution) * PI2
+    );
+    sum += readShadowOpticalDepth(
+      uv + offset * radius * shadowTexelSize,
+      distanceToTop,
+      distanceOffset,
+      cascadeIndex
+    );
+    #endif // UNROLLED_LOOP_INDEX < SHADOW_SAMPLE_COUNT
+  }
+  #pragma unroll_loop_end
+  return sum / float(SHADOW_SAMPLE_COUNT);
+}
+
+float sampleShadowOpticalDepth(
+  const vec3 rayPosition,
+  const float distanceOffset,
+  const float radius,
+  const float jitter
+) {
+  float distanceToTop = getDistanceToShadowTop(rayPosition);
+  if (distanceToTop <= 0.0) {
+    return 0.0;
+  }
+  vec3 worldPosition = ECEFToWorld(rayPosition);
+  int cascadeIndex = getFadedCascadeIndex(
+    viewMatrix,
+    worldPosition,
+    shadowIntervals,
+    cameraNear,
+    shadowFar,
+    jitter
+  );
+  return cascadeIndex >= 0
+    ? sampleShadowOpticalDepthPCF(
+      worldPosition,
+      distanceToTop,
+      distanceOffset,
+      radius,
+      cascadeIndex
+    )
+    : 0.0;
+}
+
+#ifdef DEBUG_SHOW_SHADOW_MAP
+vec4 getCascadedShadowMaps(vec2 uv) {
+  vec4 coord = vec4(vUv, vUv - 0.5) * 2.0;
+  vec4 shadow = vec4(0.0);
+  if (uv.y > 0.5) {
+    if (uv.x < 0.5) {
+      shadow = texture(shadowBuffer, vec3(coord.xw, 0.0));
+    } else {
+      #if SHADOW_CASCADE_COUNT > 1
+      shadow = texture(shadowBuffer, vec3(coord.zw, 1.0));
+      #endif // SHADOW_CASCADE_COUNT > 1
+    }
+  } else {
+    if (uv.x < 0.5) {
+      #if SHADOW_CASCADE_COUNT > 2
+      shadow = texture(shadowBuffer, vec3(coord.xy, 2.0));
+      #endif // SHADOW_CASCADE_COUNT > 2
+    } else {
+      #if SHADOW_CASCADE_COUNT > 3
+      shadow = texture(shadowBuffer, vec3(coord.zy, 3.0));
+      #endif // SHADOW_CASCADE_COUNT > 3
+    }
+  }
+
+  #if !defined(DEBUG_SHOW_SHADOW_MAP_TYPE)
+  #define DEBUG_SHOW_SHADOW_MAP_TYPE (0)
+  #endif // !defined(DEBUG_SHOW_SHADOW_MAP_TYPE
+
+  const float frontDepthScale = 1e-5;
+  const float meanExtinctionScale = 10.0;
+  const float maxOpticalDepthScale = 0.01;
+  vec3 color;
+  #if DEBUG_SHOW_SHADOW_MAP_TYPE == 1
+  color = vec3(shadow.r * frontDepthScale);
+  #elif DEBUG_SHOW_SHADOW_MAP_TYPE == 2
+  color = vec3(shadow.g * meanExtinctionScale);
+  #elif DEBUG_SHOW_SHADOW_MAP_TYPE == 3
+  color = vec3((shadow.b + shadow.a) * maxOpticalDepthScale);
+  #else // DEBUG_SHOW_SHADOW_MAP_TYPE
+  color =
+    (shadow.rgb + vec3(0.0, 0.0, shadow.a)) *
+    vec3(frontDepthScale, meanExtinctionScale, maxOpticalDepthScale);
+  #endif // DEBUG_SHOW_SHADOW_MAP_TYPE
+  return vec4(color, 1.0);
+}
+#endif // DEBUG_SHOW_SHADOW_MAP
+
+vec2 henyeyGreenstein(const vec2 g, const float cosTheta) {
+  vec2 g2 = g * g;
+  // prettier-ignore
+  return RECIPROCAL_PI4 *
+    ((1.0 - g2) / max(vec2(1e-7), pow(1.0 + g2 - 2.0 * g * cosTheta, vec2(1.5))));
+}
+
+#ifdef ACCURATE_PHASE_FUNCTION
+
+float draine(float u, float g, float a) {
+  float g2 = g * g;
+  // prettier-ignore
+  return (1.0 - g2) *
+    (1.0 + a * u * u) /
+    (4.0 * (1.0 + a * (1.0 + 2.0 * g2) / 3.0) * PI * pow(1.0 + g2 - 2.0 * g * u, 1.5));
+}
+
+// Numerically-fitted large particles (d=10) phase function It won't be
+// plausible without a more precise multiple scattering.
+// Reference: https://research.nvidia.com/labs/rtr/approximate-mie/
+float phaseFunction(const float cosTheta, const float attenuation) {
+  const float gHG = 0.988176691700256; // exp(-0.0990567/(d-1.67154))
+  const float gD = 0.5556712547839497; // exp(-2.20679/(d+3.91029) - 0.428934)
+  const float alpha = 21.995520856274638; // exp(3.62489 - 8.29288/(d+5.52825))
+  const float weight = 0.4819554318404214; // exp(-0.599085/(d-0.641583)-0.665888)
+  return mix(
+    henyeyGreenstein(vec2(gHG) * attenuation, cosTheta).x,
+    draine(cosTheta, gD * attenuation, alpha),
+    weight
+  );
+}
+
+#else // ACCURATE_PHASE_FUNCTION
+
+float phaseFunction(const float cosTheta, const float attenuation) {
+  const vec2 g = scatterAnisotropy;
+  const vec2 weights = vec2(1.0 - scatterAnisotropyMix, scatterAnisotropyMix);
+  // A similar approximation is described in the Frostbite's paper, where phase
+  // angle is attenuated instead of anisotropy.
+  return dot(henyeyGreenstein(g * attenuation, cosTheta), weights);
+}
+
+#endif // ACCURATE_PHASE_FUNCTION
+
+float phaseFunction(const float cosTheta) {
+  return phaseFunction(cosTheta, 1.0);
+}
+
+float marchOpticalDepth(
+  const vec3 rayOrigin,
+  const vec3 rayDirection,
+  const int maxIterationCount,
+  const float mipLevel,
+  const float jitter,
+  out float rayDistance
+) {
+  int iterationCount = int(
+    max(0.0, remap(mipLevel, 0.0, 1.0, float(maxIterationCount + 1), 1.0) - jitter)
+  );
+  if (iterationCount == 0) {
+    // Fudge factor to approximate the mean optical depth.
+    // TODO: Remove it.
+    return 0.5;
+  }
+  float stepSize = minSecondaryStepSize / float(iterationCount);
+  float nextDistance = stepSize * jitter;
+  float opticalDepth = 0.0;
+  for (int i = 0; i < iterationCount; ++i) {
+    rayDistance = nextDistance;
+    vec3 position = rayDistance * rayDirection + rayOrigin;
+    vec2 uv = getGlobeUv(position);
+    float height = length(position) - bottomRadius;
+    WeatherSample weather = sampleWeather(uv, height, mipLevel);
+    MediaSample media = sampleMedia(weather, position, uv, mipLevel, jitter);
+    opticalDepth += media.extinction * stepSize;
+    nextDistance += stepSize;
+    stepSize *= secondaryStepScale;
+  }
+  return opticalDepth;
+}
+
+float marchOpticalDepth(
+  const vec3 rayOrigin,
+  const vec3 rayDirection,
+  const int maxIterationCount,
+  const float mipLevel,
+  const float jitter
+) {
+  float rayDistance;
+  return marchOpticalDepth(
+    rayOrigin,
+    rayDirection,
+    maxIterationCount,
+    mipLevel,
+    jitter,
+    rayDistance
+  );
+}
+
+float approximateMultipleScattering(const float opticalDepth, const float cosTheta) {
+  // Multiple scattering approximation
+  // See: https://fpsunflower.github.io/ckulla/data/oz_volumes.pdf
+  // a: attenuation, b: contribution, c: phase attenuation
+  vec3 coeffs = vec3(1.0); // [a, b, c]
+  const vec3 attenuation = vec3(0.5, 0.5, 0.5); // Should satisfy a <= b
+  float scattering = 0.0;
+  float beerLambert;
+  #pragma unroll_loop_start
+  for (int i = 0; i < 12; ++i) {
+    #if UNROLLED_LOOP_INDEX < MULTI_SCATTERING_OCTAVES
+    beerLambert = exp(-opticalDepth * coeffs.y);
+    scattering += coeffs.x * beerLambert * phaseFunction(cosTheta, coeffs.z);
+    coeffs *= attenuation;
+    #endif // UNROLLED_LOOP_INDEX < MULTI_SCATTERING_OCTAVES
+  }
+  #pragma unroll_loop_end
+  return scattering;
+}
+
+// TODO: Construct spherical harmonics of degree 2 using 2 sample points
+// positioned near the horizon occlusion points on the sun direction plane.
+vec3 getGroundSunSkyIrradiance(
+  const vec3 position,
+  const vec3 surfaceNormal,
+  const float height,
+  out vec3 skyIrradiance
+) {
+  #ifdef ACCURATE_SUN_SKY_IRRADIANCE
+  return GetSunAndSkyIrradiance(
+    (position - surfaceNormal * height) * METER_TO_LENGTH_UNIT,
+    sunDirection,
+    skyIrradiance
+  );
+  #else // ACCURATE_SUN_SKY_IRRADIANCE
+  skyIrradiance = vGroundIrradiance.sky;
+  return vGroundIrradiance.sun;
+  #endif // ACCURATE_SUN_SKY_IRRADIANCE
+}
+
+vec3 getCloudsSunSkyIrradiance(const vec3 position, const float height, out vec3 skyIrradiance) {
+  #ifdef ACCURATE_SUN_SKY_IRRADIANCE
+  return GetSunAndSkyIrradiance(position * METER_TO_LENGTH_UNIT, sunDirection, skyIrradiance);
+  #else // ACCURATE_SUN_SKY_IRRADIANCE
+  float alpha = remapClamped(height, minHeight, maxHeight);
+  skyIrradiance = mix(vCloudsIrradiance.minSky, vCloudsIrradiance.maxSky, alpha);
+  return mix(vCloudsIrradiance.minSun, vCloudsIrradiance.maxSun, alpha);
+  #endif // ACCURATE_SUN_SKY_IRRADIANCE
+}
+
+#ifdef GROUND_IRRADIANCE
+vec3 approximateIrradianceFromGround(
+  const vec3 position,
+  const vec3 surfaceNormal,
+  const float height,
+  const float mipLevel,
+  const float jitter
+) {
+  float opticalDepthToGround = marchOpticalDepth(
+    position,
+    -surfaceNormal,
+    maxIterationCountToGround,
+    mipLevel,
+    jitter
+  );
+  vec3 skyIrradiance;
+  vec3 sunIrradiance = getGroundSunSkyIrradiance(position, surfaceNormal, height, skyIrradiance);
+  const float groundAlbedo = 0.3;
+  vec3 groundIrradiance = skyIrradiance + (1.0 - coverage) * sunIrradiance * RECIPROCAL_PI2;
+  vec3 bouncedLight = groundAlbedo * RECIPROCAL_PI * groundIrradiance;
+  vec3 bouncedIrradiance = bouncedLight * exp(-opticalDepthToGround);
+  return albedo * bouncedIrradiance * RECIPROCAL_PI4 * groundIrradianceScale;
+}
+#endif // GROUND_IRRADIANCE
+
+vec4 marchClouds(
+  const vec3 rayOrigin,
+  const vec3 rayDirection,
+  const vec2 rayNearFar,
+  const float cosTheta,
+  const float jitter,
+  const float rayStartTexelsPerPixel,
+  out float frontDepth,
+  out ivec3 sampleCount
+) {
+  vec3 radianceIntegral = vec3(0.0);
+  float transmittanceIntegral = 1.0;
+  float weightedDistanceSum = 0.0;
+  float transmittanceSum = 0.0;
+
+  float maxRayDistance = rayNearFar.y - rayNearFar.x;
+  float stepSize = minStepSize + (perspectiveStepScale - 1.0) * rayNearFar.x;
+  // I don't understand why spatial aliasing remains unless doubling the jitter.
+  float rayDistance = stepSize * jitter * 2.0;
+
+  for (int i = 0; i < maxIterationCount; ++i) {
+    if (rayDistance > maxRayDistance) {
+      break; // Termination
+    }
+
+    vec3 position = rayDistance * rayDirection + rayOrigin;
+    float height = length(position) - bottomRadius;
+    float mipLevel = log2(max(1.0, rayStartTexelsPerPixel + rayDistance * 1e-5));
+
+    #if !defined(DEBUG_MARCH_INTERVALS)
+    if (insideLayerIntervals(height)) {
+      stepSize *= perspectiveStepScale;
+      rayDistance += mix(stepSize, maxStepSize, min(1.0, mipLevel));
+      continue;
+    }
+    #endif // !defined(DEBUG_MARCH_INTERVALS)
+
+    // Sample rough weather.
+    vec2 uv = getGlobeUv(position);
+    WeatherSample weather = sampleWeather(uv, height, mipLevel);
+
+    #ifdef DEBUG_SHOW_SAMPLE_COUNT
+    ++sampleCount.x;
+    #endif // DEBUG_SHOW_SAMPLE_COUNT
+
+    if (!any(greaterThan(weather.density, vec4(minDensity)))) {
+      // Step longer in empty space.
+      // TODO: This produces banding artifacts.
+      // Possible improvement: Binary search refinement
+      stepSize *= perspectiveStepScale;
+      rayDistance += mix(stepSize, maxStepSize, min(1.0, mipLevel));
+      continue;
+    }
+
+    // Sample detailed participating media.
+    MediaSample media = sampleMedia(weather, position, uv, mipLevel, jitter, sampleCount);
+
+    if (media.extinction > minExtinction) {
+      vec3 skyIrradiance;
+      vec3 sunIrradiance = getCloudsSunSkyIrradiance(position, height, skyIrradiance);
+      vec3 surfaceNormal = normalize(position);
+
+      // March optical depth to the sun for finer details, which BSM lacks.
+      float sunRayDistance = 0.0;
+      float opticalDepth = marchOpticalDepth(
+        position,
+        sunDirection,
+        maxIterationCountToSun,
+        mipLevel,
+        jitter,
+        sunRayDistance
+      );
+
+      if (height < shadowTopHeight) {
+        // Obtain the optical depth from BSM at the ray position.
+        opticalDepth += sampleShadowOpticalDepth(
+          position,
+          // Take account of only positions further than the marched ray
+          // distance.
+          sunRayDistance,
+          // Apply PCF only when the sun is close to the horizon.
+          maxShadowFilterRadius * remapClamped(dot(sunDirection, surfaceNormal), 0.1, 0.0),
+          jitter
+        );
+      }
+
+      float scattering = approximateMultipleScattering(opticalDepth, cosTheta);
+      vec3 radiance = albedo * sunIrradiance * scattering;
+
+      #ifdef GROUND_IRRADIANCE
+      // Fudge factor for the irradiance from ground.
+      if (height < shadowTopHeight && mipLevel < 0.5) {
+        radiance += approximateIrradianceFromGround(
+          position,
+          surfaceNormal,
+          height,
+          mipLevel,
+          jitter
+        );
+      }
+      #endif // GROUND_IRRADIANCE
+
+      // Crude approximation of sky gradient. Better than none in the shadows.
+      float skyGradient = dot(0.5 + weather.heightFraction, media.weight);
+      radiance += albedo * skyIrradiance * RECIPROCAL_PI4 * skyGradient * skyIrradianceScale;
+
+      // Finally multiply by extinction (redundant but kept for clarity).
+      radiance *= media.extinction;
+
+      #ifdef POWDER
+      radiance *= 1.0 - powderScale * exp(-media.extinction * powderExponent);
+      #endif // POWDER
+
+      #ifdef DEBUG_SHOW_CASCADES
+      if (height < shadowTopHeight) {
+        radiance = 1e-3 * getFadedCascadeColor(position, jitter);
+      }
+      #endif // DEBUG_SHOW_CASCADES
+
+      // Energy-conserving analytical integration of scattered light
+      // See 5.6.3 in https://media.contentapi.ea.com/content/dam/eacom/frostbite/files/s2016-pbs-frostbite-sky-clouds-new.pdf
+      float transmittance = exp(-media.extinction * stepSize);
+      float clampedExtinction = max(media.extinction, 1e-7);
+      vec3 scatteringIntegral = (radiance - radiance * transmittance) / clampedExtinction;
+      radianceIntegral += transmittanceIntegral * scatteringIntegral;
+      transmittanceIntegral *= transmittance;
+
+      // Aerial perspective affecting clouds
+      // See 5.9.1 in https://media.contentapi.ea.com/content/dam/eacom/frostbite/files/s2016-pbs-frostbite-sky-clouds-new.pdf
+      weightedDistanceSum += rayDistance * transmittanceIntegral;
+      transmittanceSum += transmittanceIntegral;
+    }
+
+    if (transmittanceIntegral <= minTransmittance) {
+      break; // Early termination
+    }
+
+    // Take a shorter step because we've already hit the clouds.
+    stepSize *= perspectiveStepScale;
+    rayDistance += stepSize;
+  }
+
+  // The final product of 5.9.1 and we'll evaluate this in aerial perspective.
+  frontDepth = transmittanceSum > 0.0 ? weightedDistanceSum / transmittanceSum : -1.0;
+
+  return vec4(radianceIntegral, remapClamped(transmittanceIntegral, 1.0, minTransmittance));
+}
+
+#ifdef SHADOW_LENGTH
+
+float marchShadowLength(
+  const vec3 rayOrigin,
+  const vec3 rayDirection,
+  const vec2 rayNearFar,
+  const float jitter
+) {
+  float shadowLength = 0.0;
+  float maxRayDistance = rayNearFar.y - rayNearFar.x;
+  float stepSize = minShadowLengthStepSize;
+  float rayDistance = stepSize * jitter;
+  const float attenuationFactor = 1.0 - 1e-3;
+  float attenuation = 1.0;
+
+  // TODO: This march is closed, and sample resolution can be much lower.
+  // Refining the termination by binary search will make it much more efficient.
+  for (int i = 0; i < maxShadowLengthIterationCount; ++i) {
+    if (rayDistance > maxRayDistance) {
+      break; // Termination
+    }
+    vec3 position = rayDistance * rayDirection + rayOrigin;
+    float opticalDepth = sampleShadowOpticalDepth(position, 0.0, 0.0, jitter);
+    shadowLength += (1.0 - exp(-opticalDepth)) * stepSize * attenuation;
+
+    // Hack to prevent over-integration of shadow length. The shadow should be
+    // attenuated by the inscatter as the ray travels further.
+    attenuation *= attenuationFactor;
+    if (attenuation < 1e-5) {
+      break;
+    }
+
+    stepSize *= perspectiveStepScale;
+    rayDistance += stepSize;
+  }
+  return shadowLength;
+}
+
+#endif // SHADOW_LENGTH
+
+#ifdef HAZE
+
+vec4 approximateHaze(
+  const vec3 rayOrigin,
+  const vec3 rayDirection,
+  const float maxRayDistance,
+  const float cosTheta,
+  const float shadowLength
+) {
+  float modulation = remapClamped(coverage, 0.2, 0.4);
+  if (cameraHeight * modulation < 0.0) {
+    return vec4(0.0);
+  }
+  float density = modulation * hazeDensityScale * exp(-cameraHeight * hazeExponent);
+  if (density < 1e-7) {
+    return vec4(0.0); // Prevent artifact in views from space
+  }
+
+  // Analytical optical depth where density exponentially decreases with height.
+  // Based on: https://iquilezles.org/articles/fog/
+  float angle = max(dot(normalize(rayOrigin), rayDirection), 1e-5);
+  float exponent = angle * hazeExponent;
+  // Derive the optical depths separately for with and without shadow length.
+  float expTerm = 1.0 - exp(-maxRayDistance * exponent);
+  float shadowExpTerm = 1.0 - exp(-min(maxRayDistance, shadowLength) * exponent);
+  float linearTerm = density / hazeExponent / angle;
+  float opticalDepth = expTerm * linearTerm;
+  float effectiveOpticalDepth = max((expTerm - shadowExpTerm) * linearTerm, 0.0);
+
+  vec3 skyIrradiance = vGroundIrradiance.sky;
+  vec3 sunIrradiance = vGroundIrradiance.sun;
+  vec3 irradiance = sunIrradiance * phaseFunction(cosTheta);
+  irradiance += skyIrradiance * RECIPROCAL_PI4 * skyIrradianceScale;
+  vec3 inscatter = albedo * irradiance * saturate(1.0 - exp(-effectiveOpticalDepth));
+
+  // Inscatter is attenuated by shadow length, but transmittance is not.
+  return vec4(inscatter, saturate(1.0 - exp(-opticalDepth)));
+}
+
+#endif // HAZE
+
+void applyAerialPerspective(
+  const vec3 cameraPosition,
+  const vec3 frontPosition,
+  const float shadowLength,
+  inout vec4 color
+) {
+  vec3 transmittance;
+  vec3 inscatter = GetSkyRadianceToPoint(
+    cameraPosition * METER_TO_LENGTH_UNIT,
+    frontPosition * METER_TO_LENGTH_UNIT,
+    shadowLength * METER_TO_LENGTH_UNIT,
+    sunDirection,
+    transmittance
+  );
+  float clampedAlpha = max(color.a, 1e-7);
+  color.rgb = mix(vec3(0.0), color.rgb * transmittance / clampedAlpha + inscatter, color.a);
+}
+
+bool rayIntersectsGround(const vec3 cameraPosition, const vec3 rayDirection) {
+  float r = length(cameraPosition);
+  float mu = dot(cameraPosition, rayDirection) / r;
+  return mu < 0.0 && r * r * (mu * mu - 1.0) + bottomRadius * bottomRadius >= 0.0;
+}
+
+struct IntersectionResult {
+  bool ground;
+  vec4 first;
+  vec4 second;
+};
+
+IntersectionResult getIntersections(const vec3 cameraPosition, const vec3 rayDirection) {
+  IntersectionResult intersections;
+  intersections.ground = rayIntersectsGround(cameraPosition, rayDirection);
+  raySphereIntersections(
+    cameraPosition,
+    rayDirection,
+    bottomRadius + vec4(0.0, minHeight, maxHeight, shadowTopHeight),
+    intersections.first,
+    intersections.second
+  );
+  return intersections;
+}
+
+vec2 getRayNearFar(const IntersectionResult intersections) {
+  vec2 nearFar;
+  if (cameraHeight < minHeight) {
+    // View below the clouds
+    if (intersections.ground) {
+      nearFar = vec2(-1.0); // No clouds to the ground
+    } else {
+      nearFar = vec2(intersections.second.y, intersections.second.z);
+      nearFar.y = min(nearFar.y, maxRayDistance);
+    }
+  } else if (cameraHeight < maxHeight) {
+    // View inside the total cloud layer
+    if (intersections.ground) {
+      nearFar = vec2(cameraNear, intersections.first.y);
+    } else {
+      nearFar = vec2(cameraNear, intersections.second.z);
+    }
+  } else {
+    // View above the clouds
+    nearFar = vec2(intersections.first.z, intersections.second.z);
+    if (intersections.ground) {
+      // Clamp the ray at the min height.
+      nearFar.y = intersections.first.y;
+    }
+  }
+  return nearFar;
+}
+
+#ifdef SHADOW_LENGTH
+vec2 getShadowRayNearFar(const IntersectionResult intersections) {
+  vec2 nearFar;
+  if (cameraHeight < shadowTopHeight) {
+    if (intersections.ground) {
+      nearFar = vec2(cameraNear, intersections.first.x);
+    } else {
+      nearFar = vec2(cameraNear, intersections.second.w);
+    }
+  } else {
+    nearFar = vec2(intersections.first.w, intersections.second.w);
+    if (intersections.ground) {
+      // Clamp the ray at the ground.
+      nearFar.y = intersections.first.x;
+    }
+  }
+  nearFar.y = min(nearFar.y, maxShadowLengthRayDistance);
+  return nearFar;
+}
+#endif // SHADOW_LENGTH
+
+#ifdef HAZE
+vec2 getHazeRayNearFar(const IntersectionResult intersections) {
+  vec2 nearFar;
+  if (cameraHeight < maxHeight) {
+    if (intersections.ground) {
+      nearFar = vec2(cameraNear, intersections.first.x);
+    } else {
+      nearFar = vec2(cameraNear, intersections.second.z);
+    }
+  } else {
+    nearFar = vec2(cameraNear, intersections.second.z);
+    if (intersections.ground) {
+      // Clamp the ray at the ground.
+      nearFar.y = intersections.first.x;
+    }
+  }
+  return nearFar;
+}
+#endif // HAZE
+
+float getRayDistanceToScene(const vec3 rayDirection) {
+  float depth = readDepth(vUv * targetUvScale + temporalJitter);
+  if (depth < 1.0 - 1e-7) {
+    depth = reverseLogDepth(depth, cameraNear, cameraFar);
+    float viewZ = getViewZ(depth);
+    return -viewZ / dot(rayDirection, vCameraDirection);
+  }
+  return -1.0;
+}
+
+void main() {
+  #ifdef DEBUG_SHOW_SHADOW_MAP
+  outputColor = getCascadedShadowMaps(vUv);
+  outputDepthVelocity = vec3(0.0);
+  #ifdef SHADOW_LENGTH
+  outputShadowLength = 0.0;
+  #endif // SHADOW_LENGTH
+  return;
+  #endif // DEBUG_SHOW_SHADOW_MAP
+
+  vec3 cameraPosition = vCameraPosition - vEllipsoidCenter;
+  vec3 rayDirection = normalize(vRayDirection);
+  float cosTheta = dot(sunDirection, rayDirection);
+
+  IntersectionResult intersections = getIntersections(cameraPosition, rayDirection);
+  vec2 rayNearFar = getRayNearFar(intersections);
+  #ifdef SHADOW_LENGTH
+  vec2 shadowRayNearFar = getShadowRayNearFar(intersections);
+  #endif // SHADOW_LENGTH
+  #ifdef HAZE
+  vec2 hazeRayNearFar = getHazeRayNearFar(intersections);
+  #endif // HAZE
+
+  float rayDistanceToScene = getRayDistanceToScene(rayDirection);
+  if (rayDistanceToScene >= 0.0) {
+    rayNearFar.y = min(rayNearFar.y, rayDistanceToScene);
+    #ifdef SHADOW_LENGTH
+    shadowRayNearFar.y = min(shadowRayNearFar.y, rayDistanceToScene);
+    #endif // SHADOW_LENGTH
+    #ifdef HAZE
+    hazeRayNearFar.y = min(hazeRayNearFar.y, rayDistanceToScene);
+    #endif // HAZE
+  }
+
+  bool intersectsGround = any(lessThan(rayNearFar, vec2(0.0)));
+  bool intersectsScene = rayNearFar.y < rayNearFar.x;
+
+  float stbn = getSTBN();
+
+  vec4 color = vec4(0.0);
+  float frontDepth = rayNearFar.y;
+  vec3 depthVelocity = vec3(0.0);
+  float shadowLength = 0.0;
+
+  if (!intersectsGround && !intersectsScene) {
+    vec3 rayOrigin = rayNearFar.x * rayDirection + cameraPosition;
+
+    vec2 globeUv = getGlobeUv(rayOrigin);
+    #ifdef DEBUG_SHOW_UV
+    outputColor = vec4(vec3(checker(globeUv, localWeatherRepeat + localWeatherOffset)), 1.0);
+    outputDepthVelocity = vec3(0.0);
+    #ifdef SHADOW_LENGTH
+    outputShadowLength = 0.0;
+    #endif // SHADOW_LENGTH
+    return;
+    #endif // DEBUG_SHOW_UV
+
+    float mipLevel = getMipLevel(globeUv * localWeatherRepeat) * mipLevelScale;
+    mipLevel = mix(0.0, mipLevel, min(1.0, 0.2 * cameraHeight / maxHeight));
+
+    float marchedFrontDepth;
+    ivec3 sampleCount = ivec3(0);
+    color = marchClouds(
+      rayOrigin,
+      rayDirection,
+      rayNearFar,
+      cosTheta,
+      stbn,
+      pow(2.0, mipLevel),
+      marchedFrontDepth,
+      sampleCount
+    );
+
+    #ifdef DEBUG_SHOW_SAMPLE_COUNT
+    outputColor = vec4(vec3(sampleCount) / vec3(500.0, 5.0, 5.0), 1.0);
+    outputDepthVelocity = vec3(0.0);
+    #ifdef SHADOW_LENGTH
+    outputShadowLength = 0.0;
+    #endif // SHADOW_LENGTH
+    return;
+    #endif // DEBUG_SHOW_SAMPLE_COUNT
+
+    // Front depth will be -1.0 when no samples are accumulated.
+    if (marchedFrontDepth >= 0.0) {
+      frontDepth = rayNearFar.x + marchedFrontDepth;
+
+      #ifdef SHADOW_LENGTH
+      // Clamp the shadow length ray at the clouds.
+      shadowRayNearFar.y = mix(
+        shadowRayNearFar.y,
+        min(frontDepth, shadowRayNearFar.y),
+        color.a // Interpolate by the alpha for smoother edges.
+      );
+      #endif // SHADOW_LENGTH
+
+      #ifdef HAZE
+      // Clamp the haze ray at the clouds.
+      hazeRayNearFar.y = mix(
+        hazeRayNearFar.y,
+        min(frontDepth, hazeRayNearFar.y),
+        color.a // Interpolate by the alpha for smoother edges.
+      );
+      #endif // HAZE
+    }
+
+    #ifdef SHADOW_LENGTH
+    if (all(greaterThanEqual(shadowRayNearFar, vec2(0.0)))) {
+      shadowLength = marchShadowLength(
+        shadowRayNearFar.x * rayDirection + cameraPosition,
+        rayDirection,
+        shadowRayNearFar,
+        stbn
+      );
+    }
+    #endif // SHADOW_LENGTH
+
+    // Apply aerial perspective.
+    vec3 frontPosition = cameraPosition + frontDepth * rayDirection;
+    applyAerialPerspective(cameraPosition, frontPosition, shadowLength, color);
+
+    // Velocity for temporal resolution.
+    vec3 frontPositionWorld = ECEFToWorld(frontPosition);
+    vec4 prevClip = reprojectionMatrix * vec4(frontPositionWorld, 1.0);
+    prevClip /= prevClip.w;
+    vec2 prevUv = prevClip.xy * 0.5 + 0.5;
+    vec2 velocity = (vUv - prevUv) * resolution;
+    depthVelocity = vec3(frontDepth, velocity);
+
+  } else {
+    #ifdef SHADOW_LENGTH
+    if (all(greaterThanEqual(shadowRayNearFar, vec2(0.0)))) {
+      shadowLength = marchShadowLength(
+        shadowRayNearFar.x * rayDirection + cameraPosition,
+        rayDirection,
+        shadowRayNearFar,
+        stbn
+      );
+    }
+    #endif // SHADOW_LENGTH
+
+    // TODO: We can calculate velocity to reduce occlusion errors at the edges,
+    // but suffers from floating-point precision errors on near objects.
+
+    // if (intersectsScene) {
+    //   vec3 frontPosition = cameraPosition + rayNearFar.y * rayDirection;
+    //   vec3 frontPositionWorld = ECEFToWorld(frontPosition);
+    //   vec4 prevClip = reprojectionMatrix * vec4(frontPositionWorld, 1.0);
+    //   prevClip /= prevClip.w;
+    //   vec2 prevUv = prevClip.xy * 0.5 + 0.5;
+    //   vec2 velocity = (vUv - prevUv) * resolution;
+    //   depthVelocity = vec3(rayNearFar.y, velocity);
+    // }
+
+  }
+
+  #ifdef DEBUG_SHOW_FRONT_DEPTH
+  outputColor = vec4(turbo(frontDepth / maxRayDistance), 1.0);
+  outputDepthVelocity = vec3(0.0);
+  #ifdef SHADOW_LENGTH
+  outputShadowLength = 0.0;
+  #endif // SHADOW_LENGTH
+  return;
+  #endif // DEBUG_SHOW_FRONT_DEPTH
+
+  #ifdef HAZE
+  vec4 haze = approximateHaze(
+    cameraNear * rayDirection + cameraPosition,
+    rayDirection,
+    hazeRayNearFar.y - hazeRayNearFar.x,
+    cosTheta,
+    shadowLength
+  );
+  color = color * (1.0 - haze.a) + haze;
+  #endif // HAZE
+
+  outputColor = color;
+  outputDepthVelocity = depthVelocity;
+  #ifdef SHADOW_LENGTH
+  outputShadowLength = shadowLength * METER_TO_LENGTH_UNIT;
+  #endif // SHADOW_LENGTH
+}