@geoblocks/cesium-post-process 0.3.0 → 0.5.0

package/src/shaders/LensDistortion.glsl

@@ -0,0 +1,24 @@
+// The barrel distortion and dark corners of a wide-angle lens, like those of FPV cameras: straight
+// lines bend outward away from the middle. The corners stay in place and the middle is
+// magnified, so the picture keeps filling the screen.
+precision highp sampler2D;
+uniform sampler2D colorTexture;
+// 0 to 1
+uniform float distortion;
+uniform float vignette;
+in vec2 v_textureCoordinates;
+
+// strongest distortion: the middle magnified by 1 + this, relative to the corners
+const float MAX_DISTORTION = 0.5;
+
+void main() {
+  vec2 aspect = vec2(czm_viewport.z / czm_viewport.w, 1.0);
+  // from the middle, 1 at the corners
+  vec2 fromMiddle = (v_textureCoordinates - 0.5) * aspect / (0.5 * length(aspect));
+  float r2 = dot(fromMiddle, fromMiddle);
+  float k = distortion * MAX_DISTORTION;
+  vec2 uv = 0.5 + (v_textureCoordinates - 0.5) * (1.0 + k * r2) / (1.0 + k);
+  vec4 sceneColor = texture(colorTexture, uv);
+  float dark = 1.0 - vignette * smoothstep(0.3, 1.0, r2);
+  out_FragColor = vec4(sceneColor.rgb * dark, sceneColor.a);
+}

package/src/shaders/Lightning.glsl

@@ -0,0 +1,257 @@
+// Lightning, cloud-to-ground strikes: a branching channel from the cloud base to the ground, with 2 to 4
+// return strokes tens of milliseconds apart, down one channel, and a flash that follows their flicker, as
+// in the descriptions of the lightning flash (Rakov and Uman, "Lightning: Physics and Effects", 2003). The
+// channel is drawn over the picture in screen space as a hot core in a halo, at least a pixel and a half
+// wide: a channel is centimeters wide, and a thousand meters away it would not show at its true width. It
+// is a line from the cloud to the ground that wanders to either side, by value noise of the position along
+// it in four octaves, pinned at both ends, with branches that leave it downward at an angle and wander the
+// same way, fading toward their ends. The distance to it is the pixel's across the line, less the wander,
+// over the slope of the wander, so that the width stays the same where it zigzags: a function of the
+// position along the line, a handful of noise lookups for each channel, not a polyline for each pixel.
+// The channel is hidden behind nearer terrain. The flash lights each pixel in proportion to its own color,
+// less with its distance to the strike, and the sky toward the cloud above it. Seen from above the cloud
+// base, the channel is hidden in the cloud, and the flash lights the cloud over the strike from inside, as
+// a glow. Needs EyeFromDepth and Hash.
+precision highp sampler2D;
+const int STRIKES = 4;
+const int BRANCHES = 5;
+uniform sampler2D colorTexture;
+uniform sampler2D depthTexture;
+// the top of each strike's channel, at the cloud base, in eye coordinates, and its seed; and its foot
+// and its age in seconds, negative when there is no strike in the slot
+uniform vec4 strikeTop[STRIKES];
+uniform vec4 strikeBottom[STRIKES];
+// the branches of each strike's channel, from the CPU: where along the channel they leave it, the cosine
+// and the sine of their angle from it, and their length as a share of the channel's, 0 for none
+uniform vec4 strikeBranches[STRIKES * BRANCHES];
+// the glow of each strike in the clouds, in eye coordinates, and the map's intensity at the strike,
+// 0 for none; and 0 below the cloud base to 1 above it, where the glow replaces the channel
+uniform vec4 strikeGlow[STRIKES];
+uniform float above;
+in vec2 v_textureCoordinates;
+
+const int MAX_STROKES = 4;
+// how far the main channel and the branches wander to either side, as a fraction of their length
+const float MAIN_WANDER = 0.7;
+const float BRANCH_WANDER = 0.6;
+// the brightness of the branches against the main channel's
+const float BRANCH_BRIGHTNESS = 0.5;
+// how far from the line between its ends a channel reaches, as a fraction of its length: the main one's
+// wander, then its branches; and the widest halo in pixels. Pixels farther than that skip the channel
+const float MAIN_REACH = 0.35;
+const float BRANCH_REACH = 0.5;
+const float MAX_HALO = 80.0;
+const float MAX_SLOPE = 2.5;
+// the channel's flicker under which it is not drawn
+const float FAINT = 0.01;
+// the width of the core and of the halo, in meters: scaled to pixels by the distance, the core to no
+// less than a pixel and a half
+const float CORE_WIDTH = 1.0;
+const float HALO_WIDTH = 25.0;
+// how bright the halo is against the core
+const float HALO = 0.35;
+// the channel is white at its core and blue around it, from the nitrogen lines of a 30000 K plasma, with a
+// violet cast from the hydrogen line of the water in a storm's air (Kieu et al., 2021)
+const vec3 HALO_COLOR = vec3(0.68, 0.66, 1.0);
+const vec3 FLASH_COLOR = vec3(0.8, 0.82, 1.0);
+// the extinction of the light of a strike per meter, in red, green and blue: the scattering of the air goes
+// with the wavelength to the minus 4, so far strikes turn yellow, then red, as at sunset
+const vec3 EXTINCTION = vec3(1.0, 1.9, 3.4) * 2e-5;
+// the distance, in meters, at which the flash on the land has fallen to half
+const float FLASH_REACH = 3000.0;
+// the sky is a ray this long
+const float SKY_DISTANCE = 20000.0;
+// time constants of the channel's flicker and of the flash, in seconds
+const float BOLT_DECAY = 0.05;
+const float FLASH_DECAY = 0.15;
+// the glow in the clouds above a strike, seen from above: as wide as this, in meters, and as bright
+const float GLOW_RADIUS = 4000.0;
+const float GLOW_BRIGHTNESS = 0.9;
+// seen from above, most of the way to the glow is through thin air: its light is dimmed by at most
+// this many meters of the air near the ground, about the height over which the air thins by e
+const float GLOW_AIR = 8000.0;
+
+// noise of one coordinate, in [-0.5, 0.5), and its slope: linear between the random values of the whole
+// numbers, not smoothed, so that the path is made of straight segments with sharp turns, as a bolt is
+vec2 valueNoise(float x, float seed) {
+  float cell = floor(x);
+  float low = hash(vec2(cell, seed));
+  float high = hash(vec2(cell + 1.0, seed));
+  return vec2(mix(low, high, fract(x)) - 0.5, high - low);
+}
+
+// four octaves of it along a channel, from 4 segments to 34: the wander at s and its slope
+vec2 wander(float s, float seed) {
+  vec2 sum = vec2(0.0);
+  float amplitude = 1.0;
+  float frequency = 4.0;
+  for (int i = 0; i < 4; i++) {
+    sum += amplitude * valueNoise(s * frequency, seed + 7.0 * float(i)) * vec2(1.0, frequency);
+    amplitude *= 0.45;
+    frequency *= 2.1;
+  }
+  return sum;
+}
+
+// how far a channel is from its line at s, in its lengths, and the slope of that: the wander held to 0
+// at the start, by a smoothstep over the first quarter of a branch, and at both ends of the main
+// channel, by a sine, so that it leaves the cloud and reaches the ground upright
+vec2 offsetAt(float s, float seed, bool main) {
+  vec2 w = wander(s, seed);
+  float envelope = sin(czm_pi * s);
+  float slope = czm_pi * cos(czm_pi * s);
+  if (!main) {
+    float u = clamp(4.0 * s, 0.0, 1.0);
+    envelope = u * u * (3.0 - 2.0 * u);
+    slope = 24.0 * u * (1.0 - u);
+  }
+  return vec2(w.x * envelope, w.y * envelope + w.x * slope);
+}
+
+// the distance in pixels from p to a channel that leaves a along dir, len pixels long, and the share s
+// of the way along it where p is nearest
+float channelDistance(vec2 p, vec2 a, vec2 dir, float len, float amplitude, float seed, bool main, out float s) {
+  vec2 r = p - a;
+  float along = dot(r, dir);
+  s = clamp(along / len, 0.0, 1.0);
+  vec2 offset = offsetAt(s, seed, main);
+  float across = dot(r, vec2(-dir.y, dir.x)) - amplitude * len * offset.x;
+  // the estimate holds near the channel only: past a slope of a few, the halo of a steep segment would
+  // stretch sideways
+  float slope = clamp(amplitude * offset.y, -MAX_SLOPE, MAX_SLOPE);
+  // past the ends, the distance to the end
+  return length(vec2(across / sqrt(1.0 + slope * slope), along - s * len));
+}
+
+// the core and the halo of the channel at a distance in pixels
+vec2 channelProfile(float d, float core, float halo) {
+  return vec2(exp(-d * d / (core * core)), HALO * exp(-d / halo));
+}
+
+// the light of a strike seen from this far, in each color
+vec3 transmittance(float d) {
+  return exp(-EXTINCTION * d);
+}
+
+// the flicker of the channel and the light of the flash, at an age in seconds: each stroke lights it up
+// at once and fades, the first one the brightest, and a dimmer current keeps the channel lit between them
+void strokes(float age, float seed, out float bolt, out float flash) {
+  bolt = 0.3 * exp(-age / 0.3);
+  flash = 0.0;
+  float count = 2.0 + floor(3.0 * hash(vec2(seed, 91.0)));
+  float start = 0.0;
+  for (int i = 0; i < MAX_STROKES; i++) {
+    if (float(i) >= count) {
+      break;
+    }
+    float strength = i == 0 ? 1.0 : 0.35 + 0.5 * hash(vec2(seed, 50.0 + float(i)));
+    float since = age - start;
+    if (since >= 0.0) {
+      bolt += strength * exp(-since / BOLT_DECAY);
+      flash += strength * exp(-since / FLASH_DECAY);
+    }
+    start += 0.04 + 0.08 * hash(vec2(seed, 70.0 + float(i)));
+  }
+}
+
+vec2 screenPoint(vec3 eye) {
+  vec4 clip = czm_projection * vec4(eye, 1.0);
+  return (0.5 * clip.xy / clip.w + 0.5) * czm_viewport.zw;
+}
+
+// the distance from p to the segment ab
+float segmentDistance(vec2 p, vec2 a, vec2 b) {
+  vec2 ab = b - a;
+  return length(p - a - ab * clamp(dot(p - a, ab) / dot(ab, ab), 0.0, 1.0));
+}
+
+void main() {
+  vec2 uv = v_textureCoordinates;
+  vec4 sceneColor = texture(colorTexture, uv);
+  vec3 color = sceneColor.rgb;
+  vec4 eye = eyeAt(depthTexture, uv);
+  float sceneDistance = eye.w > 0.0 ? length(eye.xyz) : 1e9;
+  vec3 pixelEye = eye.w > 0.0 ? eye.xyz : eye.xyz * SKY_DISTANCE;
+  vec2 pixel = uv * czm_viewport.zw;
+  // the focal length in pixels
+  float focal = 0.5 * czm_projection[1][1] * czm_viewport.w;
+
+  vec3 light = vec3(0.0);
+  vec3 channel = vec3(0.0);
+  for (int k = 0; k < STRIKES; k++) {
+    float age = strikeBottom[k].w;
+    if (age < 0.0) {
+      continue;
+    }
+    vec3 top = strikeTop[k].xyz;
+    vec3 bottom = strikeBottom[k].xyz;
+    float seed = strikeTop[k].w;
+    float bolt;
+    float flash;
+    strokes(age, seed, bolt, flash);
+
+    // the land around the foot of the strike, and the sky toward the cloud above it
+    float reach = distance(pixelEye, bottom) / FLASH_REACH;
+    float sky = eye.w > 0.0 ? 0.0 : pow(max(dot(eye.xyz, normalize(top)), 0.0), 6.0);
+    vec3 seen = transmittance(length(bottom));
+    light += FLASH_COLOR * seen * flash * (color * 1.2 + 0.08) / (1.0 + reach * reach);
+    light += FLASH_COLOR * seen * flash * sky * 0.5;
+
+    // seen from above, the flash lights the cloud over the strike from inside: a glow around the
+    // point of the view ray nearest to it, hidden behind nearer terrain
+    vec4 glow = strikeGlow[k];
+    float along = dot(glow.xyz, normalize(eye.xyz));
+    if (above > 0.0 && glow.w > 0.0 && along > 0.0 && sceneDistance > along * 0.98) {
+      float across = length(glow.xyz - normalize(eye.xyz) * along);
+      light += FLASH_COLOR * transmittance(min(along, GLOW_AIR)) * flash * glow.w * above * GLOW_BRIGHTNESS * exp(-across * across / (GLOW_RADIUS * GLOW_RADIUS));
+    }
+
+    // the channel, when both its ends are in front of the camera, and the pixel is near it
+    if (top.z > -1.0 || bottom.z > -1.0) {
+      continue;
+    }
+    vec2 a = screenPoint(top);
+    vec2 b = screenPoint(bottom);
+    float len = distance(a, b);
+    // the halo's widest reach, around the middle of the channel: pixels farther than that skip the channel
+    float margin = 3.0 * clamp(HALO_WIDTH * focal / length(0.5 * (top + bottom)), 4.0, MAX_HALO);
+    // the branches reach further from the line than the main channel's wander does
+    float fromLine = segmentDistance(pixel, a, b);
+    if (bolt < FAINT || len < 2.0 || fromLine > BRANCH_REACH * len + margin) {
+      continue;
+    }
+    vec2 dir = (b - a) / len;
+    float s = clamp(dot(pixel - a, dir) / len, 0.0, 1.0);
+    float boltDistance = length(mix(top, bottom, s));
+    float core = max(1.5, CORE_WIDTH * focal / boltDistance);
+    float halo = clamp(HALO_WIDTH * focal / boltDistance, 4.0, MAX_HALO);
+    vec2 profile = vec2(0.0);
+    if (fromLine < MAIN_REACH * len + margin) {
+      profile = channelProfile(channelDistance(pixel, a, dir, len, MAIN_WANDER, seed, true, s), core, halo);
+    }
+    for (int j = 0; j < BRANCHES; j++) {
+      vec4 branch = strikeBranches[k * BRANCHES + j];
+      float branchLen = len * branch.w;
+      if (branchLen <= 0.0) {
+        continue;
+      }
+      float at = branch.x;
+      vec2 branchDir = vec2(branch.y * dir.x - branch.z * dir.y, branch.z * dir.x + branch.y * dir.y);
+      // nowhere near the branch, which stays within its length and wander of its middle, and the main
+      // channel's wander of its line
+      vec2 onLine = a + dir * len * at;
+      if (distance(pixel, onLine + branchDir * 0.5 * branchLen) > (0.5 + 0.5 * BRANCH_WANDER) * branchLen + MAIN_REACH * len + margin) {
+        continue;
+      }
+      vec2 base = onLine + vec2(-dir.y, dir.x) * MAIN_WANDER * len * offsetAt(at, seed, true).x;
+      float along;
+      float branchDistance = channelDistance(pixel, base, branchDir, branchLen, BRANCH_WANDER, seed + 5.0 * float(j + 1), false, along);
+      profile = max(profile, BRANCH_BRIGHTNESS * (1.0 - 0.7 * along) * channelProfile(branchDistance, core, halo));
+    }
+    // hidden behind terrain nearer than the channel at this height
+    if (sceneDistance > boltDistance * 0.98 - 30.0) {
+      channel += (1.0 - above) * bolt * transmittance(boltDistance) * (profile.x + profile.y * HALO_COLOR);
+    }
+  }
+  out_FragColor = vec4(color + light + channel, sceneColor.a);
+}

package/src/shaders/MotionBlur.glsl

@@ -0,0 +1,71 @@
+// Camera motion blur, after "A Reconstruction Filter for Plausible Motion Blur" (McGuire et al.,
+// I3D 2012). Only the camera moves, so each pixel's motion follows from its depth and the
+// reprojection into the previous frame, computed once per pixel into the velocity buffer of
+// MotionBlurVelocity.glsl. The blur gathers jittered samples along the pixel's motion, weighted
+// by depth so that near terrain and far ridges or sky do not smear into each other.
+precision highp sampler2D;
+uniform sampler2D colorTexture;
+// xy: half the blur, as a fraction of the viewport; z: the distance from the camera
+uniform sampler2D velocityTexture;
+in vec2 v_textureCoordinates;
+
+const int SAMPLES = 16;
+// depth difference, relative to the depth, over which a sample goes from in front to behind
+const float SOFT_DEPTH = 0.1;
+
+
+// xy: half the blur of the pixel at uv, in pixels; z: its distance from the camera
+vec3 halfBlurAt(vec2 uv) {
+  vec3 velocity = texture(velocityTexture, uv).xyz;
+  return vec3(velocity.xy * czm_viewport.zw, velocity.z);
+}
+
+// 1 when b is in front of a, 0 when it is SOFT_DEPTH behind
+float inFront(float a, float b) {
+  return clamp(1.0 - (b - a) / (SOFT_DEPTH * min(a, b)), 0.0, 1.0);
+}
+
+// the blur of a pixel with this half blur covers a sample this far away; the extents are kept
+// above 0 for samples without blur
+float cone(float gap, vec2 halfBlur) {
+  return clamp(1.0 - gap / max(length(halfBlur), 1e-3), 0.0, 1.0);
+}
+
+// both pixels are blurred over the gap between them
+float cylinder(float gap, vec2 halfBlur) {
+  float extent = max(length(halfBlur), 1e-3);
+  return 1.0 - smoothstep(0.95 * extent, 1.05 * extent, gap);
+}
+
+void main() {
+  vec3 center = halfBlurAt(v_textureCoordinates);
+  vec2 halfBlur = center.xy;
+  vec4 centerColor = texture(colorTexture, v_textureCoordinates);
+  float extent = length(halfBlur);
+  if (extent < 0.5) {
+    out_FragColor = centerColor;
+    return;
+  }
+
+  float weight = 1.0 / extent;
+  vec4 color = centerColor * weight;
+  // the jitter turns the banding of few samples into fine noise
+  float jitter = pixelNoise(gl_FragCoord.xy) - 0.5;
+  for (int i = 0; i < SAMPLES; i++) {
+    float t = mix(-1.0, 1.0, (float(i) + jitter + 1.0) / float(SAMPLES + 1));
+    vec2 uv = v_textureCoordinates + t * halfBlur / czm_viewport.zw;
+    vec3 other = halfBlurAt(uv);
+    float gap = abs(t) * extent;
+    float front = inFront(center.z, other.z);
+    float behind = inFront(other.z, center.z);
+    // a sample in front counts when its own blur reaches this pixel, one behind when this
+    // pixel's blur reaches it, and both when they are blurred together
+    float alpha =
+      front * cone(gap, other.xy) +
+      behind * cone(gap, halfBlur) +
+      2.0 * cylinder(gap, other.xy) * cylinder(gap, halfBlur);
+    weight += alpha;
+    color += alpha * texture(colorTexture, uv);
+  }
+  out_FragColor = color / weight;
+}

package/src/shaders/MotionBlurVelocity.glsl

@@ -0,0 +1,31 @@
+// The velocity buffer of the motion blur, at a fraction of the resolution: each pixel's half
+// blur, as a fraction of the viewport, and its distance from the camera. Computed once per
+// pixel here rather than once per sample in the gather. Needs EyeFromDepth.
+precision highp sampler2D;
+uniform sampler2D depthTexture;
+// current eye coordinates to the previous frame's clip coordinates, computed in double
+// precision on the CPU
+uniform mat4 reprojection;
+// exposure time over the time since the previous frame: the blur spans the motion during the
+// exposure, whatever the frame rate
+uniform float exposureScale;
+in vec2 v_textureCoordinates;
+
+// longest blur, as a fraction of the viewport height
+const float MAX_BLUR = 0.05;
+
+void main() {
+  // the sky is a direction: only the camera rotation moves it
+  vec4 eye = eyeAt(depthTexture, v_textureCoordinates);
+  vec4 previous = reprojection * eye;
+  vec2 motion = previous.w > 0.0 ? v_textureCoordinates - (previous.xy / previous.w * 0.5 + 0.5) : vec2(0.0);
+  motion *= exposureScale;
+  // the clamp is resolution independent: the ratio to the viewport height is the same at any scale
+  vec2 pixels = motion * czm_viewport.zw;
+  float extent = length(pixels);
+  float maxExtent = MAX_BLUR * czm_viewport.w;
+  if (extent > maxExtent) {
+    motion *= maxExtent / extent;
+  }
+  out_FragColor = vec4(0.5 * motion, eye.w == 0.0 ? 1e30 : length(eye.xyz), 1.0);
+}

package/src/shaders/Noise.glsl

@@ -0,0 +1,43 @@
+// random gradient in [-1, 1] at a lattice point
+vec3 gradient(vec3 p) {
+  p = fract(p * vec3(0.1031, 0.1030, 0.0973));
+  p += dot(p, p.yxz + 33.33);
+  return fract((p.xxy + p.yxx) * p.zyx) * 2.0 - 1.0;
+}
+
+// gradient noise, about -0.7 to 0.7. After prod80's ReShade Film Grain (MIT), with gradients
+// from a hash instead of a texture
+float gradientNoise(vec3 p) {
+  vec3 i = floor(p);
+  vec3 f = fract(p);
+  vec3 u = f * f * f * (f * (f * 6.0 - 15.0) + 10.0);
+  return mix(
+    mix(
+      mix(dot(gradient(i), f), dot(gradient(i + vec3(1.0, 0.0, 0.0)), f - vec3(1.0, 0.0, 0.0)), u.x),
+      mix(dot(gradient(i + vec3(0.0, 1.0, 0.0)), f - vec3(0.0, 1.0, 0.0)), dot(gradient(i + vec3(1.0, 1.0, 0.0)), f - vec3(1.0, 1.0, 0.0)), u.x),
+      u.y),
+    mix(
+      mix(dot(gradient(i + vec3(0.0, 0.0, 1.0)), f - vec3(0.0, 0.0, 1.0)), dot(gradient(i + vec3(1.0, 0.0, 1.0)), f - vec3(1.0, 0.0, 1.0)), u.x),
+      mix(dot(gradient(i + vec3(0.0, 1.0, 1.0)), f - vec3(0.0, 1.0, 1.0)), dot(gradient(i + vec3(1.0, 1.0, 1.0)), f - vec3(1.0, 1.0, 1.0)), u.x),
+      u.y),
+    u.z);
+}
+
+// random gradient in [-1, 1] at a lattice point of the plane, for a seed
+vec2 gradient(vec2 p, float seed) {
+  vec3 p3 = fract(vec3(p, seed) * vec3(0.1031, 0.1030, 0.0973));
+  p3 += dot(p3, p3.yxz + 33.33);
+  return fract((p3.xx + p3.yz) * p3.zy) * 2.0 - 1.0;
+}
+
+// gradient noise over the plane, about -0.7 to 0.7, a new pattern for each seed: half the
+// hashes of the volume's, for a pattern that only has to change by whole frames
+float gradientNoise(vec2 p, float seed) {
+  vec2 i = floor(p);
+  vec2 f = fract(p);
+  vec2 u = f * f * f * (f * (f * 6.0 - 15.0) + 10.0);
+  return mix(
+    mix(dot(gradient(i, seed), f), dot(gradient(i + vec2(1.0, 0.0), seed), f - vec2(1.0, 0.0)), u.x),
+    mix(dot(gradient(i + vec2(0.0, 1.0), seed), f - vec2(0.0, 1.0)), dot(gradient(i + vec2(1.0, 1.0), seed), f - vec2(1.0, 1.0)), u.x),
+    u.y);
+}

package/src/shaders/Normal.glsl

@@ -0,0 +1,21 @@
+// normal at the pixel from its neighbors at this distance in pixels: on each axis the nearer
+// side, so that the edges of the scene do not bend it
+precision highp sampler2D;
+vec3 normalAt(sampler2D depthTexture, vec2 uv, vec3 center, float distance) {
+  vec2 step = distance / czm_viewport.zw;
+  vec3 right = eyeAt(depthTexture, uv + vec2(step.x, 0.0)).xyz - center;
+  vec3 left = center - eyeAt(depthTexture, uv - vec2(step.x, 0.0)).xyz;
+  vec3 above = eyeAt(depthTexture, uv + vec2(0.0, step.y)).xyz - center;
+  vec3 below = center - eyeAt(depthTexture, uv - vec2(0.0, step.y)).xyz;
+  vec3 dx = dot(right, right) < dot(left, left) ? right : left;
+  vec3 dy = dot(above, above) < dot(below, below) ? above : below;
+  vec3 normal = normalize(cross(dx, dy));
+  // toward the camera
+  return normal * sign(dot(normal, -center));
+}
+
+// the terrain mesh is made of flat triangles, and so are the normals from the depth buffer:
+// averaged over several distances, the facets blend into a smoother surface
+vec3 smoothNormalAt(sampler2D depthTexture, vec2 uv, vec3 center) {
+  return normalize(normalAt(depthTexture, uv, center, 2.0 * czm_pixelRatio) + normalAt(depthTexture, uv, center, 6.0 * czm_pixelRatio));
+}

package/src/shaders/Phase.glsl

@@ -0,0 +1,6 @@
+// Henyey-Greenstein's phase function, normalized: 1 / (4 pi) for light scattered alike in all
+// directions, which the haze and the clouds share.
+float henyeyGreenstein(float cosTheta, float g) {
+  float g2 = g * g;
+  return (1.0 - g2) / (4.0 * czm_pi * pow(1.0 + g2 - 2.0 * g * cosTheta, 1.5));
+}

package/src/shaders/Precipitation.glsl

@@ -0,0 +1,199 @@
+// Precipitation, rain or snow: streaks of falling drops in four layers, nearer ones larger, faster
+// and more opaque, in one pass over the scene, after the composite rainfall of ToyShop (Tatarchuk
+// 2006). The drops are laid out on the sphere of view directions, around the direction they fall
+// toward: drops falling along parallel lines appear on great circles through it, so in its Mercator
+// coordinates (the angle around it, and log(tan(theta / 2)) of the angle theta from it) the drops
+// of a layer, at one distance, are a regular grid scrolling at a constant rate: their size and
+// speed on the sphere both go with sin(theta). The streaks fall down the screen at the horizon and
+// radiate from below the camera when it looks down. The drops are hidden behind what is nearer than
+// their layer, and the rain veils the distance in an overcast haze, whose light the drops refract,
+// and in shafts of heavier rain hanging below the cloud base. The wind comes in gusts. The snow,
+// from 0 to 1, turns the rain to snow in one population: the drops slow down from 9 m/s to 1 m/s,
+// which shortens their streak, and grow from thin sharp lines into soft round flakes that flutter,
+// the nearest layer out of focus as in Andrew Baldwin's "Just snow", in a thicker, whiter haze.
+// Where it rains comes from the map: the shafts and the share of each ray in the rain from the
+// shafts' pass, the drops from the map's intensity at the camera, read on the CPU. The haze's length
+// below the cloud base is this pass's, from each pixel's depth, sharp at the ridges. Seen from
+// above, where Clouds draws the clouds, they hide the rain under them: no shafts nor haze.
+// Needs EyeFromDepth, Hash, Height, PrecipitationWind, Fog, Phase and RainHaze.
+precision highp sampler2D;
+const int LAYERS = 4;
+uniform sampler2D colorTexture;
+uniform sampler2D depthTexture;
+// the shafts' opacity, the ray's extinction, the share of it in the rain and the share of the rain
+// in the sun, from PrecipitationShafts.glsl at a fraction of the resolution
+uniform sampler2D shaftTexture;
+// 1 when Clouds draws the clouds, 0 otherwise
+uniform float clouds;
+// 1 when their shadow map lights the haze, 0 otherwise
+uniform float shadowed;
+// the map's intensity at the camera, 0 to 1
+uniform float localIntensity;
+// from the CPU, as they change with the snow: the length of a drop's trail, its motion over the
+// exposure, in cells, and the scroll of the grid along the fall, in cells, wrapped at PERIOD, which
+// has to follow the speed without a jump
+uniform float trail;
+uniform float offset;
+// what the layers share, from the CPU rather than computed for each pixel: the cells around and
+// along the fall per radian, the number of cells around, and the distance in meters; and the
+// brightness, how far the largest drop's shape reaches around its trail in pixels, the radius of a
+// streak and the radius of the largest flake in pixels
+uniform vec4 layerShape[LAYERS];
+uniform vec4 layerLook[LAYERS];
+in vec2 v_textureCoordinates;
+
+// cells along the fall, for the random drops to repeat seamlessly as they scroll
+const float PERIOD = 1000.0;
+// the nearest layer is 2 m away, each further layer twice as far; at the horizon, a drop every
+// 0.05 rad around
+const float NEAREST = 2.0;
+// share of the cells with a drop, at full intensity
+const float DENSITY = 0.6;
+// a drop is a capsule from a point in its cell, its trail within a cell: the cells are taller than
+// wide in the rain, square in the snow
+// how far a flake flutters across its cell, in cells, and a streak wavers in the gusts
+const float FLUTTER = 0.12;
+const float WAVER = 0.08;
+// the drops refract the haze's light, whiter than they would, as the milk film crews add to the
+// water, for rain that shows; the flakes scatter it, near white
+const float RAIN_MILK = 0.25;
+const float SNOW_MILK = 0.35;
+// the shafts' shade of the haze: darker in the rain, lighter in the snow
+const float RAIN_SHAFT_SHADE = 0.75;
+const float SNOW_SHAFT_SHADE = 1.1;
+// the shafts' resolution, precipitation.js's SHAFT_SCALE
+const float SHAFT_SCALE = 0.125;
+
+// the shafts' opacity, the ray's extinction, the share of it in the rain and the share of the rain
+// in the sun, blurred by PrecipitationShaftBlur.glsl and upsampled bilinearly from their texture,
+// which is read at its nearest texel
+vec4 shafts() {
+  // the size Cesium gives the texture
+  vec2 size = ceil(czm_viewport.zw * SHAFT_SCALE);
+  vec2 p = v_textureCoordinates * size - 0.5;
+  vec2 i = floor(p);
+  vec2 f = p - i;
+  vec2 center = (i + 0.5) / size;
+  vec2 texel = 1.0 / size;
+  vec4 bottom = mix(texture(shaftTexture, center), texture(shaftTexture, center + vec2(texel.x, 0.0)), f.x);
+  vec4 top = mix(texture(shaftTexture, center + vec2(0.0, texel.y)), texture(shaftTexture, center + texel), f.x);
+  return mix(bottom, top, f.y);
+}
+
+// the opacity at the pixel of the drop with its head in the cell `back` cells above its own, if it
+// has one: f is the pixel's place in its own cell. The drop morphs from a thin, sharp, long streak
+// to a round, soft, short flake with the snow: its radius and softness, brightness and flutter.
+float drop(vec4 look, float index, float count, float density, float streak, float amplitude, vec2 reach, vec2 pixelCells, vec2 cell, vec2 f, float back) {
+  vec2 id = vec2(mod(cell.x, count), mod(cell.y - back, PERIOD) + PERIOD * index);
+  float h = hash(id);
+  if (h >= density) {
+    return 0.0;
+  }
+  // the drop's random values, from the one hash: uniform in [0, 1) for the cells with a drop; its
+  // head somewhere in the middle of its cell, and the pixel's place around its trail
+  h /= density;
+  vec2 head = vec2(0.25 + 0.5 * fract(h * 13.7), 0.25 + 0.5 * fract(h * 71.3));
+  vec2 toHead = vec2(f.x, f.y + back) - head;
+  // most drops are nowhere near the pixel: the rest of the shape is for the few that are
+  if (abs(toHead.x) > amplitude + reach.x || toHead.y < -reach.y || toHead.y > streak + reach.y) {
+    return 0.0;
+  }
+  // wavering in the gusts or fluttering across the cell at its own rate
+  float rate = mix(1.7, 1.0 + 2.0 * fract(h * 5.1), snow);
+  toHead.x -= amplitude * sin(rate * time + czm_twoPi * fract(h * 7.3));
+  float t = streak > 0.0 ? clamp(toHead.y / streak, 0.0, 1.0) : 0.0;
+  // the distance to the trail, in pixels
+  float distanceToTrail = length(vec2(toHead.x, toHead.y - t * streak) / pixelCells);
+  float radius = mix(look.z, look.w * (0.6 + 0.8 * fract(h * 3.7)), snow);
+  // the nearest layer's flakes out of focus, soft and wide; the others sharp
+  float soft = mix(0.5, index == 0.0 ? 0.8 * radius : 0.5, snow);
+  float coverage = 1.0 - smoothstep(radius - soft, radius + soft, distanceToTrail);
+  // fading out along a streak, not along a flake
+  float taper = mix(1.0, 4.0 * t * (1.0 - t), streak);
+  return look.x * (0.55 + 0.45 * fract(h * 37.1)) * coverage * taper;
+}
+
+void main() {
+  vec4 sceneColor = texture(colorTexture, v_textureCoordinates);
+  // the pixel's view direction and distance, the sky far away, and the angle a pixel covers
+  vec4 eye = eyeAt(depthTexture, v_textureCoordinates);
+  vec3 view = normalize(eye.xyz);
+  float sceneDistance = eye.w == 0.0 ? SKY_DISTANCE : length(eye.xyz);
+  float pixel = 2.0 / (czm_projection[1][1] * czm_viewport.w);
+
+  // the local frame at the camera, in world coordinates
+  vec3 upWorld = upWC();
+  vec3 eastWorld = eastWC();
+  vec3 northWorld = cross(upWorld, eastWorld);
+  float tilt = gustingTilt();
+
+  // none above the cloud base; as hard as it rains at the camera
+  float raining = 1.0 - smoothstep(cloudBase - 50.0, cloudBase + 50.0, cameraHeight);
+
+  // the haze over the part of the ray below the cloud base, as rainy as the shafts' pass found it,
+  // from the rain's to the snow's color; from above, hidden by the clouds where Clouds draws them
+  vec2 below = belowHeight(view * sceneDistance, cloudBase);
+  vec4 sampled = shafts();
+  vec3 shaft = sampled.xyz * (1.0 - clouds * (1.0 - raining));
+  // the rain's, in its bands, and the clear air's and the mist's over the share of the ray in the
+  // rain, thinning out with the height, summed in optical depth
+  float rainLength = (below.y - below.x) * sceneDistance;
+  float h0 = heightAt(view * sceneDistance * below.x);
+  float h1 = heightAt(view * sceneDistance * below.y);
+  float layers = layerDepth(CLEAR_AIR, h0, h1, rainLength) + layerDepth(MIST, h0, h1, rainLength);
+  float haze = rainHaze(rainLength * shaft.y * (1.0 + RAIN_BANDS) * rainExtinction(intensity, snow) + shaft.z * layers);
+  // a rain cell seen from a dry spot is still under its own clouds
+  float overcast = max(localIntensity, min(shaft.y * (1.0 + RAIN_BANDS), 1.0));
+  // the sun through the gaps of the clouds, from their shadow map, or as much as the overcast lets
+  float sunlit = shadowed > 0.0 ? sampled.w : 1.0 - overcast;
+  vec3 hazeColor = rainHazeColor(view, daylight(), snow, overcast, sunlit);
+  vec3 color = mix(sceneColor.rgb, hazeColor, haze);
+
+  color = mix(color, min(mix(RAIN_SHAFT_SHADE, SNOW_SHAFT_SHADE, snow) * hazeColor, vec3(1.0)), shaft.x);
+  float local = intensity * localIntensity;
+  // in eye coordinates: the direction the drops fall toward, tilted toward the east by the wind,
+  // and north across it
+  vec3 fall = czm_viewRotation * (sin(tilt) * eastWorld - cos(tilt) * upWorld);
+  vec3 north = czm_viewRotation * northWorld;
+  vec3 across = normalize(north - dot(north, fall) * fall);
+  vec3 dropColor = min(hazeColor + mix(RAIN_MILK, SNOW_MILK, snow), vec3(1.0));
+
+  float cosTheta = dot(view, fall);
+  float sinTheta = sqrt(max(1.0 - cosTheta * cosTheta, 0.0));
+  // none toward the poles, where the cells shrink below a pixel
+  if (raining > 0.0 && local > 0.0 && sinTheta > 0.01) {
+    float around = atan(dot(view, cross(fall, across)), dot(view, across));
+    float along = log(sinTheta / max(1.0 + cosTheta, 1e-6));
+    float density = DENSITY * local;
+    float streak = trail;
+    float amplitude = mix(WAVER, FLUTTER, snow);
+    // a pixel in radians, around the pole of the fall, where cells shrink
+    float pixelOverSin = pixel / sinTheta;
+    float brightness = raining * (0.5 + 0.5 * local);
+    for (int i = 0; i < LAYERS; i++) {
+      vec4 shape = layerShape[i];
+      // hidden behind what is nearer than the layer
+      float depthFade = smoothstep(0.5, 1.0, sceneDistance / shape.w);
+      // a pixel in cells; the layer fades out as its cells get a few pixels wide
+      vec2 pixelCells = pixelOverSin * shape.xy;
+      float fade = brightness * depthFade * (1.0 - smoothstep(0.15, 0.4, pixelCells.x));
+      if (fade <= 0.0) {
+        continue;
+      }
+      float index = float(i);
+      vec2 p = vec2(around * shape.x, along * shape.y + offset + 0.37 * index);
+      vec2 cell = floor(p);
+      vec2 f = p - cell;
+      vec4 look = layerLook[i];
+      vec2 reach = look.y * pixelCells;
+      // the drops with their head in the pixel's cell, and in the cell above, whose trail or soft
+      // edge may reach into it
+      float alpha = drop(look, index, shape.z, density, streak, amplitude, reach, pixelCells, cell, f, 0.0);
+      if (f.y <= streak) {
+        alpha = 1.0 - (1.0 - alpha) * (1.0 - drop(look, index, shape.z, density, streak, amplitude, reach, pixelCells, cell, f, 1.0));
+      }
+      color = mix(color, dropColor, alpha * fade);
+    }
+  }
+  out_FragColor = vec4(color, sceneColor.a);
+}