@geoblocks/cesium-post-process 0.3.0 → 0.5.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);
+}

package/src/shaders/CloudsResolve.glsl

@@ -0,0 +1,46 @@
+// The clouds accumulated over the frames, at the march's resolution: each frame's march, jittered
+// anew, blended into the clouds of the previous frames, reprojected to where they are seen now, as
+// Frostbite's, whose 14 samples a frame "look converged" (Hillaire 2016, sec. 5.5.3). The previous
+// frames' clouds are reprojected through where the ray enters the slab, near what is seen of them
+// from outside, rather than through their transmittance-weighted distance (Sakmary 2022), which the
+// march has no channel left for, and clamped to the current frame's 3 x 3 neighborhood so that they
+// do not trail behind what moved. Needs EyeFromDepth, Height and CloudsSlab.
+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;
+// this frame's march, and the accumulation of the previous frames, from clouds.js
+uniform sampler2D cloudTexture;
+uniform sampler2D historyTexture;
+// from the eye coordinates of this frame to the clip coordinates of the previous one
+uniform mat4 reprojection;
+// the share of the previous frames in the blend, 0 when there are none
+uniform float historyWeight;
+in vec2 v_textureCoordinates;
+
+// inside the slab, the clouds are reprojected through a point this far along the ray, in meters
+const float INSIDE_DISTANCE = 2000.0;
+
+void main() {
+  vec4 current = texture(cloudTexture, v_textureCoordinates);
+  // czm_viewport is this pass's texture, the march's size
+  vec2 texel = 1.0 / czm_viewport.zw;
+  vec4 low = current;
+  vec4 high = current;
+  for (int y = -1; y <= 1; y++) {
+    for (int x = -1; x <= 1; x++) {
+      vec4 neighbor = texture(cloudTexture, v_textureCoordinates + vec2(float(x), float(y)) * texel);
+      low = min(low, neighbor);
+      high = max(high, neighbor);
+    }
+  }
+  vec3 direction = normalize(eyeAt(depthTexture, v_textureCoordinates).xyz);
+  vec2 segment = slab(dot(direction, up), texture(cloudDepth, v_textureCoordinates).r, slabTop);
+  // where the ray misses the slab, nothing is there to move: only the view turns
+  vec4 point = segment.y > segment.x ? vec4(direction * max(segment.x, min(segment.y, INSIDE_DISTANCE)), 1.0) : vec4(direction, 0.0);
+  vec4 clip = reprojection * point;
+  vec2 previous = clip.xy / clip.w * 0.5 + 0.5;
+  bool seen = clip.w > 0.0 && all(greaterThanEqual(previous, vec2(0.0))) && all(lessThanEqual(previous, vec2(1.0)));
+  vec4 history = clamp(texture(historyTexture, previous), low, high);
+  out_FragColor = mix(current, history, seen ? historyWeight : 0.0);
+}

package/src/shaders/CloudsShadow.glsl

@@ -0,0 +1,50 @@
+// The clouds' shadow map, a Beer shadow map: across an area around the camera, seen from the sun,
+// the optical depth of the clouds along the sun's rays, from the top of the slab down to each
+// quarter of its height, so that a point finds how much cloud lies between it and the sun. One
+// read rather than a march toward the sun, as Unreal's (it loses only the "volumetric self shadow
+// color") and three-clouds' in WebGL2.
+precision highp sampler2D;
+uniform sampler2D shadowMap;
+// the ground point the map is centered on, in world coordinates, and the base and the top of the
+// slab it covers, in meters above the ellipsoid, from clouds.js
+uniform vec3 shadowCenter;
+// the map's side, in meters, wider as the camera is higher, from clouds.js
+uniform float shadowExtent;
+uniform float shadowBase;
+uniform float shadowTop;
+
+// the shadow fades out over the outer share of the map's half side, so that its edge does not show
+const float SHADOW_FADE = 0.2;
+
+// the axes of the map, across the sun's rays: the sun's direction in world coordinates crossed
+// with the up at its center, and the third direction
+void shadowAxes(out vec3 across, out vec3 along) {
+  vec3 up = normalize(shadowCenter);
+  across = cross(czm_lightDirectionWC, up);
+  across = dot(across, across) > 1e-6 ? normalize(across) : normalize(cross(czm_lightDirectionWC, vec3(1.0, 0.0, 0.0)));
+  along = cross(czm_lightDirectionWC, across);
+}
+
+// a point's height above the sphere through the map's center: over the map, it differs from the
+// height above the ellipsoid by meters
+float shadowHeight(vec3 positionWC) {
+  return length(positionWC) - length(shadowCenter);
+}
+
+// the optical depth of the clouds between a point in world coordinates and the sun, 0 off the map
+float shadowDepth(vec3 positionWC) {
+  vec3 across;
+  vec3 along;
+  shadowAxes(across, along);
+  vec3 offset = positionWC - shadowCenter;
+  vec2 uv = vec2(dot(offset, across), dot(offset, along)) / shadowExtent + 0.5;
+  float edge = 2.0 * max(abs(uv.x - 0.5), abs(uv.y - 0.5));
+  if (edge >= 1.0) {
+    return 0.0;
+  }
+  float fade = 1.0 - smoothstep(1.0 - SHADOW_FADE, 1.0, edge);
+  vec4 depths = texture(shadowMap, uv);
+  // the share of the slab above the point, in quarters, through the depths at each
+  float f = 4.0 * clamp((shadowTop - shadowHeight(positionWC)) / max(shadowTop - shadowBase, 1.0), 0.0, 1.0);
+  return fade * (f < 1.0 ? f * depths.x : f < 2.0 ? mix(depths.x, depths.y, f - 1.0) : f < 3.0 ? mix(depths.y, depths.z, f - 2.0) : mix(depths.z, depths.w, f - 3.0));
+}

package/src/shaders/CloudsShadowMap.glsl

@@ -0,0 +1,68 @@
+// The clouds' shadow map, drawn by clouds.js into its own texture: for each texel, the sun's ray
+// through it marched from the top of the slab down to its base, the optical depth of the clouds
+// kept at each quarter of the slab's height, unless the ray crosses no clouds. Needs CloudsSlab,
+// WeatherMap, Noise, CloudsDensity and CloudsShadow.
+// the highest coverage around each block of the clouds' map, from weather-map.js
+precision highp sampler2D;
+uniform sampler2D maxMap;
+in vec2 v_textureCoordinates;
+
+// the steps along each ray, 4 for each quarter, and the texels across, clouds.js's SHADOW_SIZE, for
+// a texel's footprint, for the noise's mipmap
+const int SHADOW_STEPS = 16;
+const float SHADOW_SIZE = 512.0;
+// the ray is probed at this many points of the max map before its march, as the clouds' march, and
+// skipped where they find no clouds: the max map's 12 km windows overlap between probes as long as
+// the ray crosses the slab over less than about 100 km, the sun above about 4 degrees; lower, a
+// small cell between two probes casts no shadow
+const int SHADOW_PROBES = 8;
+// the sun is taken this high at least, the sine of its height: lower, its rays cross the slab over
+// more than 100 km
+const float LOW_SUN = 0.05;
+
+void main() {
+  vec3 across;
+  vec3 along;
+  shadowAxes(across, along);
+  vec2 xy = (v_textureCoordinates - 0.5) * shadowExtent;
+  vec3 start = shadowCenter + across * xy.x + along * xy.y;
+  float sine = dot(czm_lightDirectionWC, normalize(start));
+  if (sine <= 0.0) {
+    // the sun is down: no shadows to speak of
+    out_FragColor = vec4(0.0);
+    return;
+  }
+  sine = max(sine, LOW_SUN);
+  float h0 = shadowHeight(start);
+  // from the top of the slab down to its base, along the ray
+  float top = (slabTop - h0) / sine;
+  float base = (cloudBase - h0) / sine;
+  float covered = 0.0;
+  for (int k = 0; k < SHADOW_PROBES; k++) {
+    vec2 uv = mapUv(start + czm_lightDirectionWC * mix(top, base, (float(k) + 0.5) / float(SHADOW_PROBES)));
+    if (all(greaterThanEqual(uv, vec2(0.0))) && all(lessThanEqual(uv, vec2(1.0)))) {
+      covered = max(covered, texture(maxMap, uv).g);
+    }
+  }
+  if (covered <= 0.0) {
+    out_FragColor = vec4(0.0);
+    return;
+  }
+  float ds = (top - base) / float(SHADOW_STEPS);
+  float depth = 0.0;
+  vec4 depths = vec4(0.0);
+  float unused;
+  for (int i = 0; i < SHADOW_STEPS; i++) {
+    vec3 point = start + czm_lightDirectionWC * mix(top, base, (float(i) + 0.5) / float(SHADOW_STEPS));
+    depth += EXTINCTION * cloudDensity(point, shadowHeight(point), shadowExtent / SHADOW_SIZE, unused, unused, unused) * ds;
+    if (i == SHADOW_STEPS / 4 - 1) {
+      depths.x = depth;
+    } else if (i == SHADOW_STEPS / 2 - 1) {
+      depths.y = depth;
+    } else if (i == 3 * SHADOW_STEPS / 4 - 1) {
+      depths.z = depth;
+    }
+  }
+  depths.w = depth;
+  out_FragColor = depths;
+}

package/src/shaders/CloudsSlab.glsl

@@ -0,0 +1,58 @@
+// The slab of the clouds along a view ray, which the march and the resolve share: where the ray's
+// height reaches a height, and the part of the ray in the slab. Needs Height.
+// meters above the ellipsoid
+uniform float cloudBase;
+// the top of the tallest cloud the map makes, where the march starts from above, from clouds.js
+uniform float slabTop;
+
+// the ray is marched as far as this from where it enters the slab, in meters, not from the camera:
+// from far above, the slab itself is farther than that. A grazing ray marched farther would take
+// steps longer than the billows and turn the far clouds into streaks; deeper than this into the
+// slab, it is nearly always behind a cloud
+const float MAX_DISTANCE = 40000.0;
+
+// where the height along the view ray, at a distance t in direction k = dot(direction, up), reaches
+// c: the height is cameraHeight + k t + (1 - k k) t t / (2 radius), as heightAt's. False if it never
+// does. Without the cancellation of the textbook formula, also for a vertical ray, where the
+// quadratic term is 0
+bool crossings(float c, float k, out float near, out float far) {
+  float a = (1.0 - k * k) / (2.0 * radius);
+  float d = cameraHeight - c;
+  float discriminant = k * k - 4.0 * a * d;
+  if (discriminant < 0.0) {
+    return false;
+  }
+  float q = -0.5 * (k + (k < 0.0 ? -1.0 : 1.0) * sqrt(discriminant));
+  q = q == 0.0 ? 1e-9 : q;
+  float r0 = a > 1e-12 ? q / a : (q > 0.0 ? 1e20 : -1e20);
+  float r1 = d / q;
+  near = min(r0, r1);
+  far = max(r0, r1);
+  return true;
+}
+
+// the part of the ray in the slab up to a top, from where it enters it to where it leaves it, meets
+// the ground or is MAX_DISTANCE long; empty when it misses the slab
+vec2 slab(float k, float sceneDistance, float top) {
+  float near;
+  float far;
+  // always above the tops
+  if (!crossings(top, k, near, far)) {
+    return vec2(0.0);
+  }
+  float start = max(near, 0.0);
+  float end = far;
+  if (crossings(cloudBase, k, near, far)) {
+    if (cameraHeight >= cloudBase) {
+      // going down below the base
+      if (near > 0.0) {
+        end = min(end, near);
+      }
+    } else {
+      // coming up through the base
+      start = max(start, far);
+    }
+  }
+  end = min(end, min(sceneDistance, start + MAX_DISTANCE));
+  return vec2(start, max(end, start));
+}

package/src/shaders/ColorIsolation.glsl

@@ -0,0 +1,26 @@
+// Color isolation: one hue keeps its color, the rest of the scene turns gray. After prod80's
+// ReShade Color Isolation (MIT), https://github.com/prod80/prod80-ReShade-Repository
+precision highp sampler2D;
+uniform sampler2D colorTexture;
+// the hue kept and the half width of the selection, 0 to 1 for the whole circle
+uniform float hue;
+uniform float range;
+// 0 to 1
+uniform float strength;
+in vec2 v_textureCoordinates;
+
+void main() {
+  vec4 sceneColor = texture(colorTexture, v_textureCoordinates);
+  vec3 color = clamp(sceneColor.rgb, 0.0, 1.0);
+  float gray = czm_luminance(color);
+  float h = czm_RGBToHSL(color).x;
+  // a triangle around the hue, on the circle
+  float r = 1.0 / max(range, 1e-3);
+  float weight = max(1.0 - abs((h - hue) * r), 0.0)
+    + max(1.0 - abs((h + 1.0 - hue) * r), 0.0)
+    + max(1.0 - abs((h - 1.0 - hue) * r), 0.0);
+  float w = clamp(weight, 0.0, 1.0);
+  float keep = w * w * w * (w * (w * 6.0 - 15.0) + 10.0);
+  vec3 isolated = mix(vec3(gray), color, keep);
+  out_FragColor = vec4(mix(color, isolated, strength), sceneColor.a);
+}

package/src/shaders/DepthEdges.glsl

@@ -0,0 +1,81 @@
+// The edges found in the depth, shared by Toy and WhiteModel, after EyeFromDepth: how far a pixel
+// lies, how large a pixel is there, the depth's neighbors around it, how sharply it bends between
+// them (a crease, not across a jump: an edge in front of something farther, nor the gentle bends
+// between the terrain's triangles), the outline on the near side of a jump; the sky's gradient.
+// its samplers read in high precision, whatever comes before (a phone's GPU's default is low)
+precision highp sampler2D;
+uniform sampler2D depthTexture;
+
+// how much the depth bends, in pixels' sizes, to start and to end lighting an edge
+const vec2 CREASE = vec2(0.6, 1.6);
+// how far the depth jumps, in pixels' sizes, to be an edge in front of something farther, not a crease
+uniform float jump;
+// the bevel's widest, in pixels: its neighbors read that far at the most
+const float BEVEL = 8.0;
+// the sky's depth, far off
+const float SKY = 1e9;
+
+// how far the pixel at uv lies, in meters: in an orthographic view past its near plane, small
+// numbers whose differences keep their precision (its camera thousands of meters back: some
+// phones' GPUs, Mali, lose it subtracting depths that large), in a perspective one from the camera
+float depthAt(vec2 uv) {
+  if (czm_orthographicIn3D == 1.0) {
+    float raw = texture(depthTexture, uv).r;
+    return raw >= 1.0 ? SKY : raw * (czm_currentFrustum.y - czm_currentFrustum.x);
+  }
+  vec4 eye = eyeAt(depthTexture, uv);
+  return eye.w == 0.0 ? SKY : -eye.z;
+}
+
+// a pixel's size in meters at a depth: an orthographic view's the same everywhere, a perspective's
+// growing with the depth
+float pixelAt(float depth) {
+  return 2.0 / (czm_projection[0][0] * czm_viewport.z) * (czm_orthographicIn3D == 1.0 ? 1.0 : depth);
+}
+
+// the depths of the neighbors steps pixels away from uv, less its own c: right, left, up, down
+vec4 neighborsAt(vec2 uv, float c, float steps) {
+  vec2 o = steps / czm_viewport.zw;
+  return vec4(depthAt(uv + vec2(o.x, 0.0)), depthAt(uv - vec2(o.x, 0.0)), depthAt(uv + vec2(0.0, o.y)), depthAt(uv - vec2(0.0, o.y))) - c;
+}
+
+// how sharply the depth bends between neighbors n a span of meters apart, from 0 to 1, none across
+// a jump; convex where they lie farther than the middle, their sum positive
+float creaseOf(vec4 n, float span, float pixel) {
+  float far = max(max(abs(n.x), abs(n.y)), max(abs(n.z), abs(n.w)));
+  return smoothstep(CREASE.x, CREASE.y, (abs(n.x + n.y) + abs(n.z + n.w)) / span) * (1.0 - step(jump * pixel, far));
+}
+
+// how far the surface beyond the pixel at uv lies behind it, in one direction o (a pixel's step): the two neighbours
+// that way extrapolated back to the pixel, linearly in an orthographic view, where the depth is affine on the screen,
+// in its reciprocal in a perspective one. A plane at any slope extrapolates exactly to the pixel, so a face seen at a
+// grazing angle is never a jump, only a nearer thing standing in front of a farther one. The nearer of the extrapolation
+// and the neighbour itself: beside a thin thing two pixels away, the extrapolation through it runs far behind the pixel
+float farSide(vec2 uv, vec2 o, float c) {
+  float d1 = depthAt(uv + o);
+  float d2 = depthAt(uv + 2.0 * o);
+  if (d1 == SKY) {
+    return SKY;
+  }
+  if (czm_orthographicIn3D == 1.0) {
+    return min(d1, d2 == SKY ? d1 : 2.0 * d1 - d2) - c;
+  }
+  float r = d2 == SKY ? 1.0 / d1 : 2.0 / d1 - 1.0 / d2;
+  return (r <= 0.0 ? d1 : min(d1, 1.0 / r)) - c;
+}
+
+// the outline, a pixel wide, on the near side of a jump: the farthest of the four directions' surfaces behind the pixel,
+// against the jump, anti-aliased over a quarter of it each way (n and steps, the creases' neighbours, unused here: the
+// outline reads its own)
+float outlineAt(vec2 uv, float c, vec4 n, float steps, float pixel) {
+  vec2 texel = 1.0 / czm_viewport.zw;
+  float farther = max(max(farSide(uv, vec2(texel.x, 0.0), c), farSide(uv, vec2(-texel.x, 0.0), c)),
+    max(farSide(uv, vec2(0.0, texel.y), c), farSide(uv, vec2(0.0, -texel.y), c)));
+  float limit = jump * pixel;
+  return smoothstep(0.75 * limit, 1.25 * limit, farther);
+}
+
+// the sky's gradient at uv, from the top of the screen to its bottom
+vec3 skyAt(vec2 uv, vec4 top, vec4 bottom) {
+  return mix(bottom.rgb, top.rgb, smoothstep(0.0, 1.0, uv.y));
+}

package/src/shaders/DigitalVideo.glsl

@@ -0,0 +1,65 @@
+// A digital FPV video feed and its breakups: clean, slightly punchy colors, until a weak signal
+// breaks the picture into macroblocks, some displaced, strips shifted sideways and the color
+// channels split, and at worst a short black screen. A block keeps only its lowest frequencies,
+// as a codec that has thrown its detail away: a gradient between its corners, with fewer colors.
+// The displaced blocks and strips follow three.js's DigitalGlitch. Without the previous frames,
+// there are no freezes.
+precision highp sampler2D;
+uniform sampler2D colorTexture;
+// how broken the picture is, 0 to 1, and 1 during a black screen
+uniform float severity;
+uniform float blackout;
+// the video frame number, for the random patterns
+uniform float frame;
+in vec2 v_textureCoordinates;
+
+// a macroblock, in CSS pixels
+const float BLOCK = 16.0;
+
+void main() {
+  vec2 size = czm_viewport.zw;
+  vec2 pixel = gl_FragCoord.xy / czm_pixelRatio;
+  vec2 uv = v_textureCoordinates;
+  vec4 sceneColor = texture(colorTexture, uv);
+  // clean: slightly crushed blacks, a little more color
+  vec3 rgb = sceneColor.rgb;
+  rgb = czm_saturation(rgb, 1.1);
+  rgb = max(rgb - 0.02, 0.0) / 0.98;
+
+  if (severity > 0.0) {
+    // the pattern changes every few frames, as the decoder stutters
+    float pattern = floor(frame / 3.0);
+    // strips shifted sideways
+    float strip = floor(pixel.y / (BLOCK * 2.0));
+    if (hash(vec2(strip, pattern + 7.0)) < 0.25 * severity) {
+      uv.x += (hash(vec2(strip, pattern + 11.0)) - 0.5) * 0.2 * severity;
+    }
+    // macroblocks: more of them as the signal gets worse; some show the picture displaced
+    vec2 block = floor(uv * size / czm_pixelRatio / BLOCK);
+    if (hash(block + pattern * 0.37) < 1.2 * severity) {
+      vec2 displaced = hash(block + pattern + 3.0) < 0.3
+        ? floor((vec2(hash(block + 5.0), hash(block + 9.0)) - 0.5) * 4.0)
+        : vec2(0.0);
+      vec2 cell = BLOCK * czm_pixelRatio / size;
+      vec2 origin = (block + displaced) * cell;
+      // the block's corners, and a gradient between them
+      vec2 inset = 0.5 / size;
+      vec3 c00 = texture(colorTexture, origin + inset).rgb;
+      vec3 c10 = texture(colorTexture, origin + vec2(cell.x - inset.x, inset.y)).rgb;
+      vec3 c01 = texture(colorTexture, origin + vec2(inset.x, cell.y - inset.y)).rgb;
+      vec3 c11 = texture(colorTexture, origin + cell - inset).rgb;
+      vec2 f = fract(uv * size / czm_pixelRatio / BLOCK);
+      rgb = mix(mix(c00, c10, f.x), mix(c01, c11, f.x), f.y);
+      // fewer colors
+      float levels = mix(24.0, 6.0, severity);
+      rgb = floor(rgb * levels + 0.5) / levels;
+    } else if (uv != v_textureCoordinates) {
+      rgb = texture(colorTexture, uv).rgb;
+    }
+    // the color channels split sideways
+    vec2 split = vec2(3.0 * severity * czm_pixelRatio / size.x, 0.0);
+    rgb.r = mix(rgb.r, texture(colorTexture, uv + split).r, severity);
+    rgb.b = mix(rgb.b, texture(colorTexture, uv - split).b, severity);
+  }
+  out_FragColor = vec4(rgb * (1.0 - blackout), sceneColor.a);
+}