@takram/three-clouds 0.1.0

package/src/shaders/clouds.glsl

@@ -0,0 +1,190 @@
+float getSTBN() {
+  ivec3 size = textureSize(stbnTexture, 0);
+  vec3 scale = 1.0 / vec3(size);
+  return texture(stbnTexture, vec3(gl_FragCoord.xy, float(frame % size.z)) * scale).r;
+}
+
+// Straightforward spherical mapping
+vec2 getSphericalUv(const vec3 position) {
+  vec2 st = normalize(position.yx);
+  float phi = atan(st.x, st.y);
+  float theta = asin(normalize(position).z);
+  return vec2(phi * RECIPROCAL_PI2 + 0.5, theta * RECIPROCAL_PI + 0.5);
+}
+
+vec2 getCubeSphereUv(const vec3 position) {
+  // Cube-sphere relaxation by: http://mathproofs.blogspot.com/2005/07/mapping-cube-to-sphere.html
+  // TODO: Tile and fix seams.
+  // Possible improvements:
+  // https://iquilezles.org/articles/texturerepetition/
+  // https://gamedev.stackexchange.com/questions/184388/fragment-shader-map-dot-texture-repeatedly-over-the-sphere
+  // https://github.com/mmikk/hextile-demo
+
+  vec3 n = normalize(position);
+  vec3 f = abs(n);
+  vec3 c = n / max(f.x, max(f.y, f.z));
+  vec2 m;
+  if (all(greaterThan(f.yy, f.xz))) {
+    m = c.y > 0.0 ? vec2(-n.x, n.z) : n.xz;
+  } else if (all(greaterThan(f.xx, f.yz))) {
+    m = c.x > 0.0 ? n.yz : vec2(-n.y, n.z);
+  } else {
+    m = c.z > 0.0 ? n.xy : vec2(n.x, -n.y);
+  }
+
+  vec2 m2 = m * m;
+  float q = dot(m2.xy, vec2(-2.0, 2.0)) - 3.0;
+  float q2 = q * q;
+  vec2 uv;
+  uv.x = sqrt(1.5 + m2.x - m2.y - 0.5 * sqrt(-24.0 * m2.x + q2)) * (m.x > 0.0 ? 1.0 : -1.0);
+  uv.y = sqrt(6.0 / (3.0 - uv.x * uv.x)) * m.y;
+  return uv * 0.5 + 0.5;
+}
+
+vec2 getGlobeUv(const vec3 position) {
+  return getCubeSphereUv(position);
+}
+
+float getMipLevel(const vec2 uv) {
+  const float mipLevelScale = 0.1;
+  vec2 coord = uv * resolution;
+  vec2 ddx = dFdx(coord);
+  vec2 ddy = dFdy(coord);
+  float deltaMaxSqr = max(dot(ddx, ddx), dot(ddy, ddy)) * mipLevelScale;
+  return max(0.0, 0.5 * log2(max(1.0, deltaMaxSqr)));
+}
+
+bool insideLayerIntervals(const float height) {
+  bvec3 gt = greaterThan(vec3(height), minIntervalHeights);
+  bvec3 lt = lessThan(vec3(height), maxIntervalHeights);
+  return any(bvec3(gt.x && lt.x, gt.y && lt.y, gt.z && lt.z));
+}
+
+struct WeatherSample {
+  vec4 heightFraction; // Normalized height of each layer
+  vec4 density;
+};
+
+vec4 shapeAlteringFunction(const vec4 heightFraction, const vec4 bias) {
+  // Apply a semi-circle transform to round the clouds towards the top.
+  vec4 biased = pow(heightFraction, bias);
+  vec4 x = clamp(biased * 2.0 - 1.0, -1.0, 1.0);
+  return 1.0 - x * x;
+}
+
+WeatherSample sampleWeather(const vec2 uv, const float height, const float mipLevel) {
+  WeatherSample weather;
+  weather.heightFraction = remapClamped(vec4(height), minLayerHeights, maxLayerHeights);
+
+  vec4 localWeather = pow(
+    textureLod(
+      localWeatherTexture,
+      uv * localWeatherRepeat + localWeatherOffset,
+      mipLevel
+    ).LOCAL_WEATHER_CHANNELS,
+    weatherExponents
+  );
+  #ifdef SHADOW
+  localWeather *= shadowLayerMask;
+  #endif // SHADOW
+
+  vec4 heightScale = shapeAlteringFunction(weather.heightFraction, shapeAlteringBiases);
+
+  // Modulation to control weather by coverage parameter.
+  // Reference: https://github.com/Prograda/Skybolt/blob/master/Assets/Core/Shaders/Clouds.h#L63
+  vec4 factor = 1.0 - coverage * heightScale;
+  weather.density = remapClamped(
+    mix(localWeather, vec4(1.0), coverageFilterWidths),
+    factor,
+    factor + coverageFilterWidths
+  );
+
+  return weather;
+}
+
+vec4 getLayerDensity(const vec4 heightFraction) {
+  // prettier-ignore
+  return densityProfile.expTerms * exp(densityProfile.exponents * heightFraction) +
+    densityProfile.linearTerms * heightFraction +
+    densityProfile.constantTerms;
+}
+
+struct MediaSample {
+  float density;
+  vec4 weight;
+  float scattering;
+  float extinction;
+};
+
+MediaSample sampleMedia(
+  const WeatherSample weather,
+  const vec3 position,
+  const vec2 uv,
+  const float mipLevel,
+  const float jitter,
+  out ivec3 sampleCount
+) {
+  vec4 density = weather.density;
+
+  // TODO: Define in physical length.
+  vec3 surfaceNormal = normalize(position);
+  float localWeatherSpeed = length(localWeatherOffset);
+  vec3 evolution = -surfaceNormal * localWeatherSpeed * 2e4;
+
+  vec3 turbulence = vec3(0.0);
+  #ifdef TURBULENCE
+  vec2 turbulenceUv = uv * localWeatherRepeat * turbulenceRepeat;
+  turbulence =
+    turbulenceDisplacement *
+    (texture(turbulenceTexture, turbulenceUv).rgb * 2.0 - 1.0) *
+    dot(density, remapClamped(weather.heightFraction, vec4(0.3), vec4(0.0)));
+  #endif // TURBULENCE
+
+  vec3 shapePosition = (position + evolution + turbulence) * shapeRepeat + shapeOffset;
+  float shape = texture(shapeTexture, shapePosition).r;
+  density = remapClamped(density, vec4(1.0 - shape) * shapeAmounts, vec4(1.0));
+
+  #ifdef DEBUG_SHOW_SAMPLE_COUNT
+  ++sampleCount.y;
+  #endif // DEBUG_SHOW_SAMPLE_COUNT
+
+  #ifdef SHAPE_DETAIL
+  if (mipLevel * 0.5 + (jitter - 0.5) * 0.5 < 0.5) {
+    vec3 detailPosition = (position + turbulence) * shapeDetailRepeat + shapeDetailOffset;
+    float detail = texture(shapeDetailTexture, detailPosition).r;
+    // Fluffy at the top and whippy at the bottom.
+    vec4 modifier = mix(
+      vec4(pow(detail, 6.0)),
+      vec4(1.0 - detail),
+      remapClamped(weather.heightFraction, vec4(0.2), vec4(0.4))
+    );
+    modifier = mix(vec4(0.0), modifier, shapeDetailAmounts);
+    density = remapClamped(density * 2.0, vec4(modifier * 0.5), vec4(1.0));
+
+    #ifdef DEBUG_SHOW_SAMPLE_COUNT
+    ++sampleCount.z;
+    #endif // DEBUG_SHOW_SAMPLE_COUNT
+  }
+  #endif // SHAPE_DETAIL
+
+  // Nicely decrease the density at the bottom.
+  density = saturate(density * densityScales * getLayerDensity(weather.heightFraction));
+
+  MediaSample media;
+  float densitySum = density.x + density.y + density.z + density.w;
+  media.weight = density / densitySum;
+  media.scattering = densitySum * scatteringCoefficient;
+  media.extinction = densitySum * absorptionCoefficient + media.scattering;
+  return media;
+}
+
+MediaSample sampleMedia(
+  const WeatherSample weather,
+  const vec3 position,
+  const vec2 uv,
+  const float mipLevel,
+  const float jitter
+) {
+  ivec3 sampleCount;
+  return sampleMedia(weather, position, uv, mipLevel, jitter, sampleCount);
+}

package/src/shaders/clouds.vert

@@ -0,0 +1,69 @@
+precision highp float;
+precision highp sampler3D;
+
+#include "atmosphere/parameters"
+#include "atmosphere/functions"
+#include "types"
+
+uniform mat4 inverseProjectionMatrix;
+uniform mat4 inverseViewMatrix;
+uniform vec3 cameraPosition;
+uniform vec3 ellipsoidCenter;
+uniform mat4 inverseEllipsoidMatrix;
+uniform vec3 altitudeCorrection;
+
+// Atmosphere
+uniform float bottomRadius;
+uniform vec3 sunDirection;
+
+// Cloud layers
+uniform float minHeight;
+uniform float maxHeight;
+
+layout(location = 0) in vec3 position;
+
+out vec2 vUv;
+out vec3 vCameraPosition;
+out vec3 vCameraDirection; // Direction to the center of screen
+out vec3 vRayDirection; // Direction to the texel
+out vec3 vEllipsoidCenter;
+
+out GroundIrradiance vGroundIrradiance;
+out CloudsIrradiance vCloudsIrradiance;
+
+void sampleSunSkyIrradiance(const vec3 positionECEF) {
+  vGroundIrradiance.sun = GetSunAndSkyIrradiance(
+    positionECEF * METER_TO_LENGTH_UNIT,
+    sunDirection,
+    vGroundIrradiance.sky
+  );
+
+  vec3 surfaceNormal = normalize(positionECEF);
+  vec2 radii = (bottomRadius + vec2(minHeight, maxHeight)) * METER_TO_LENGTH_UNIT;
+  vCloudsIrradiance.minSun = GetSunAndSkyIrradiance(
+    surfaceNormal * radii.x,
+    sunDirection,
+    vCloudsIrradiance.minSky
+  );
+  vCloudsIrradiance.maxSun = GetSunAndSkyIrradiance(
+    surfaceNormal * radii.y,
+    sunDirection,
+    vCloudsIrradiance.maxSky
+  );
+}
+
+void main() {
+  vUv = position.xy * 0.5 + 0.5;
+
+  vec4 viewPosition = inverseProjectionMatrix * vec4(position, 1.0);
+  vec4 worldDirection = inverseViewMatrix * vec4(viewPosition.xyz, 0.0);
+  mat3 rotation = mat3(inverseEllipsoidMatrix);
+  vCameraPosition = rotation * cameraPosition;
+  vCameraDirection = rotation * normalize((inverseViewMatrix * vec4(0.0, 0.0, -1.0, 0.0)).xyz);
+  vRayDirection = rotation * worldDirection.xyz;
+  vEllipsoidCenter = ellipsoidCenter + altitudeCorrection;
+
+  sampleSunSkyIrradiance(vCameraPosition - vEllipsoidCenter);
+
+  gl_Position = vec4(position.xy, 1.0, 1.0);
+}

package/src/shaders/cloudsEffect.frag

@@ -0,0 +1,11 @@
+uniform sampler2D cloudsBuffer;
+
+void mainImage(const vec4 inputColor, const vec2 uv, out vec4 outputColor) {
+  #ifdef SKIP_RENDERING
+  outputColor = inputColor;
+  #else // SKIP_RENDERING
+  vec4 clouds = texture(cloudsBuffer, uv);
+  outputColor.rgb = inputColor.rgb * (1.0 - clouds.a) + clouds.rgb;
+  outputColor.a = inputColor.a * (1.0 - clouds.a) + clouds.a;
+  #endif // SKIP_RENDERING
+}

package/src/shaders/cloudsResolve.frag

@@ -0,0 +1,202 @@
+precision highp float;
+precision highp sampler2DArray;
+
+#include "core/turbo"
+#include "catmullRomSampling"
+#include "varianceClipping"
+
+uniform sampler2D colorBuffer;
+uniform sampler2D depthVelocityBuffer;
+uniform sampler2D colorHistoryBuffer;
+
+#ifdef SHADOW_LENGTH
+uniform sampler2D shadowLengthBuffer;
+uniform sampler2D shadowLengthHistoryBuffer;
+#endif // SHADOW_LENGTH
+
+uniform vec2 texelSize;
+uniform int frame;
+uniform float varianceGamma;
+uniform float temporalAlpha;
+uniform vec2 jitterOffset;
+
+in vec2 vUv;
+
+layout(location = 0) out vec4 outputColor;
+#ifdef SHADOW_LENGTH
+layout(location = 1) out float outputShadowLength;
+#endif // SHADOW_LENGTH
+
+const ivec2 neighborOffsets[9] = ivec2[9](
+  ivec2(-1, -1),
+  ivec2(-1, 0),
+  ivec2(-1, 1),
+  ivec2(0, -1),
+  ivec2(0, 0),
+  ivec2(0, 1),
+  ivec2(1, -1),
+  ivec2(1, 0),
+  ivec2(1, 1)
+);
+
+const ivec4[4] bayerIndices = ivec4[4](
+  ivec4(0, 12, 3, 15),
+  ivec4(8, 4, 11, 7),
+  ivec4(2, 14, 1, 13),
+  ivec4(10, 6, 9, 5)
+);
+
+vec2 getUnjitteredUv(ivec2 coord) {
+  return (vec2(coord) + 0.5 - jitterOffset) * texelSize;
+}
+
+vec4 getClosestFragment(const vec2 uv) {
+  vec4 result = vec4(1e7, 0.0, 0.0, 0.0);
+  vec4 neighbor;
+  #pragma unroll_loop_start
+  for (int i = 0; i < 9; ++i) {
+    neighbor = textureOffset(depthVelocityBuffer, uv, neighborOffsets[i]);
+    if (neighbor.r < result.r) {
+      result = neighbor;
+    }
+  }
+  #pragma unroll_loop_end
+  return result;
+}
+
+vec4 getClosestFragment(const ivec2 coord) {
+  vec4 result = vec4(1e7, 0.0, 0.0, 0.0);
+  vec4 neighbor;
+  #pragma unroll_loop_start
+  for (int i = 0; i < 9; ++i) {
+    neighbor = texelFetchOffset(depthVelocityBuffer, coord, 0, neighborOffsets[i]);
+    if (neighbor.r < result.r) {
+      result = neighbor;
+    }
+  }
+  #pragma unroll_loop_end
+  return result;
+}
+
+void temporalUpscale(
+  const ivec2 coord,
+  const ivec2 lowResCoord,
+  const bool currentFrame,
+  out vec4 outputColor,
+  out float outputShadowLength
+) {
+  #if !defined(DEBUG_SHOW_VELOCITY)
+  if (currentFrame) {
+    // Use the texel just rendered without any accumulation.
+    outputColor = texelFetch(colorBuffer, lowResCoord, 0);
+    #ifdef SHADOW_LENGTH
+    outputShadowLength = texelFetch(shadowLengthBuffer, lowResCoord, 0).r;
+    #endif // SHADOW_LENGTH
+    return;
+  }
+  #endif // !defined(DEBUG_SHOW_VELOCITY)
+
+  vec2 unjitteredUv = getUnjitteredUv(coord);
+  vec4 currentColor = texture(colorBuffer, unjitteredUv);
+  #ifdef SHADOW_LENGTH
+  vec4 currentShadowLength = vec4(texture(shadowLengthBuffer, unjitteredUv).rgb, 1.0);
+  #endif // SHADOW_LENGTH
+
+  vec4 depthVelocity = getClosestFragment(unjitteredUv);
+  vec2 velocity = depthVelocity.gb * texelSize;
+  vec2 prevUv = vUv - velocity;
+  if (prevUv.x < 0.0 || prevUv.x > 1.0 || prevUv.y < 0.0 || prevUv.y > 1.0) {
+    outputColor = currentColor;
+    #ifdef SHADOW_LENGTH
+    outputShadowLength = currentShadowLength.r;
+    #endif // SHADOW_LENGTH
+    return; // Rejection
+  }
+
+  // Variance clipping with a large variance gamma seems to work fine for
+  // upsampling. This increases ghosting, of course, but it's hard to notice on
+  // clouds.
+  // vec4 historyColor = textureCatmullRom(colorHistoryBuffer, prevUv);
+  vec4 historyColor = texture(colorHistoryBuffer, prevUv);
+  vec4 clippedColor = varianceClipping(colorBuffer, vUv, currentColor, historyColor, varianceGamma);
+  outputColor = clippedColor;
+
+  #ifdef DEBUG_SHOW_VELOCITY
+  outputColor.rgb = outputColor.rgb + vec3(abs(velocity), 0.0);
+  #endif // DEBUG_SHOW_VELOCITY
+
+  #ifdef SHADOW_LENGTH
+  // Sampling the shadow length history using scene depth doesn't make much
+  // sense, but it's too hard to derive it properly. At least this approach
+  // resolves the edges of scene objects.
+  // vec4 historyShadowLength = vec4(textureCatmullRom(shadowLengthHistoryBuffer, prevUv).rgb, 1.0);
+  vec4 historyShadowLength = vec4(texture(shadowLengthHistoryBuffer, prevUv).rgb, 1.0);
+  vec4 clippedShadowLength = varianceClipping(
+    shadowLengthBuffer,
+    vUv,
+    currentShadowLength,
+    historyShadowLength,
+    varianceGamma
+  );
+  outputShadowLength = clippedShadowLength.r;
+  #endif // SHADOW_LENGTH
+}
+
+void temporalAntialiasing(const ivec2 coord, out vec4 outputColor, out float outputShadowLength) {
+  vec4 currentColor = texelFetch(colorBuffer, coord, 0);
+  #ifdef SHADOW_LENGTH
+  vec4 currentShadowLength = vec4(texelFetch(shadowLengthBuffer, coord, 0).rgb, 1.0);
+  #endif // SHADOW_LENGTH
+
+  vec4 depthVelocity = getClosestFragment(coord);
+  vec2 velocity = depthVelocity.gb * texelSize;
+
+  vec2 prevUv = vUv - velocity;
+  if (prevUv.x < 0.0 || prevUv.x > 1.0 || prevUv.y < 0.0 || prevUv.y > 1.0) {
+    outputColor = currentColor;
+    #ifdef SHADOW_LENGTH
+    outputShadowLength = currentShadowLength.r;
+    #endif // SHADOW_LENGTH
+    return; // Rejection
+  }
+
+  vec4 historyColor = texture(colorHistoryBuffer, prevUv);
+  vec4 clippedColor = varianceClipping(colorBuffer, coord, currentColor, historyColor);
+  outputColor = mix(clippedColor, currentColor, temporalAlpha);
+
+  #ifdef DEBUG_SHOW_VELOCITY
+  outputColor.rgb = outputColor.rgb + vec3(abs(velocity), 0.0);
+  #endif // DEBUG_SHOW_VELOCITY
+
+  #ifdef SHADOW_LENGTH
+  vec4 historyShadowLength = vec4(texture(shadowLengthHistoryBuffer, prevUv).rgb, 1.0);
+  vec4 clippedShadowLength = varianceClipping(
+    shadowLengthBuffer,
+    coord,
+    currentShadowLength,
+    historyShadowLength
+  );
+  outputShadowLength = mix(clippedShadowLength.r, currentShadowLength.r, temporalAlpha);
+  #endif // SHADOW_LENGTH
+}
+
+void main() {
+  ivec2 coord = ivec2(gl_FragCoord.xy);
+
+  #if !defined(SHADOW_LENGTH)
+  float outputShadowLength;
+  #endif // !defined(SHADOW_LENGTH)
+
+  #ifdef TEMPORAL_UPSCALE
+  ivec2 lowResCoord = coord / 4;
+  int bayerValue = bayerIndices[coord.x % 4][coord.y % 4];
+  bool currentFrame = bayerValue == frame % 16;
+  temporalUpscale(coord, lowResCoord, currentFrame, outputColor, outputShadowLength);
+  #else // TEMPORAL_UPSCALE
+  temporalAntialiasing(coord, outputColor, outputShadowLength);
+  #endif // TEMPORAL_UPSCALE
+
+  #if defined(SHADOW_LENGTH) && defined(DEBUG_SHOW_SHADOW_LENGTH)
+  outputColor = vec4(turbo(outputShadowLength * 0.05), 1.0);
+  #endif // defined(SHADOW_LENGTH) && defined(DEBUG_SHOW_SHADOW_LENGTH)
+}

package/src/shaders/cloudsResolve.vert

@@ -0,0 +1,10 @@
+precision highp float;
+
+layout(location = 0) in vec3 position;
+
+out vec2 vUv;
+
+void main() {
+  vUv = position.xy * 0.5 + 0.5;
+  gl_Position = vec4(position.xy, 1.0, 1.0);
+}

package/src/shaders/localWeather.frag

@@ -0,0 +1,83 @@
+precision highp float;
+precision highp int;
+
+#include "core/math"
+#include "perlin"
+#include "tileableNoise"
+
+in vec2 vUv;
+
+layout(location = 0) out vec4 outputColor;
+
+float getWorleyFbm(
+  const vec3 point,
+  float frequency,
+  float amplitude,
+  const float lacunarity,
+  const float gain,
+  const int octaveCount
+) {
+  float noise = 0.0;
+  for (int i = 0; i < octaveCount; ++i) {
+    noise += amplitude * (1.0 - getWorleyNoise(point, frequency));
+    frequency *= lacunarity;
+    amplitude *= gain;
+  }
+  return noise;
+}
+
+void main() {
+  vec3 point = vec3(vUv.x, vUv.y, 0.0);
+
+  // Mid clouds
+  {
+    float worley = getWorleyFbm(
+      point + vec3(0.5),
+      8.0, // frequency
+      0.4, // amplitude
+      2.0, // lacunarity
+      0.95, // gain
+      4 // octaveCount
+    );
+    worley = smoothstep(1.0, 1.4, worley);
+    outputColor.g = worley;
+  }
+
+  // Low clouds
+  {
+    float worley = getWorleyFbm(
+      point,
+      16.0, // frequency
+      0.4, // amplitude
+      2.0, // lacunarity
+      0.95, // gain
+      4 // octaveCount
+    );
+    worley = smoothstep(0.8, 1.4, worley);
+    outputColor.r = saturate(worley - outputColor.g);
+  }
+
+  // High clouds
+  {
+    float perlin = getPerlinNoise(
+      point,
+      vec3(6.0, 12.0, 1.0), // frequency
+      8 // octaveCount
+    );
+    perlin = smoothstep(-0.5, 0.5, perlin);
+    outputColor.b = perlin;
+  }
+
+  // Extra
+  {
+    float perlin = getPerlinNoise(
+      point + vec3(-19.1, 33.4, 47.2),
+      32.0, // frequency
+      4 // octaveCount
+    );
+    perlin = smoothstep(-0.5, 0.5, perlin);
+    outputColor.a = perlin;
+  }
+
+  outputColor.a = 1.0;
+}

package/src/shaders/parameters.glsl

@@ -0,0 +1,64 @@
+uniform vec2 resolution;
+uniform int frame;
+uniform sampler3D stbnTexture;
+
+// Atmosphere
+uniform float bottomRadius;
+uniform mat4 ellipsoidMatrix;
+uniform mat4 inverseEllipsoidMatrix;
+uniform vec3 sunDirection;
+
+// Participating medium
+uniform float scatteringCoefficient;
+uniform float absorptionCoefficient;
+uniform vec3 albedo;
+
+// Primary raymarch
+uniform float minDensity;
+uniform float minExtinction;
+uniform float minTransmittance;
+
+// Shape and weather
+uniform sampler2D localWeatherTexture;
+uniform vec2 localWeatherRepeat;
+uniform vec2 localWeatherOffset;
+uniform float coverage;
+uniform sampler3D shapeTexture;
+uniform vec3 shapeRepeat;
+uniform vec3 shapeOffset;
+
+#ifdef SHAPE_DETAIL
+uniform sampler3D shapeDetailTexture;
+uniform vec3 shapeDetailRepeat;
+uniform vec3 shapeDetailOffset;
+#endif // SHAPE_DETAIL
+
+#ifdef TURBULENCE
+uniform sampler2D turbulenceTexture;
+uniform vec2 turbulenceRepeat;
+uniform float turbulenceDisplacement;
+#endif // TURBULENCE
+
+// Haze
+#ifdef HAZE
+uniform float hazeDensityScale;
+uniform float hazeExponent;
+#endif // HAZE
+
+// Cloud layers
+uniform vec4 minLayerHeights;
+uniform vec4 maxLayerHeights;
+uniform vec3 minIntervalHeights;
+uniform vec3 maxIntervalHeights;
+uniform vec4 densityScales;
+uniform vec4 shapeAmounts;
+uniform vec4 shapeDetailAmounts;
+uniform vec4 weatherExponents;
+uniform vec4 shapeAlteringBiases;
+uniform vec4 coverageFilterWidths;
+uniform float minHeight;
+uniform float maxHeight;
+uniform float shadowTopHeight;
+uniform float shadowBottomHeight;
+uniform vec4 shadowLayerMask;
+uniform DensityProfile densityProfile;