@geoblocks/cesium-post-process 0.4.0 → 0.5.0

package/src/shaders/AnalogVideo.glsl

@@ -0,0 +1,132 @@
+// An analog FPV video feed, as in the recordings of FPV pilots' goggles: a soft PAL picture,
+// washed out, its color bleeding sideways (the signal carries the brightness at a higher
+// resolution than the color, yet smeared a little), with ringing beside sharp edges and lines
+// that jitter sideways. As the signal weakens (low over the ground, behind obstacles), the
+// color goes first, the picture washes out toward a cold white and fills with colored streaks:
+// short dashes along the video lines, the clicks of FM video below its threshold. Now and then
+// the receiver loses the sync for a frame or two: the picture tears, a white band and black
+// below it. Without a signal, the receiver shows its own noise: a dark field of colored
+// streaks, the picture and its display gone. After ntsc-rs's chroma lowpass and delay, luma
+// smear and ringing, and the recordings of FPV drones flying low and crashing.
+precision highp sampler2D;
+uniform sampler2D colorTexture;
+// seconds
+uniform float time;
+// 0 to 1
+uniform float noise;
+// per frame: how weak the signal is now, 0 to 1, 1 without a signal; where the picture tears,
+// as a fraction of its height from the top, or -1
+uniform float weak;
+uniform float tear;
+in vec2 v_textureCoordinates;
+
+// PAL video runs at 25 frames per second, in 576 lines of about 720 samples
+const float FRAME_RATE = 25.0;
+const vec2 VIDEO = vec2(720.0, 576.0);
+// in video samples: the color spread on either side, and shifted to the right; the overshoot
+// beside edges; the brightness trailing to the right, as through a lowpass filter
+const float BLEED = 3.0;
+const float BLEED_SHIFT = 1.0;
+const float RING_DISTANCE = 1.5;
+const float RING = 0.5;
+const float SMEAR = 1.0;
+// the white band of a tear, as a fraction of the picture height
+const float TEAR_BAND = 0.07;
+
+// BT.601 luma and color differences
+vec3 toYuv(vec3 rgb) {
+  float y = dot(rgb, vec3(0.299, 0.587, 0.114));
+  return vec3(y, 0.492 * (rgb.b - y), 0.877 * (rgb.r - y));
+}
+
+vec3 toRgb(vec3 yuv) {
+  float b = yuv.x + yuv.y / 0.492;
+  float r = yuv.x + yuv.z / 0.877;
+  return vec3(r, (yuv.x - 0.299 * r - 0.114 * b) / 0.587, b);
+}
+
+float luma(vec2 uv) {
+  return toYuv(texture(colorTexture, uv).rgb).x;
+}
+
+// the streaks of one layer on a video line: at most one starts in each cell of the line, and runs
+// for up to maxSpan samples, shorter than a cell so that only the previous cell reaches this one;
+// with this chance per cell; its color, and its coverage in alpha
+vec4 streaks(float x, float line, float frame, float cell, float maxSpan, float chance, float seed) {
+  float index = floor(x / cell);
+  vec4 streak = vec4(0.0);
+  for (int i = 0; i < 2; i++) {
+    // a new pattern each frame, offset by more cells than a line holds so that frames do not repeat
+    vec2 id = vec2(index - float(i) + frame * 61.0 + seed, line);
+    float start = (index - float(i) + hash(id + 0.5)) * cell;
+    float span = 2.0 + (maxSpan - 2.0) * hash(id + 1.5) * hash(id + 1.5);
+    float along = (x - start) / span;
+    float on = step(hash(id), chance) * step(0.0, along) * step(along, 1.0);
+    float shape = on * smoothstep(0.0, 0.15, along) * (1.0 - smoothstep(0.7, 1.0, along));
+    if (shape > streak.a) {
+      // bright, whitish or colored: magenta, green, blue, yellow
+      float angle = 6.2832 * hash(id + 3.5);
+      vec3 yuv = vec3(0.55 + 0.45 * hash(id + 2.5), 0.22 * hash(id + 4.5) * vec2(cos(angle), sin(angle)));
+      streak = vec4(toRgb(yuv), shape);
+    }
+  }
+  return streak;
+}
+
+void main() {
+  float frame = mod(floor(time * FRAME_RATE), 1000.0);
+  // the video line, counted from the top, and the sample along it
+  float fromTop = 1.0 - v_textureCoordinates.y;
+  float line = floor(fromTop * VIDEO.y);
+  // the lines jitter sideways, more as the signal weakens
+  float shake = (hash(vec2(line, frame)) - 0.5) * (0.4 + 2.0 * weak);
+  vec2 uv = vec2(v_textureCoordinates.x + shake / VIDEO.x, 1.0 - (line + 0.5) / VIDEO.y);
+  float x = uv.x * VIDEO.x;
+
+  // the brightness smeared to the right, with ringing beside the edges; the color averaged sideways
+  // and shifted
+  vec4 sceneColor = texture(colorTexture, uv);
+  vec3 yuv = toYuv(sceneColor.rgb);
+  float texel = 1.0 / VIDEO.x;
+  yuv.x = 0.5 * yuv.x + 0.3 * luma(uv - vec2(0.5 * SMEAR * texel, 0.0)) + 0.2 * luma(uv - vec2(SMEAR * texel, 0.0));
+  float left = luma(uv - vec2(RING_DISTANCE * texel, 0.0));
+  float right = luma(uv + vec2(RING_DISTANCE * texel, 0.0));
+  yuv.x += RING * (yuv.x - 0.5 * (left + right));
+  vec2 color = vec2(0.0);
+  for (int i = -2; i <= 2; i++) {
+    float offset = (BLEED_SHIFT + BLEED * float(i) / 2.0) * texel;
+    color += toYuv(texture(colorTexture, uv - vec2(offset, 0.0)).rgb).yz;
+  }
+  yuv.yz = color / 5.0;
+
+  // washed out: less color and contrast, lifted blacks; as the signal weakens, the color lost and
+  // the picture washed out toward a cold white
+  float wash = smoothstep(0.4, 0.85, weak);
+  yuv.yz *= 0.75 * (1.0 - smoothstep(0.35, 0.6, weak));
+  yuv.x = 0.06 + 0.86 * yuv.x;
+  yuv.x = mix(yuv.x, 0.55 + 0.45 * yuv.x, 0.6 * wash);
+  yuv.yz += vec2(0.04, -0.02) * wash;
+  vec3 rgb = toRgb(yuv);
+
+  // grain, one value per video sample and a new pattern each frame, heavier in the dark
+  float grain = hash(vec2(floor(x), line) + vec2(frame * 37.0, frame * 17.0)) - 0.5;
+  rgb += grain * noise * 0.2 * (1.0 - 0.6 * yuv.x);
+
+  // the sync lost: below the tear, a white band, then black
+  if (tear >= 0.0) {
+    float below = step(tear, fromTop);
+    rgb = mix(rgb, vec3(0.02 + 0.05 * grain), below);
+    rgb = mix(rgb, vec3(0.92), below * (1.0 - smoothstep(0.0, TEAR_BAND, fromTop - tear)));
+  }
+
+  // no signal: the receiver's dark noise instead of the picture
+  rgb = mix(rgb, vec3(0.08 + 0.12 * grain), smoothstep(0.92, 1.0, weak));
+
+  // the streaks, rare in a good signal, everywhere without one: long ones, and short ones as the
+  // signal fails
+  vec4 longStreak = streaks(x, line, frame, 24.0, 18.0, 0.35 * weak * weak * weak, 0.0);
+  vec4 shortStreak = streaks(x, line, frame, 8.0, 6.0, 0.6 * smoothstep(0.5, 1.0, weak), 500.0);
+  vec4 streak = longStreak.a > shortStreak.a ? longStreak : shortStreak;
+  rgb = mix(rgb, streak.rgb, 0.85 * streak.a);
+  out_FragColor = vec4(clamp(rgb, 0.0, 1.0), sceneColor.a);
+}

package/src/shaders/Beam.glsl

@@ -0,0 +1,108 @@
+// The beam of a cone of light in the haze, for the spotlight and for lights of your own:
+// raymarched along the part of the view ray inside the cone, found analytically, so that no
+// sample is wasted and pixels next to each other see the same stretch of it. Needs Hash, and
+// Noise for the dust.
+
+struct Beam {
+  // the cone: its apex and the direction it points, in eye coordinates
+  vec3 apex;
+  vec3 forward;
+  // cosines of its half angle, and of the angle within which its core is hot
+  float edgeCos;
+  float coreCos;
+  // brightness of the core over the rest of the cone, 0 for a plain penumbra
+  float hotCore;
+  // the light's position, from which the haze's brightness falls off as reference^2 over
+  // (core^2 + distance^2): 1 at the reference distance for a small core, softened within it
+  vec3 light;
+  float reference;
+  float core;
+  // how far along the view ray the haze is lit, meters, and its extinction on the way, per meter
+  float reach;
+  float extinction;
+  // Henyey-Greenstein asymmetry, 0 to 1: forward scattering
+  float anisotropy;
+  // exponent of the spacing of the samples along the ray: 1 for even, 2 for dense at the start
+  float spacing;
+  // the lit haze fades in over this stretch of the view ray, meters; none when empty
+  vec2 nearFade;
+  // dust catching the light: noise across the beam, constant along each line from the light so
+  // that it streaks, in world coordinates so that it stays when the camera turns; its contrast
+  // and its density across the width of the beam
+  float dust;
+  float dustScale;
+};
+
+const int BEAM_SAMPLES = 8;
+
+// the part of the view ray, from the camera at the origin, inside the cone: entry and exit
+// distances, exit before entry when the ray misses it
+vec2 coneSegment(vec3 ray, vec3 apex, vec3 forward, float edgeCos) {
+  // points t * ray in the cone: dot(p, forward)^2 >= edgeCos^2 dot(p, p), with p from the apex
+  vec3 v = -apex;
+  float k2 = edgeCos * edgeCos;
+  float rd = dot(ray, forward);
+  float vd = dot(v, forward);
+  float a = rd * rd - k2;
+  // a ray along the surface of the cone would divide by zero
+  a = abs(a) < 1e-7 ? -1e-7 : a;
+  float b = rd * vd - k2 * dot(ray, v);
+  float c = vd * vd - k2 * dot(v, v);
+  float discriminant = b * b - a * c;
+  if (discriminant < 0.0) {
+    return vec2(1.0, 0.0);
+  }
+  float root = sqrt(discriminant);
+  float t1 = (-b - root) / a;
+  float t2 = (-b + root) / a;
+  vec2 segment = a < 0.0 ? vec2(min(t1, t2), max(t1, t2))
+    // a ray steeper than the cone stays in it on one side, of the lit nappe or the other one
+    : rd > 0.0 ? vec2(max(t1, t2), 1e30) : vec2(-1e30, min(t1, t2));
+  // ahead of the apex, not in the mirrored cone behind it
+  return vd + 0.5 * (segment.x + segment.y) * rd > 0.0 ? segment : vec2(1.0, 0.0);
+}
+
+// Henyey-Greenstein phase, normalized over the sphere
+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));
+}
+
+// the haze lit by the beam along the view ray up to sceneDistance: samples over the part of the
+// ray inside the cone, each weighted by the softness of the cone with its core, the dust, the
+// falloff from the light and what the haze has dimmed so far, dithered per pixel so that they do
+// not band, then scattered toward the camera
+float beamAlong(vec3 ray, float sceneDistance, Beam beam) {
+  vec2 segment = coneSegment(ray, beam.apex, beam.forward, beam.edgeCos);
+  float start = max(segment.x, 0.0);
+  float end = min(min(segment.y, sceneDistance), beam.reach);
+  if (end <= start) {
+    return 0.0;
+  }
+  float length_ = end - start;
+  float jitter = pixelNoise(gl_FragCoord.xy);
+  float scattered = 0.0;
+  float transmittance = exp(-beam.extinction * start);
+  for (int i = 0; i < BEAM_SAMPLES; i++) {
+    float u = (float(i) + jitter) / float(BEAM_SAMPLES);
+    float t = start + length_ * pow(u, beam.spacing);
+    // pow(0, 0) is undefined, a NaN on some GPUs, where the jitter is 0
+    float step = length_ * beam.spacing * pow(max(u, 1e-6), beam.spacing - 1.0) / float(BEAM_SAMPLES);
+    vec3 p = ray * t;
+    vec3 fromApex = p - beam.apex;
+    float cosine = dot(fromApex, beam.forward) / length(fromApex);
+    float cone = smoothstep(beam.edgeCos, beam.coreCos, cosine) + beam.hotCore * smoothstep(beam.coreCos, 1.0, cosine);
+    vec3 fromLight = p - beam.light;
+    if (beam.dust > 0.0) {
+      float along = max(dot(fromLight, beam.forward), 1e-3);
+      vec3 section = czm_inverseViewRotation * ((fromLight - along * beam.forward) * 2.0 / along);
+      float noise = gradientNoise(beam.dustScale * section) + 0.25 * gradientNoise(2.0 * beam.dustScale * section);
+      cone *= 1.0 + beam.dust * noise;
+    }
+    float falloff = beam.reference * beam.reference / (beam.core * beam.core + dot(fromLight, fromLight));
+    float fade = beam.nearFade.y > beam.nearFade.x ? smoothstep(beam.nearFade.x, beam.nearFade.y, t) : 1.0;
+    scattered += transmittance * cone * falloff * fade * step;
+    transmittance *= exp(-beam.extinction * step);
+  }
+  return scattered * henyeyGreenstein(dot(ray, beam.forward), beam.anisotropy);
+}

package/src/shaders/CloudsBlur.glsl

@@ -0,0 +1,30 @@
+// The clouds blurred over the neighboring texels at the march's resolution, as the precipitation's
+// shafts are: an edge thinner than a texel would otherwise come out of the upscale as a square. A
+// 3 x 3 binomial kernel here costs a 16th of the reads the same blur would take at the full
+// resolution. Only the neighbors at about the texel's depth count, so a cloud over the sky does not
+// bleed onto a ridge in front of it.
+precision highp sampler2D;
+uniform sampler2D cloudTexture;
+// the farthest distance of the scene in each texel's block of pixels, from CloudsDepth.glsl
+uniform sampler2D cloudDepth;
+in vec2 v_textureCoordinates;
+
+// texels are at the same depth within this share of it, CloudsComposite.glsl's
+const float DEPTH_TOLERANCE = 0.1;
+
+void main() {
+  // czm_viewport is this pass's texture, the size of the march's
+  vec2 texel = 1.0 / czm_viewport.zw;
+  float here = texture(cloudDepth, v_textureCoordinates).r;
+  vec4 sum = vec4(0.0);
+  float weights = 0.0;
+  for (int y = -1; y <= 1; y++) {
+    for (int x = -1; x <= 1; x++) {
+      vec2 uv = v_textureCoordinates + vec2(float(x), float(y)) * texel;
+      float weight = (x == 0 ? 2.0 : 1.0) * (y == 0 ? 2.0 : 1.0) * (abs(texture(cloudDepth, uv).r - here) <= DEPTH_TOLERANCE * here ? 1.0 : 0.0);
+      sum += weight * texture(cloudTexture, uv);
+      weights += weight;
+    }
+  }
+  out_FragColor = sum / weights;
+}

package/src/shaders/CloudsComposite.glsl

@@ -0,0 +1,59 @@
+// The clouds over the scene: the march's samples at a fraction of the resolution, upscaled
+// bilinearly from those whose depth, the farthest of their block of pixels, is about this pixel's,
+// and from the one nearest in depth where none is, rather than weighting the bilinear weights by
+// the depths, which "can select only one sample, but that sample is not similar to the surface
+// depth you need at all" (Pesce 2016): a ridge in front of a cloud keeps a sharp outline rather
+// than a halo of the march's resolution. The clouds' shadows darken the scene under them, from the
+// shadow map. Needs EyeFromDepth, Height, CloudsSlab and CloudsShadow.
+precision highp sampler2D;
+uniform sampler2D colorTexture;
+uniform sampler2D depthTexture;
+// the light the clouds scatter toward the camera, and the share of the scene seen through them
+uniform sampler2D cloudTexture;
+// the farthest distance of the scene in each texel's block of pixels, from CloudsDepth.glsl
+uniform sampler2D cloudDepth;
+in vec2 v_textureCoordinates;
+
+// the march's resolution, clouds.js's CLOUD_SCALE, and the sky's distance, past any terrain,
+// CloudsDepth.glsl's
+const float CLOUD_SCALE = 0.25;
+const float SKY_DISTANCE = 1e9;
+// texels are at this pixel's depth within this share of it, CloudsBlur.glsl's
+const float DEPTH_TOLERANCE = 0.1;
+// the clouds' shadow takes at most this share of the scene's light: the sunlit share of a lit
+// scene, as precipitation.js's OVERCAST
+const float SHADOW_STRENGTH = 0.5;
+
+void main() {
+  vec4 sceneColor = texture(colorTexture, v_textureCoordinates);
+  vec2 size = ceil(czm_viewport.zw * CLOUD_SCALE);
+  vec2 position = v_textureCoordinates * size - 0.5;
+  vec2 corner = floor(position);
+  vec2 f = position - corner;
+  float here = eyeDistance(depthTexture, v_textureCoordinates, SKY_DISTANCE);
+  vec4 sum = vec4(0.0);
+  float weights = 0.0;
+  vec4 nearest = vec4(0.0);
+  float nearestGap = 1e30;
+  for (int y = 0; y <= 1; y++) {
+    for (int x = 0; x <= 1; x++) {
+      vec2 uv = (corner + vec2(float(x), float(y)) + 0.5) / size;
+      vec4 sampled = texture(cloudTexture, uv);
+      float gap = abs(texture(cloudDepth, uv).r - here);
+      float weight = gap <= DEPTH_TOLERANCE * here ? (x == 0 ? 1.0 - f.x : f.x) * (y == 0 ? 1.0 - f.y : f.y) : 0.0;
+      sum += weight * sampled;
+      weights += weight;
+      if (gap < nearestGap) {
+        nearestGap = gap;
+        nearest = sampled;
+      }
+    }
+  }
+  vec4 cloud = weights > 1e-4 ? sum / weights : nearest;
+  vec4 eye = eyeAt(depthTexture, v_textureCoordinates);
+  if (eye.w != 0.0) {
+    vec3 positionWC = (czm_inverseView * vec4(eye.xyz, 1.0)).xyz;
+    sceneColor.rgb *= mix(1.0 - SHADOW_STRENGTH, 1.0, exp(-shadowDepth(positionWC)));
+  }
+  out_FragColor = vec4(sceneColor.rgb * cloud.a + cloud.rgb, sceneColor.a);
+}

package/src/shaders/CloudsDensity.glsl

@@ -0,0 +1,129 @@
+// The clouds' density at a point, which the march and the shadow map share: as tall and as solid
+// as the rain under it is heavy, shaped by billows of noise that drift with the wind. Needs
+// CloudsSlab and WeatherMap.
+// the noise: the billows of the base shape in red, the details in green and blue
+precision highp sampler2D;
+uniform highp sampler3D cloudNoise;
+// the noise over the clouds' map, a square that repeats, from cloud-noise.js
+uniform sampler2D mapNoise;
+// meters above the ellipsoid
+uniform float cloudTop;
+// the direction the wind blows toward, and how far it has carried the noise, in world coordinates
+uniform vec3 windDirection;
+uniform vec3 windOffset;
+// scale of the opacity
+uniform float density;
+
+// the clouds over the lightest rain are this thick, in meters, clouds.js's THIN_DEPTH
+const float THIN_DEPTH = 1500.0;
+// the clouds' base is flat, reaching their full density over this share of their height,
+// remap(h, 0, 0.05, 0, 1): the lifting condensation level is about the same across an air mass; the
+// deck is full up to this share of its height, then thins out to its top; towers thin out all the
+// way up, in the convective envelope pow(1 - h, 1.5) (Schneider 2022); and spread an anvil from
+// this share of their height to this one, their coverage raised to a power from 1 to this one,
+// pow(coverage, remap(h, 0.7, 0.8, 1, lerp(1, 0.5, anvil_bias))) (Schneider 2017). The report
+// gives these as starting points, not from a source it could check
+const float FLAT_BASE = 0.05;
+const float DECK_TOP = 0.65;
+const float TOWER_ENVELOPE = 1.5;
+const vec3 ANVIL = vec3(0.7, 0.8, 0.5);
+// the cloud shield over dry ground is broken: its coverage is this share of the clouds' over the
+// rain, which the rain raises to the full
+const float SHIELD_COVERAGE = 0.5;
+// the map's cells are read jittered by up to this share of a cell, uv + 0.3 * perlin2(uv * k)
+// cells, so that their squares do not show; and the coverage varies by up to this share around its
+// mean, by noise over 8 cells, 8 km of the radar's 1 km cells, a pattern that is not the billows'
+// noise, whose tile would show (Högfeldt 2016). Both from a square of noise made once
+// (cloud-noise.js), read once rather than computed three times at each sample, which spans this
+// many of the map's cells, cloud-noise.js's MAP_TILE_CELLS
+const float MAP_JITTER = 0.3;
+const float COVERAGE_NOISE = 0.4;
+const float MAP_TILE_CELLS = 64.0;
+
+// the clouds' map at a point in world coordinates, jittered, its coverage varied, 0 outside the map
+vec4 cloudMapAt(vec3 positionWC) {
+  vec2 cells = vec2(textureSize(map, 0));
+  vec2 uv = mapUv(positionWC);
+  // the jitter in red and green, the coverage's variation in blue, -1 to 1
+  vec3 noise = texture(mapNoise, uv * cells / MAP_TILE_CELLS).rgb * 2.0 - 1.0;
+  uv += MAP_JITTER * noise.rg / cells;
+  if (any(lessThan(uv, vec2(0.0))) || any(greaterThan(uv, vec2(1.0)))) {
+    return vec4(0.0);
+  }
+  vec4 texel = mix(texture(map, uv), texture(nextMap, uv), mapBlend);
+  texel.g = clamp(texel.g * (1.0 + COVERAGE_NOISE * noise.b), 0.0, 1.0);
+  return texel;
+}
+// extinction inside a solid cloud, per meter: about 1.3 km of visibility
+const float EXTINCTION = 0.003;
+// the noise repeats every this many meters, in 4 billows across, with this many voxels, clouds.js's
+// NOISE_SIZE, and its details are about this size
+const float NOISE_TILE = 16000.0;
+const float NOISE_VOXELS = 64.0;
+const float DETAIL_SIZE = 1000.0;
+// the scale of the larger lookup of the noise, not a fraction that would line its tiles up
+const float LARGE_SCALE = 0.27;
+// the noise is read this many mipmaps blurrier than a pixel's footprint: its features then span a
+// few pixels of the pass, rather than one that the upscale would turn into a square
+const float LOD_BIAS = 1.5;
+// the clouds lean downwind by this many meters from the base to the top of the slab,
+// p += height_fraction * wind_direction * 500 (Schneider 2017)
+const float WIND_SKEW = 500.0;
+// how much the details erode the thin edges of the clouds
+const float EROSION = 0.6;
+// the details are wisps at the base of a cloud, billows above this share of its height: inverted
+// Worley noise at the base for "some nice whispy shapes" (Schneider 2015)
+const float WISPY_BASE = 0.3;
+
+// the cloud's density at a point, 0 to the density uniform, from the clouds' map (cloud-map.js):
+// where its shield covers the ground, as tall as its type, a deck over drizzle to towers over heavy
+// rain, and as solid as the rain under it is heavy, which it gives, with the share of the height of
+// its column and its dimensional profile. The noise is read at the mipmap of the footprint of a
+// pixel, in meters, and the details fade out as it grows: sampled once a pixel, finer noise would
+// alias into speckles
+float cloudDensity(vec3 positionWC, float h, float footprint, out float rain, out float column, out float dimensional) {
+  // the rain in red, the shield's coverage in green, the clouds' type in blue
+  vec4 cell = cloudMapAt(positionWC);
+  float m = cell.r;
+  float type = cell.b;
+  rain = m;
+  column = 0.0;
+  dimensional = 0.0;
+  if (cell.g <= 0.0) {
+    return 0.0;
+  }
+  float top = cloudBase + mix(THIN_DEPTH, cloudTop - cloudBase, type);
+  float y = (h - cloudBase) / (top - cloudBase);
+  column = y;
+  if (y <= 0.0 || y >= 1.0) {
+    return 0.0;
+  }
+  float base = clamp(y / FLAT_BASE, 0.0, 1.0);
+  float profile = base * mix(1.0 - smoothstep(DECK_TOP, 1.0, y), pow(1.0 - y, TOWER_ENVELOPE), type);
+  float lod = max(log2(footprint * NOISE_VOXELS / NOISE_TILE) + LOD_BIAS, 0.0);
+  // the noise drifts with the wind and the map does not, so the clouds stay where it rains and
+  // their billows pass through them (Schneider 2017)
+  float slabFraction = clamp((h - cloudBase) / (cloudTop - cloudBase), 0.0, 1.0);
+  vec3 q = (positionWC - windOffset - WIND_SKEW * slabFraction * windDirection) / NOISE_TILE;
+  vec4 noise = textureLod(cloudNoise, fract(q), lod);
+  // the same noise about four times larger, its axes swapped, breaks up the repetition of the tile,
+  // which far views would show as a grid
+  float large = textureLod(cloudNoise, fract(LARGE_SCALE * q.zxy + 0.5), max(lod + log2(LARGE_SCALE), 0.0)).r;
+  noise.r = clamp(noise.r + 0.6 * (large - 0.5), 0.0, 1.0);
+  float coverage = cell.g * mix(SHIELD_COVERAGE, 1.0, m);
+  coverage = pow(coverage, mix(1.0, mix(1.0, ANVIL.z, type), clamp((y - ANVIL.x) / (ANVIL.y - ANVIL.x), 0.0, 1.0)));
+  dimensional = profile * coverage;
+  // the profile times the coverage carves the noise rather than scaling it,
+  // saturate(noise - (1 - dimensional_profile)) (Schneider 2022): the core stays solid, and only
+  // the noise's highest billows reach the top and the base. Ramped up over a softness rather than
+  // sharpened by a power as in Nubis Cubed (Schneider 2023): with 250 m voxels, a sharp edge
+  // follows their interpolation in a grid. The edges soften as the pixels grow, which would
+  // otherwise cut them in steps of the pass's resolution
+  float soft = 0.15 + 0.35 * clamp(footprint / 2000.0, 0.0, 1.0);
+  float shape = smoothstep(0.0, soft, noise.r - (1.0 - profile * coverage));
+  // the details erode where the cloud is thin, its edges, and leave its core solid
+  float billows = mix(noise.g, noise.b, 0.4);
+  float detail = mix(1.0 - billows, billows, clamp(y / WISPY_BASE, 0.0, 1.0)) * (1.0 - smoothstep(0.25, 0.5, footprint / DETAIL_SIZE));
+  float erosion = EROSION * detail * (1.0 - shape);
+  return density * clamp((shape - erosion) / (1.0 - erosion), 0.0, 1.0);
+}

package/src/shaders/CloudsDepth.glsl

@@ -0,0 +1,26 @@
+// The farthest distance of the scene in each block of pixels of the clouds' march, at its
+// resolution: the march goes as far as it, and the blur and the upscale compare their texels by it,
+// so a cloud over the sky does not stop at a ridge in its block. "There is absolutely no physical or
+// theoretical basis for this. It just looks better than halos" (Cantlay, GPU Gems 3, ch. 23).
+// Needs EyeFromDepth.
+precision highp sampler2D;
+uniform sampler2D depthTexture;
+in vec2 v_textureCoordinates;
+
+// the pixels of a block across, one over clouds.js's CLOUD_SCALE, and the sky's distance, past any
+// terrain
+const int BLOCK = 4;
+const float SKY_DISTANCE = 1e9;
+
+void main() {
+  // czm_viewport is this pass's texture, the march's size
+  vec2 pixel = 1.0 / (czm_viewport.zw * float(BLOCK));
+  float farthest = 0.0;
+  for (int y = 0; y < BLOCK; y++) {
+    for (int x = 0; x < BLOCK; x++) {
+      vec2 offset = (vec2(float(x), float(y)) - 0.5 * float(BLOCK - 1)) * pixel;
+      farthest = max(farthest, eyeDistance(depthTexture, v_textureCoordinates + offset, SKY_DISTANCE));
+    }
+  }
+  out_FragColor = vec4(farthest, 0.0, 0.0, 1.0);
+}

package/src/shaders/CloudsMarch.glsl

@@ -0,0 +1,174 @@
+// Clouds from a map of the rain, raymarched at a fraction of the resolution: the light they scatter
+// toward the camera, and the share of the scene still seen through them, along each view ray. They
+// fill a slab above the cloud base where the map has rain: a flat layer over drizzle, towers up to
+// the cloud top over the heaviest rain, with a rounded base and top, shaped by billows of noise
+// that repeats in world coordinates, read from a texture made once (cloud-noise.js): wispy over
+// light rain and solid over heavy rain, with details eroding their edges, not their cores. The sun lights them through a few
+// samples toward it, with a silver lining toward it, its light scattered more than once brightening
+// their cores, and the sky lights them, brighter at their top: thick clouds are dark gray from
+// below and white from above. The steps are short near the camera and longer with the distance, so
+// a camera inside a cloud is in its fog. Precipitation, activated after them, draws the rain's haze
+// over them. Needs EyeFromDepth, Height, CloudsSlab, WeatherMap, CloudsDensity, Fog, Phase and
+// RainHaze.
+precision highp sampler2D;
+uniform sampler2D depthTexture;
+// the farthest distance of the scene in this texel's block of pixels, from CloudsDepth.glsl
+uniform sampler2D cloudDepth;
+// the highest rain around each block of the map's pixels, over both maps, from weather-map.js
+uniform sampler2D maxMap;
+// the frames drawn, for the jitter to change at each, and CloudsResolve.glsl to accumulate them
+uniform float frame;
+in vec2 v_textureCoordinates;
+
+const int STEPS = 32;
+// the ray is probed at this many points of the max map before its march, less than a block of it
+// apart over MAX_DISTANCE, 5 km for the 4 km blocks of a 1 km map: the march starts where the ray
+// drops below the tallest cloud they find, and is skipped where they find no rain, rather than
+// spending its steps in the empty air above the clouds (the coverage early-out of Schneider 2015)
+const int RAY_PROBES = 8;
+// the sun's light through the cloud, sampled at these distances toward it, in meters
+const vec2 LIGHT_DISTANCES = vec2(200.0, 700.0);
+// the sky's light on the clouds at their base and at their top, by day, and the moon's share of it
+// at night. By day, their tops see the sky overhead, in the color of Cesium's at its luminance, and
+// their bases the sunlight the ground bounces (Hillaire 2016, sec. 5.5.1), less as the sun is lower
+// than this sine of its height. Cesium's sky itself, and an albedo of 0.1 to 0.3 for the ground,
+// would leave the tops gray: our two samples toward the sun let little of it through
+const vec3 AMBIENT_BASE = vec3(0.32, 0.35, 0.40);
+const vec3 AMBIENT_TOP = vec3(0.62, 0.66, 0.72);
+const float HIGH_SUN = 0.5;
+// the sky's color on the clouds' tops is desaturated toward its gray, keeping this share of it: in
+// full, its hue turns the tops sky blue, where the sun's white light dominates them (Hillaire 2016,
+// sec. 5.5.1, lets artists desaturate the sky's light)
+const float SKY_SATURATION = 0.3;
+// the sky's light inside a cloud is occluded by its dimensional profile, its height profile times
+// its coverage, pow(1 - dimensional_profile, 0.5) (Schneider 2022): bright at its edges and top,
+// dark in its core; and by the lack of light from below at its base, in the share of its column's height
+// pow(remap(h, 0.07, 0.14, 0.1, 1.0), 0.8) (Schneider 2017): its bases are dark
+const vec2 DARK_BASE = vec2(0.07, 0.14);
+// the clouds over the heaviest rain absorb this share of the light they intercept, for the
+// "foreboding dark clouds" of Horizon Zero Dawn (Schneider 2015)
+const float RAIN_ALBEDO = 0.8;
+const float SUN = 0.8;
+// the sun's light scattered more than once, as octaves of the light scattered once (Wrenninge's,
+// Hillaire 2016, sec. 5.8, eq. 19-20): octave n has a^n of the scattering, b^n of the extinction and
+// c^n of the phase's eccentricity, so it reaches deeper into the cloud, more alike in all
+// directions. a <= b keeps it from scattering more light than reaches it; 0.5 each, Unreal's
+// defaults, and 2 octaves, as Unreal and RDR2
+const int OCTAVES = 2;
+const float OCTAVE_SCATTERING = 0.5;
+const float OCTAVE_EXTINCTION = 0.5;
+const float OCTAVE_ECCENTRICITY = 0.5;
+const vec3 MOONLIGHT = vec3(0.60, 0.63, 0.70);
+
+// Henyey-Greenstein's phase function, times 4 pi: 1 for light scattered alike in all directions
+float phase(float cosTheta, float g) {
+  return 4.0 * czm_pi * henyeyGreenstein(cosTheta, g);
+}
+
+void main() {
+  vec4 eye = eyeAt(depthTexture, v_textureCoordinates);
+  vec3 direction = normalize(eye.xyz);
+  // the farthest of the texel's pixels, the sky past the slab: the slab ends its rays
+  float sceneDistance = texture(cloudDepth, v_textureCoordinates).r;
+  vec2 segment = slab(dot(direction, up), sceneDistance, slabTop);
+  float span = segment.y - segment.x;
+  if (span <= 0.0) {
+    out_FragColor = vec4(0.0, 0.0, 0.0, 1.0);
+    return;
+  }
+  vec3 directionWC = czm_inverseViewRotation * direction;
+  // the clouds' map's coverage, and its tallest type
+  float covered = 0.0;
+  float highest = 0.0;
+  for (int k = 0; k < RAY_PROBES; k++) {
+    vec2 uv = mapUv(czm_viewerPositionWC + directionWC * (segment.x + span * (float(k) + 0.5) / float(RAY_PROBES)));
+    if (all(greaterThanEqual(uv, vec2(0.0))) && all(lessThanEqual(uv, vec2(1.0)))) {
+      vec4 cell = texture(maxMap, uv);
+      covered = max(covered, cell.g);
+      highest = max(highest, cell.b);
+    }
+  }
+  segment = slab(dot(direction, up), sceneDistance, cloudBase + mix(THIN_DEPTH, cloudTop - cloudBase, highest));
+  span = segment.y - segment.x;
+  if (covered <= 0.0 || span <= 0.0) {
+    out_FragColor = vec4(0.0, 0.0, 0.0, 1.0);
+    return;
+  }
+  vec3 lightWC = czm_inverseViewRotation * czm_lightDirectionEC;
+  // a forward lobe for the silver lining, a weak backward one, for each octave: the sun is a
+  // direction, the angle is the same along the ray
+  float cosTheta = dot(direction, czm_lightDirectionEC);
+  float octaves[OCTAVES];
+  float contribution = 1.0;
+  float eccentricity = 1.0;
+  for (int n = 0; n < OCTAVES; n++) {
+    octaves[n] = contribution * mix(phase(cosTheta, -0.2 * eccentricity), phase(cosTheta, 0.6 * eccentricity), 0.7);
+    contribution *= OCTAVE_SCATTERING;
+    eccentricity *= OCTAVE_ECCENTRICITY;
+  }
+  float day = daylight();
+  // the far clouds fade into the sky behind them as Cesium's fog fades the terrain, by its factor at
+  // each step's distance: the same aerial perspective on the clouds as on the earth, without which
+  // "a visual discrepancy happens at the horizon between clouds and earth" (Hillaire 2016, sec.
+  // 5.9.1). The sky toward the view, at least SKY_ELEVATION above the horizon
+  vec3 fogColor = skyToward(direction, max(asin(clamp(dot(direction, up), -1.0, 1.0)), SKY_ELEVATION));
+  vec3 sunLight = SUN * czm_lightColor * day;
+  // the sky overhead, and the sunlight from the ground, by day; the moon's at night
+  vec3 zenith = clearSkyBelow(cloudBase, czm_inverseViewRotation * up, czm_lightDirectionWC);
+  vec3 skyHue = mix(vec3(1.0), zenith / max(czm_luminance(zenith), 1e-3), SKY_SATURATION);
+  vec3 skyAbove = mix(MOONLIGHT, skyHue, day) * czm_luminance(AMBIENT_TOP);
+  vec3 groundBelow = AMBIENT_BASE * mix(MOONLIGHT, czm_lightColor * clamp(dot(up, czm_lightDirectionEC) / HIGH_SUN, 0.0, 1.0), day);
+  // interleaved gradient noise, a different start along the ray for each pixel, and at each frame,
+  // by the golden ratio (Wolfe 2020)
+  // the angle a pixel of this pass covers
+  float pixelAngle = 2.0 / (czm_projection[1][1] * czm_viewport.w);
+  float jitter = fract(52.9829189 * fract(dot(gl_FragCoord.xy, vec2(0.06711056, 0.00583715))) + 0.618034 * frame);
+  vec3 light = vec3(0.0);
+  float transmittance = 1.0;
+  float rain;
+  float column;
+  float dimensional;
+  float unused;
+  for (int i = 0; i < STEPS; i++) {
+    float s = (float(i) + jitter) / float(STEPS);
+    float t = segment.x + span * s * s;
+    float dt = span * (2.0 * s + 1.0 / float(STEPS)) / float(STEPS);
+    vec3 pointEC = direction * t;
+    float h = heightAt(pointEC);
+    vec3 pointWC = czm_viewerPositionWC + directionWC * t;
+    float footprint = t * pixelAngle;
+    float sigma = EXTINCTION * cloudDensity(pointWC, h, footprint, rain, column, dimensional);
+    if (sigma <= 0.0) {
+      continue;
+    }
+    // the sun's light through the cloud toward it
+    float opticalDepth = 0.0;
+    float previous = 0.0;
+    for (int j = 0; j < 2; j++) {
+      // jittered as the step, for the samples of neighboring pixels not to band (Hillaire 2016,
+      // sec. 5.5.2)
+      float distanceToward = LIGHT_DISTANCES[j] * (0.75 + 0.5 * jitter);
+      opticalDepth += EXTINCTION * cloudDensity(pointWC + lightWC * distanceToward, heightAt(pointEC + czm_lightDirectionEC * distanceToward), footprint, unused, unused, unused) * (distanceToward - previous);
+      previous = distanceToward;
+    }
+    float sunThrough = 0.0;
+    float occlusion = 1.0;
+    for (int n = 0; n < OCTAVES; n++) {
+      sunThrough += octaves[n] * exp(-opticalDepth * occlusion);
+      occlusion *= OCTAVE_EXTINCTION;
+    }
+    float y = clamp((h - cloudBase) / (cloudTop - cloudBase), 0.0, 1.0);
+    float ambientOcclusion = sqrt(max(1.0 - dimensional, 0.0)) * pow(mix(0.1, 1.0, clamp((column - DARK_BASE.x) / (DARK_BASE.y - DARK_BASE.x), 0.0, 1.0)), 0.8);
+    vec3 scattered = sunLight * sunThrough + mix(groundBelow, skyAbove, y) * ambientOcclusion;
+    float stepTransmittance = exp(-sigma * dt);
+    // the light scattered over the step, the integral of the source over it, (S - S T) / sigma_t
+    // (Hillaire 2016, eq. 17): the albedo, sigma_s / sigma_t, of what the step intercepts
+    vec3 seen = czm_fog(t, scattered * mix(1.0, RAIN_ALBEDO, rain), fogColor, czm_fogVisualDensityScalar);
+    light += transmittance * seen * (1.0 - stepTransmittance);
+    transmittance *= stepTransmittance;
+    if (transmittance < 0.03) {
+      break;
+    }
+  }
+  out_FragColor = vec4(min(light, vec3(1.0)), transmittance);
+}