@geoblocks/cesium-post-process 0.3.0 → 0.5.0

package/{rain-rings.js → src/rain-rings.js}

@@ -1,10 +1,10 @@
-import {Cartesian3, Cartesian4, Color, FixedFrameTransforms, Matrix4, Math as CesiumMath} from '@cesium/core';
+import {Cartesian3, Cartesian4, Color, Math as CesiumMath} from '@cesium/core';
 import {PostProcessStage} from '@cesium/engine';
 import {acquireTerrainDepth, releaseTerrainDepth} from './depth-test.js';
 import Effect from './effect.js';
 import {acquireFrames, releaseFrames} from './frame-clock.js';
 import {heightUniforms} from './height.js';
-import {localFromEye} from './local-frame.js';
+import {LocalFrame} from './local-frame.js';
 import EyeFromDepth from './shaders/EyeFromDepth.js';
 import Hash from './shaders/Hash.js';
 import Height from './shaders/Height.js';
@@ -28,10 +28,11 @@ export default class RainRings extends Effect {
   /**
    * @param {import('@cesium/engine').CesiumWidget} viewer
    * @param {{intensity?: number, cell?: number, reach?: number, waterLevel?: number, maxSlope?: number, rate?: number,
-   *   color?: Color, origin?: Cartesian3}} [options] The share of the cells that have a drop, 0 to 1; the cell's size and the ring's growth
-   *   on the ground, in meters (the ring on water is clipped at 0.3 cell); the water's height above the ellipsoid, in meters, or undefined
-   *   for none; the steepest slope that takes a ring, in degrees; rings a second in a cell; the ring's color, its alpha how strongly it shows; the
-   *   point of the world the cells are laid about.
+   *   color?: Color, origin?: Cartesian3, clock?: () => number}} [options] The share of the cells that have a drop, 0 to 1; the cell's size
+   *   and the ring's growth on the ground, in meters (the ring on water is clipped at 0.3 cell); the water's height above the ellipsoid, in
+   *   meters, or undefined for none; the steepest slope that takes a ring, in degrees; rings a second in a cell; the ring's color, its alpha how
+   *   strongly it shows; the point of the world the cells are laid about; the time the rings run by, in seconds (the wall clock's by default;
+   *   one that stands still keeps them still, for a viewer who asks for less motion).
    */
   constructor(viewer, options = {}) {
     super(viewer);
@@ -42,23 +43,9 @@ export default class RainRings extends Effect {
     this.maxSlope_ = options.maxSlope ?? 30;
     this.rate_ = options.rate ?? 1.6;
     this.color_ = options.color ?? new Color(0.31, 0.39, 0.5, 0.6);
-    this.origin_ = options.origin && Cartesian3.clone(options.origin);
-    /** @type {Matrix4 | undefined} */
-    this.localFrame_ = undefined;
+    this.frame_ = new LocalFrame(options.origin);
+    this.clock_ = options.clock ?? (() => performance.now() / 1000);
     this.colorScratch_ = new Cartesian4();
-    this.localScratch_ = new Matrix4();
-  }
-
-  /**
-   * The local frame, east-north-up about the origin: the camera's position when the effect is activated, if none was given.
-   * @private
-   * @param {import('@cesium/engine').Scene} scene
-   */
-  frameAt_(scene) {
-    this.origin_ ??= Cartesian3.clone(scene.camera.positionWC);
-    const frame = this.localFrame_ ?? FixedFrameTransforms.eastNorthUpToFixedFrame(this.origin_, scene.ellipsoid, new Matrix4());
-    this.localFrame_ = frame;
-    return frame;
   }
 
   /**
@@ -70,14 +57,14 @@ export default class RainRings extends Effect {
       fragmentShader: EyeFromDepth + Height + Hash + Normal + RainRingsShader,
       uniforms: {
         ...heightUniforms(scene),
-        localFromEye: () => localFromEye(this.frameAt_(scene), scene.camera.viewMatrix, this.localScratch_),
+        localFromEye: () => this.frame_.fromEye(scene),
         intensity: () => this.intensity_,
         cell: () => this.cell_,
         reach: () => this.reach_,
         waterLevel: () => this.waterLevel_ ?? NO_WATER,
         maxSlope: () => CesiumMath.toRadians(this.maxSlope_),
         rate: () => this.rate_,
-        time: () => (performance.now() / 1000) % TIME_PERIOD,
+        time: () => this.clock_() % TIME_PERIOD,
         color: () => Cartesian4.fromColor(this.color_, this.colorScratch_),
       },
     });
@@ -91,7 +78,7 @@ export default class RainRings extends Effect {
    * @param {import('@cesium/engine').Scene} scene
    */
   activated_(scene) {
-    this.frameAt_(scene);
+    this.frame_.anchor(scene);
     acquireTerrainDepth(scene);
     if (this.intensity_ > 0) {
       acquireFrames(scene, FRAME_RATE);
@@ -204,12 +191,11 @@ export default class RainRings extends Effect {
    * the effect is activated if none is given. Keep it within a few kilometers of what is looked at.
    */
   get origin() {
-    return this.origin_;
+    return this.frame_.origin;
   }
 
   set origin(value) {
-    this.origin_ = value && Cartesian3.clone(value);
-    this.localFrame_ = undefined;
+    this.frame_.origin = value;
     this.viewer.scene.requestRender();
   }
 }

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);
+}