@geoblocks/cesium-post-process 0.4.0 → 0.5.0

package/src/shaders/PrecipitationShaftBlur.glsl

@@ -0,0 +1,21 @@
+// The shafts' opacity, the ray's extinction, the share of it in the rain and the share of the rain
+// in the sun, blurred over the neighboring texels at
+// their own resolution: they fade out around the ridges in front of them rather than stopping at
+// their outline. A 3 x 3 binomial kernel here costs a 64th of the reads the same blur would take
+// at the full resolution.
+precision highp sampler2D;
+uniform sampler2D shaftTexture;
+in vec2 v_textureCoordinates;
+
+void main() {
+  // czm_viewport is this pass's texture, the size of the shafts'
+  vec2 texel = 1.0 / czm_viewport.zw;
+  vec4 sum = vec4(0.0);
+  for (int y = -1; y <= 1; y++) {
+    for (int x = -1; x <= 1; x++) {
+      float weight = (x == 0 ? 2.0 : 1.0) * (y == 0 ? 2.0 : 1.0);
+      sum += weight * texture(shaftTexture, v_textureCoordinates + vec2(float(x), float(y)) * texel);
+    }
+  }
+  out_FragColor = sum / 16.0;
+}

package/src/shaders/PrecipitationShafts.glsl

@@ -0,0 +1,84 @@
+// The shafts of the rain or the snow, at a fraction of the resolution: their opacity along each
+// view ray, for Precipitation.glsl to shade, and the ray's mean extinction, as a share of the
+// extinction where the map is full, for its haze, which it computes at its own resolution, sharp at
+// the ridges. Both are over the part of the ray below the cloud base, where it rains, found from the
+// scene's depth before it is sampled:
+// from far above, a pixel shows the rain in the column under it. Along that part, patches of noise
+// on the ground under each sample, more of them as it rains harder, slanting with the wind from the
+// cloud base and drifting with it, where the map has rain. Not dithered: at this resolution the
+// dither shows as dots, where the patches are too soft to band. Needs EyeFromDepth, Noise, Height,
+// PrecipitationWind, WeatherMap, Fog, Phase, RainHaze and CloudsShadow. With clouds in the scene, it also finds
+// the share of the rain along the ray that the sun lights through their gaps, from their shadow map:
+// the haze's light shafts (Wronski 2014's front-to-back march, on the clouds' shadow map as
+// Hillaire 2016, sec. 5.9).
+precision highp sampler2D;
+uniform sampler2D depthTexture;
+// 1 when the clouds' shadow map is there to read, 0 otherwise
+uniform float shadowed;
+in vec2 v_textureCoordinates;
+
+// samples along the part of each ray below the cloud base, as far as SHAFT_DISTANCE from its
+// start, size of the patches in meters, extinction inside them per meter, about 6 km of visibility
+const int SHAFT_STEPS = 12;
+const float SHAFT_DISTANCE = 20000.0;
+const float SHAFT_SIZE = 2500.0;
+// snow hides more, about 2.5 km
+const vec2 SHAFT_EXTINCTION = vec2(0.0006, 0.0015);
+// the wind's speed, from its tilt of the drops' fall at 9 m/s, also in the snow: a drift changing
+// with the snow would move the shafts
+const float DRIFT_VELOCITY = 9.0;
+// the shafts thin out over this height below the cloud base, into the clouds
+const float SHAFT_TOP = 1000.0;
+
+void main() {
+  vec4 eye = eyeAt(depthTexture, v_textureCoordinates);
+  vec3 rayEnd = eye.w == 0.0 ? eye.xyz * SKY_DISTANCE : eye.xyz;
+  // the part of the ray below the cloud base, and the part of it that is sampled
+  vec2 below = belowHeight(rayEnd, cloudBase);
+  float t0 = below.x;
+  float t1 = below.y;
+  float opacity = 0.0;
+  float share = 0.0;
+  float wet = 0.0;
+  float lit = 1.0;
+  if (t1 > t0) {
+    float rayLength = length(rayEnd);
+    float sampled = min(t1, t0 + SHAFT_DISTANCE / rayLength);
+    // the ray in world coordinates, once rather than for each sample
+    vec3 rayWC = czm_inverseViewRotation * rayEnd;
+    vec3 upWorld = upWC();
+    vec3 eastWorld = eastWC();
+    float threshold = mix(0.4, 0.0, intensity);
+    // the gusts sway the shafts, but they drift with the steady wind
+    float slant = tan(gustingTilt());
+    float drift = DRIFT_VELOCITY * speed * tan(radians(wind)) * time;
+    float raining = 0.0;
+    float sunlit = 0.0;
+    float density = 0.0;
+    for (int i = 0; i < SHAFT_STEPS; i++) {
+      float t = mix(t0, sampled, (float(i) + 0.5) / float(SHAFT_STEPS));
+      float h = heightAt(rayEnd * t);
+      vec3 ground = czm_viewerPositionWC + rayWC * t - upWorld * h;
+      float local = mapAt(ground);
+      ground -= eastWorld * ((cloudBase - h) * slant + drift);
+      float patches = gradientNoise(ground / SHAFT_SIZE);
+      // in bands drifting with the shafts, the noise being about -0.7 to 0.7
+      float extinction = rainExtinction(intensity * local, snow) * (1.0 + RAIN_BANDS * patches / 0.7);
+      raining += extinction;
+      // the sun through the clouds above the sample, weighted by how much it scatters there
+      vec3 sampleWC = czm_viewerPositionWC + rayWC * t;
+      sunlit += extinction * (shadowed > 0.0 ? exp(-shadowDepth(sampleWC)) : 1.0);
+      wet += smoothstep(0.0, 0.15, local);
+      float top = clamp((cloudBase - h) / SHAFT_TOP, 0.0, 1.0);
+      density += local * top * smoothstep(threshold - 0.3, threshold + 0.3, patches);
+    }
+    // the whole part below the cloud base is as rainy as its sampled part, its extinction as a
+    // share of the heaviest bands', and the share of it in the rain
+    share = raining / (float(SHAFT_STEPS) * (1.0 + RAIN_BANDS) * rainExtinction(intensity, snow));
+    wet /= float(SHAFT_STEPS);
+    lit = raining > 0.0 ? sunlit / raining : 1.0;
+    float depth = mix(SHAFT_EXTINCTION.x, SHAFT_EXTINCTION.y, snow) * (0.5 + 0.5 * intensity) * density * (sampled - t0) * rayLength / float(SHAFT_STEPS);
+    opacity = 1.0 - exp(-depth);
+  }
+  out_FragColor = vec4(opacity, share, wet, lit);
+}

package/src/shaders/PrecipitationWind.glsl

@@ -0,0 +1,33 @@
+// What the passes of the precipitation share: the local frame at the camera and the wind, in gusts.
+// Needs Height.
+// seconds, wrapped at an hour
+uniform float time;
+// tilt of the fall toward the east, in degrees
+uniform float wind;
+// speed of the drops, 1 at their terminal velocity
+uniform float speed;
+// meters above the ellipsoid
+uniform float cloudBase;
+// 0 to 1
+uniform float intensity;
+// share of the precipitation that is snow, 0 to 1
+uniform float snow;
+
+// the gusts: the wind's tilt varies by this share, over periods of 18 and 7.2 s that divide the
+// hour the time wraps at
+const float GUSTS = 0.35;
+
+// up and east at the camera, in world coordinates
+vec3 upWC() {
+  return czm_inverseViewRotation * up;
+}
+
+vec3 eastWC() {
+  return normalize(cross(vec3(0.0, 0.0, 1.0), upWC()));
+}
+
+// the wind's tilt, in radians, in gusts
+float gustingTilt() {
+  float gust = 1.0 + GUSTS * (0.6 * sin(czm_twoPi * time / 18.0) + 0.4 * sin(czm_twoPi * time / 7.2 + 1.3));
+  return radians(wind) * gust;
+}

package/src/shaders/RainHaze.glsl

@@ -0,0 +1,145 @@
+// The haze of the rain or the snow, which Precipitation and Clouds share: its extinction, its
+// opacity over an optical depth, and its color. The rain has no color of its own: its extinction
+// is the same at all wavelengths for drops above 0.2 mm (Montero-Martinez et al. 2025), so the
+// haze is the light of the sky and the sun it scatters toward the eye, L_in = (1 - T) * (the light
+// scattered toward the eye) (Hillaire 2020): the clear sky of Cesium's atmosphere at the horizon,
+// warm toward the sun and blue away from it, turning under thick clouds to the gray of an
+// overcast sky, brighter overhead, and the sun's forward glow through thin clouds. A moonlit blue
+// at night, as ValleyFog's. Needs Height, Fog and Phase.
+precision highp sampler2D;
+
+// the light intensity of the sky's atmosphere, which is not the scene's atmosphere's: 50 rather than
+// 10 by default
+uniform float skyLightIntensity;
+// the clear sky toward the horizon and overhead, from SkyTable.glsl
+uniform sampler2D skyTable;
+
+// the rain rate, in mm/h, at intensity 1, the map's intensity being sqrt(R / RAIN_RATE), as the
+// weather demo draws it from MeteoSwiss' radar
+const float RAIN_RATE = 10.0;
+// the extinction per meter of the rain, 0.11 R^0.85 per km at R mm/h, added to the clear air's, 0.1
+// per km (Montero-Martinez et al. 2025): 39 km of visibility in dry air, 11.5 km at 2.5 mm/h, 4.4 km
+// at 10 mm/h
+const vec2 RAIN_LAW = vec2(0.00011, 0.85);
+// layers of haze thinning out with the height, their extinction per meter at sea level and their
+// scale height in meters, summed in optical depth with the rain's: the clear air's, 0.1 per km at
+// the ground, over an aerosol's scale height of 1 to 2 km; and a mist lying low, 1 per km at the
+// Swiss plateau's 500 m, that fills the valleys and leaves the ridges above it. Both scale heights
+// and the mist's extinction are not from a source
+const vec2 CLEAR_AIR = vec2(0.0001, 1200.0);
+const vec2 MIST = vec2(0.0035, 400.0);
+// the rain's extinction drifts in bands, by this share around its mean: sigma_rain *=
+// mix(0.6, 1.4, noise) (Wronski 2014, "procedural Perlin noise animated by wind")
+const float RAIN_BANDS = 0.4;
+// visibility in meters at intensity 0 and 1 in the snow
+const vec2 SNOW_VISIBILITY = vec2(20000.0, 500.0);
+// the haze never quite hides the sky and the far terrain
+const float MAX_HAZE = 0.9;
+// the overcast sky at the horizon by day, a brighter gray under snow clouds; overhead, it is three
+// times as bright, the CIE's overcast sky, L / L_zenith = (1 + 2 sin(elevation)) / 3 (CIE 2003),
+// and darker under thick clouds, by up to this share: the report's 0.6 left the haze under the
+// heaviest rain at a quarter of the brightness, darker than the scene it veils, which the overcast
+// only dims by half
+const vec3 RAIN_HAZE = vec3(0.6, 0.64, 0.68);
+const vec3 SNOW_HAZE = vec3(0.7, 0.72, 0.76);
+const float THICK_CLOUDS = 0.3;
+// the asymmetry of the light scattered by the rain and by the snow, from the haze's 0.7 to the
+// rain's 0.9 to 1 (arXiv 1403.2977)
+const vec2 HAZE_ASYMMETRY = vec2(0.9, 0.75);
+// the sky toward the horizon is a ray this long, out of the atmosphere
+const float SKY_RAY = 1e7;
+// the clear sky at the horizon is read this far above it, in radians, 5 degrees: right at it,
+// Cesium's atmosphere turns a pale cyan that its sky, interpolated from the vertices of its dome,
+// never shows
+const float SKY_ELEVATION = 0.087;
+// the sky table's texels toward the horizon, besides the one overhead, SkyTable.glsl's
+const float SKY_TABLE = 64.0;
+
+// the extinction per meter, from the rain's to the snow's, as hard as it rains: 3.912 / visibility
+// is the extinction that leaves 2 % of the light. None where it does not rain, rising from 0 at the
+// edge of the rain: the dry air is Cesium's fog's
+float rainExtinction(float intensity, float snow) {
+  float rain = max(RAIN_LAW.x * pow(RAIN_RATE * intensity * intensity, RAIN_LAW.y), 1e-9);
+  float snowfall = 3.912 / (SNOW_VISIBILITY.x * pow(SNOW_VISIBILITY.y / SNOW_VISIBILITY.x, intensity));
+  return smoothstep(0.0, 0.15, intensity) * rain * pow(snowfall / rain, snow);
+}
+
+// the optical depth of a layer of haze along a straight ray this long from height h0 to h1, its
+// height linear along it: the line integral of exponential height fog,
+// (a / b) exp(-b h0) (1 - exp(-b dh)) / dh per unit of length (Quilez), with the first terms of its
+// Taylor series where the ray is level, as Flax's ExponentialHeightFog.hlsl
+float layerDepth(vec2 layer, float h0, float h1, float rayLength) {
+  float x = (h1 - h0) / layer.y;
+  float level = abs(x) < 1e-3 ? 1.0 - 0.5 * x : (1.0 - exp(-x)) / x;
+  return layer.x * rayLength * exp(-h0 / layer.y) * level;
+}
+
+// the haze's opacity over an optical depth in the rain
+float rainHaze(float opticalDepth) {
+  return MAX_HAZE * (1.0 - exp(-opticalDepth));
+}
+
+// the clear sky in a direction in world coordinates from a point at a height, as the sky shader of Cesium's atmosphere
+// renders it without high dynamic range, its inner radius lowered as SkyAtmosphereCommon.glsl
+// lowers it: from the ellipsoid's surface, a ray toward the horizon would cross the densest air
+// for hundreds of kilometers and turn a dim yellow
+vec3 clearSkyFrom(vec3 originWC, float height, vec3 directionWC, vec3 lightWC) {
+  czm_ray ray = czm_ray(originWC, directionWC);
+  float radiiDifference = czm_ellipsoidRadii.x - czm_ellipsoidRadii.z;
+  float adjust = 0.5 * radiiDifference * clamp((height - 0.25 * czm_ellipsoidRadii.x) / (0.75 * czm_ellipsoidRadii.x), 0.0, 1.0);
+  float innerRadius = length(originWC) - height - 0.25 * radiiDifference - adjust;
+  vec3 rayleigh;
+  vec3 mie;
+  float opacity;
+  czm_computeScattering(ray, SKY_RAY, lightWC, innerRadius, rayleigh, mie, opacity);
+  vec3 color = czm_computeAtmosphereColor(ray, lightWC, rayleigh, mie, opacity).rgb * skyLightIntensity / czm_atmosphereLightIntensity;
+  return czm_inverseGamma(czm_pbrNeutralTonemapping(color));
+}
+
+// the clear sky seen from the camera
+vec3 clearSky(vec3 directionWC, vec3 lightWC) {
+  return clearSkyFrom(czm_viewerPositionWC, czm_eyeHeight, directionWC, lightWC);
+}
+
+// the clear sky seen from under the camera at a height, or from the camera if it is lower: from
+// far above, the camera sees the black of space overhead, not the sky the clouds and the haze see,
+// whose color divided by its luminance would turn to any hue
+vec3 clearSkyBelow(float height, vec3 directionWC, vec3 lightWC) {
+  float h = min(czm_eyeHeight, height);
+  return clearSkyFrom(czm_viewerPositionWC - normalize(czm_viewerPositionWC) * (czm_eyeHeight - h), h, directionWC, lightWC);
+}
+
+// the clear sky toward a view direction in eye coordinates, at its azimuth and at an elevation
+// above the horizon, in radians, lit by the scene's light, as the sky's atmosphere is lit by
+// default: the scene's atmosphere is lit from overhead by default, and would turn the horizon cyan
+// at any time of day
+vec3 skyToward(vec3 view, float elevation) {
+  vec3 level = view - dot(view, up) * up;
+  level = dot(level, level) > 1e-6 ? normalize(level) : normalize(cross(up, vec3(1.0, 0.0, 0.0)));
+  return clearSky(czm_inverseViewRotation * (cos(elevation) * level + sin(elevation) * up), czm_lightDirectionWC);
+}
+
+// the clear sky toward a view direction in eye coordinates, from the sky table: at its azimuth from
+// the sun's, SKY_ELEVATION above the horizon, toward overhead as it looks up
+vec3 skyFromTable(vec3 view) {
+  vec3 level = view - dot(view, up) * up;
+  vec3 sun = czm_lightDirectionEC - dot(czm_lightDirectionEC, up) * up;
+  float cosAzimuth = dot(level, level) > 1e-6 && dot(sun, sun) > 1e-6 ? dot(normalize(level), normalize(sun)) : 1.0;
+  float u = (acos(clamp(cosAzimuth, -1.0, 1.0)) / czm_pi * (SKY_TABLE - 1.0) + 0.5) / (SKY_TABLE + 1.0);
+  vec3 horizon = texture(skyTable, vec2(u, 0.5)).rgb;
+  vec3 zenith = texture(skyTable, vec2((SKY_TABLE + 0.5) / (SKY_TABLE + 1.0), 0.5)).rgb;
+  return mix(horizon, zenith, max(dot(view, up), 0.0));
+}
+
+// the haze's light toward the eye along a view direction in eye coordinates, under an overcast as
+// thick as it rains at the camera or along the ray, 0 to 1: the sky's, from the clear sky to the
+// overcast gray, and the sun's through the clouds, as much of it as reaches the haze, 0 to 1.
+// Drops scatter nearly all the light they intercept: an albedo of 1
+vec3 rainHazeColor(vec3 view, float day, float snow, float overcast, float sunlit) {
+  float elevation = max(dot(view, up), 0.0);
+  vec3 sky = skyFromTable(view);
+  vec3 overcastSky = mix(RAIN_HAZE, SNOW_HAZE, snow) * (1.0 + 2.0 * elevation) * (1.0 - THICK_CLOUDS * overcast);
+  vec3 sun = czm_lightColor * sunlit * henyeyGreenstein(dot(view, czm_lightDirectionEC), mix(HAZE_ASYMMETRY.x, HAZE_ASYMMETRY.y, snow));
+  vec3 color = min(mix(sky, overcastSky, overcast) + sun, vec3(1.0));
+  return byDaylight(color, day);
+}

package/src/shaders/RainRings.glsl

@@ -0,0 +1,64 @@
+// Rings where the rain lands: the ground cut into cells of a local frame, in each cell a drop landing, as often as the intensity says, where the
+// cell's hash puts it, a thin ring growing from it and fading as it grows, on what is flat enough. Over water slower and wider. The cells are in a
+// local frame, in double precision from the CPU (local-frame.js), so they stay where they are as the camera moves and do not step with the globe's
+// size. Needs EyeFromDepth, Height, Hash and Normal.
+precision highp sampler2D;
+uniform sampler2D colorTexture;
+uniform sampler2D depthTexture;
+uniform mat4 localFromEye;
+// 0 to 1: the share of the cells that have a drop
+uniform float intensity;
+// meters: a cell's size, and how far a ring on the ground grows
+uniform float cell;
+uniform float reach;
+// meters above the ellipsoid, far above anything with no water
+uniform float waterLevel;
+// radians
+uniform float maxSlope;
+// rings a second
+uniform float rate;
+// seconds
+uniform float time;
+// the color of a ring, its alpha how strongly it shows
+uniform vec4 color;
+in vec2 v_textureCoordinates;
+
+// a ring over water reaches this much farther, and runs this much slower
+const float WATER_REACH = 1.7;
+const float WATER_RATE = 0.5;
+// meters from the water's level within which a surface is water, and beyond which it is not
+const vec2 WET = vec2(0.1, 0.25);
+// the drop lands in the middle of its cell, this far from its edge, in cells: a ring is clipped at the edge
+const float MARGIN = 0.3;
+// the narrowest line, in meters
+const float LINE = 0.045;
+// a pixel wider than the first, in meters, fades the rings out to none at the second: they would be a speckle
+const vec2 SMALL = vec2(0.08, 0.2);
+// half the width of the slope limit, in radians
+const float SLOPE_EDGE = 0.1;
+
+void main() {
+  vec4 sceneColor = texture(colorTexture, v_textureCoordinates);
+  vec4 eye = eyeAt(depthTexture, v_textureCoordinates);
+  if (intensity <= 0.0 || eye.w == 0.0) {
+    out_FragColor = sceneColor;
+    return;
+  }
+  vec3 normal = smoothNormalAt(depthTexture, v_textureCoordinates, eye.xyz);
+  float slope = acos(clamp(dot(normal, up), -1.0, 1.0));
+  vec2 local = (localFromEye * vec4(eye.xyz, 1.0)).xy;
+  float wet = 1.0 - smoothstep(WET.x, WET.y, abs(heightAt(eye.xyz) - waterLevel));
+
+  vec2 id = floor(local / cell);
+  vec2 centre = (id + MARGIN + (1.0 - 2.0 * MARGIN) * vec2(hash(id + 3.1), hash(id + 7.7))) * cell;
+  float phase = fract(time * rate * mix(1.0, WATER_RATE, wet) + hash(id + 11.3));
+  // never past the cell's edge from the centre
+  float grown = min(reach * mix(1.0, WATER_REACH, wet), MARGIN * cell) * phase;
+  float distance = length(local - centre);
+  float width = max(LINE, 1.5 * fwidth(distance));
+  float ring = (1.0 - smoothstep(0.0, width, abs(distance - grown))) * (1.0 - phase);
+  ring *= float(hash(id) < intensity);
+  ring *= 1.0 - smoothstep(maxSlope - SLOPE_EDGE, maxSlope + SLOPE_EDGE, slope);
+  ring *= 1.0 - smoothstep(SMALL.x, SMALL.y, length(fwidth(local)));
+  out_FragColor = vec4(mix(sceneColor.rgb, color.rgb, ring * color.a), sceneColor.a);
+}

package/src/shaders/SkyTable.glsl

@@ -0,0 +1,23 @@
+// The clear sky the haze scatters, drawn by precipitation.js into a small table at each frame,
+// rather than computed twice for each pixel: its first SKY_TABLE texels at SKY_ELEVATION above the
+// horizon, at azimuths from the sun's to its opposite, the sky being symmetric about the sun's
+// vertical plane, and its last overhead, seen from no higher than the cloud base. In world
+// coordinates, the camera's up the ellipsoid's normal under it, so that the camera turning between
+// frames does not skew it. Needs Height, Fog, Phase and RainHaze.
+// meters above the ellipsoid, the precipitation's
+uniform float cloudBase;
+in vec2 v_textureCoordinates;
+
+void main() {
+  vec3 upWC = normalize(czm_viewerPositionWC * czm_ellipsoidInverseRadii * czm_ellipsoidInverseRadii);
+  float i = floor(v_textureCoordinates.x * (SKY_TABLE + 1.0));
+  if (i >= SKY_TABLE) {
+    out_FragColor = vec4(clearSkyBelow(cloudBase, upWC, czm_lightDirectionWC), 1.0);
+    return;
+  }
+  vec3 sun = czm_lightDirectionWC - dot(czm_lightDirectionWC, upWC) * upWC;
+  sun = dot(sun, sun) > 1e-6 ? normalize(sun) : normalize(cross(upWC, vec3(1.0, 0.0, 0.0)));
+  float azimuth = czm_pi * i / (SKY_TABLE - 1.0);
+  vec3 level = cos(azimuth) * sun + sin(azimuth) * cross(upWC, sun);
+  out_FragColor = vec4(clearSkyBelow(cloudBase, cos(SKY_ELEVATION) * level + sin(SKY_ELEVATION) * upWC, czm_lightDirectionWC), 1.0);
+}

package/src/shaders/SnowLine.glsl

@@ -0,0 +1,97 @@
+// Snow above an altitude, on slopes gentle enough to hold it, shaded by the sun and by the
+// brightness of the scene so that the relief stays readable. The slope comes from a normal
+// rebuilt from the neighboring pixels and smoothed over the facets of the terrain. Noise anchored
+// to the ground breaks up the edge of the snow, which lasts lower on the slopes away from the sun.
+precision highp sampler2D;
+uniform sampler2D colorTexture;
+uniform sampler2D depthTexture;
+// meters above the ellipsoid: half covered at the altitude, over a band transition meters high
+uniform float altitude;
+uniform float transition;
+// radians
+uniform float maxSlope;
+// 0 to 1
+uniform float coverage;
+// 0 to 1: how far the coverage thins the snow into patches, where 0 fades it
+uniform float patchiness;
+// meters: the noise's largest scale, its finer ones a third and a ninth of it
+uniform float grain;
+// 0 to 1: how far the snow's brightness is the scene's own (its shadows, the dusk), where 0 is the sun's shading
+uniform float sceneLight;
+// 0 to 1: the part of the snow that still covers the steep slopes at the limit, as a fraction of the coverage
+uniform float steepCover;
+// the local frame's coordinates from the eye's, made in double precision on the CPU (local-frame.js): the noise's place
+uniform mat4 localFromEye;
+// meters above the ellipsoid, far above anything with no water: none lies within a quarter meter of it
+uniform float waterLevel;
+// the sun toward which the snow is shaded, in eye coordinates, when ownSun is 1; else Cesium's
+uniform vec3 sunEC;
+uniform float ownSun;
+in vec2 v_textureCoordinates;
+
+const vec3 SNOW_SHADE = vec3(0.80, 0.87, 1.0);
+const vec3 SNOW_SUN = vec3(1.0, 0.98, 0.94);
+// meters the snow line moves down on a slope facing away from the sun, and up on one facing it
+const float ASPECT_SHIFT = 0.6;
+// meters the noise moves the snow line, as a fraction of the transition
+const float NOISE_SHIFT = 0.8;
+// half width of the slope limit, in radians (8 degrees), so that the snow thins out across the
+// facets of the terrain rather than stopping at their edges
+const float SLOPE_EDGE = 0.14;
+// the coverage, moved by the noise, from which the snow begins and is whole when it is patches; how far the noise moves it
+const vec2 PATCH = vec2(0.25, 0.6);
+const float PATCH_NOISE = 1.6;
+// meters from the water's level within which a surface is water, and beyond which it is not
+const vec2 WET = vec2(0.1, 0.25);
+
+float hash(vec3 p) {
+  p = fract(p * 0.3183099 + 0.1);
+  p *= 17.0;
+  return fract(p.x * p.y * p.z * (p.x + p.y + p.z));
+}
+
+float valueNoise(vec3 p) {
+  vec3 i = floor(p);
+  vec3 f = fract(p);
+  f = f * f * (3.0 - 2.0 * f);
+  return mix(
+    mix(mix(hash(i), hash(i + vec3(1, 0, 0)), f.x), mix(hash(i + vec3(0, 1, 0)), hash(i + vec3(1, 1, 0)), f.x), f.y),
+    mix(mix(hash(i + vec3(0, 0, 1)), hash(i + vec3(1, 0, 1)), f.x), mix(hash(i + vec3(0, 1, 1)), hash(i + vec3(1, 1, 1)), f.x), f.y),
+    f.z);
+}
+
+// 0 to 1, from a few octaves anchored to the ground, in the local frame: in world coordinates a float steps by half a meter
+float groundNoise(vec3 local) {
+  return 0.55 * valueNoise(local / grain) + 0.3 * valueNoise(3.0 * local / grain) + 0.15 * valueNoise(9.0 * local / grain);
+}
+
+void main() {
+  vec4 sceneColor = texture(colorTexture, v_textureCoordinates);
+  vec4 eye = eyeAt(depthTexture, v_textureCoordinates);
+  vec3 normal = smoothNormalAt(depthTexture, v_textureCoordinates, eye.xyz);
+  float slope = acos(clamp(dot(normal, up), -1.0, 1.0));
+
+  float sun = max(dot(normal, ownSun > 0.5 ? sunEC : czm_sunDirectionEC), 0.0);
+  float noise = groundNoise((localFromEye * vec4(eye.xyz, 1.0)).xyz) - 0.5;
+  // lower on the slopes away from the sun, irregular along the edge
+  float shift = transition * (NOISE_SHIFT * noise + ASPECT_SHIFT * (0.5 - sun));
+  float snowLine = altitude + shift;
+  float snow = smoothstep(snowLine - 0.5 * transition, snowLine + 0.5 * transition, heightAt(eye.xyz));
+  // opaque before the top of the band, so that the imagery does not show through the snow
+  snow = smoothstep(0.0, 0.7, snow);
+  // the steep slopes keep a thin, patchy cover, and the rock shows through
+  float steep = smoothstep(maxSlope - SLOPE_EDGE, maxSlope + SLOPE_EDGE, slope);
+  snow *= 1.0 - steep * (1.0 - steepCover * smoothstep(0.35, 0.65, noise + 0.5));
+  // the coverage an opacity, or, by the patchiness, the share of the ground the snow covers, the noise leaving it in patches
+  float scattered = smoothstep(PATCH.x, PATCH.y, coverage + PATCH_NOISE * noise);
+  // eye.w is 0 for the sky
+  snow *= mix(coverage, scattered, patchiness) * eye.w;
+  snow *= smoothstep(WET.x, WET.y, abs(heightAt(eye.xyz) - waterLevel));
+  float brightness = czm_luminance(sceneColor.rgb);
+  // blue in the shade, warm in the sun, with the relief of the scene kept in the brightness; or as bright as the scene, its shadows and its
+  // dusk kept on the snow
+  float shaded = clamp(0.68 + 0.25 * sun + 0.1 * brightness, 0.0, 1.0);
+  float scene = clamp(0.15 + 1.35 * brightness, 0.0, 1.0);
+  vec3 lit = mix(SNOW_SHADE, SNOW_SUN, sun) * mix(shaded, scene, sceneLight);
+  out_FragColor = vec4(mix(sceneColor.rgb, lit, snow), sceneColor.a);
+}

package/src/shaders/SpeedLines.glsl

@@ -0,0 +1,61 @@
+// Speed lines: the picture zooms toward the focus, more toward the edges of the screen, and thin
+// streaks radiate from it, a new pattern many times a second, as in comics.
+precision highp sampler2D;
+uniform sampler2D colorTexture;
+// in eye coordinates; w is 0 for the middle of the screen
+uniform vec4 focus;
+// 0 to 1
+uniform float strength;
+// seconds
+uniform float time;
+in vec2 v_textureCoordinates;
+
+const int BLUR_STEPS = 8;
+// length of the zoom blur at full strength, as a fraction of the distance to the focus
+const float BLUR = 0.12;
+// streaks around the focus, and their changes per second
+const float STREAK_COUNT = 360.0;
+const float STREAK_RATE = 24.0;
+const float STREAK_OPACITY = 0.2;
+
+// the streaks draw their randomness from hash: with a sin, they disappeared for half of each
+// cycle of frames
+void main() {
+  vec2 uv = v_textureCoordinates;
+  vec4 clip = czm_projection * vec4(focus.xyz, 1.0);
+  // on the screen, in front of the camera
+  vec2 center = focus.w > 0.0 && focus.z < 0.0 ? 0.5 * clip.xy / clip.w + 0.5 : vec2(0.5);
+  vec2 toCenter = center - uv;
+  // distance to the focus, 1 at the half height of the screen
+  vec2 aspect = vec2(czm_viewport.z / czm_viewport.w, 1.0);
+  float fromCenter = 2.0 * length(toCenter * aspect);
+  float edge = smoothstep(0.2, 1.0, fromCenter);
+
+  vec4 sceneColor = texture(colorTexture, uv);
+  vec3 color = sceneColor.rgb;
+  // zoom blur, from a start that varies with the pixel so that the steps blur into noise; none
+  // where it would be shorter than a pixel, around the focus
+  float blur = strength * BLUR * edge;
+  if (blur * length(toCenter * czm_viewport.zw) > 0.5) {
+    float jitter = pixelNoise(gl_FragCoord.xy);
+    color = vec3(0.0);
+    for (int i = 0; i < BLUR_STEPS; i++) {
+      color += texture(colorTexture, uv + toCenter * blur * (float(i) + jitter) / float(BLUR_STEPS)).rgb;
+    }
+    color /= float(BLUR_STEPS);
+  }
+
+  // streaks: noise around the focus, constant along each ray from it, only toward the edges
+  float streaks = STREAK_OPACITY * strength * smoothstep(0.5, 1.2, fromCenter);
+  if (streaks > 0.0) {
+    vec2 direction = toCenter * aspect;
+    float frame = mod(floor(time * STREAK_RATE), 1000.0);
+    // value noise over the angle, in whole cells so that it closes around the focus
+    float around = (atan(direction.y, direction.x) / czm_twoPi + 0.5) * STREAK_COUNT;
+    float cell = floor(around);
+    float t = fract(around);
+    float noise = mix(hash(vec2(cell, frame)), hash(vec2(mod(cell + 1.0, STREAK_COUNT), frame)), t * t * (3.0 - 2.0 * t));
+    color = mix(color, vec3(1.0), streaks * smoothstep(0.72, 0.9, noise));
+  }
+  out_FragColor = vec4(color, sceneColor.a);
+}

package/src/shaders/Spotlight.glsl

@@ -0,0 +1,89 @@
+// A searchlight above the focus, pointing down: it throws a pool of warm light radius meters
+// wide on flat ground, with a soft penumbra, shades the relief under it and lights up the haze
+// in its beam, from SpotlightBeam.glsl; the rest of the scene darkens and loses its color. The
+// cone and the falloff follow three.js's SpotLight. Needs EyeFromDepth, Normal, Filmic and
+// SpotlightCone.
+precision highp sampler2D;
+uniform sampler2D colorTexture;
+// the beam's haze and the log2 of the scene distance, at a fraction of the resolution
+uniform sampler2D beamTexture;
+// 0 to 1
+uniform float darkness;
+// brightness of the beam in the air, 0 to 1
+uniform float beam;
+// brightness of the light, 1 for the searchlight: the pool and the beam scale with it
+uniform float power;
+in vec2 v_textureCoordinates;
+
+const vec3 LIGHT_COLOR = vec3(1.0, 0.93, 0.8);
+const float INTENSITY = 1.4;
+// difference of the log2 of the distances, about 10 %, under which the beam's texels around a
+// pixel are interpolated
+const float SOFT_DEPTH = 0.14;
+
+// light reaching a point fromLight away from the light: the cone around the axis with its
+// penumbra, and the inverse square, 1 at the focus, capped for what is close to the light
+float spotAt(vec3 fromLight, vec3 axis, float height, float coneCos, float penumbraCos) {
+  float lightDistance = length(fromLight);
+  float spot = smoothstep(coneCos, penumbraCos, dot(fromLight, -axis) / lightDistance);
+  return spot * min(height * height / (lightDistance * lightDistance), 4.0);
+}
+
+// the beam's haze at the pixel, from the four texels of its lower resolution around it:
+// interpolated where they are all at the pixel's distance, else the one nearest to it, so that the
+// haze stops at the ridges in front of it rather than spilling onto them
+float beamAt(vec2 uv, float depth) {
+  ivec2 size = textureSize(beamTexture, 0);
+  vec2 position = uv * vec2(size) - 0.5;
+  ivec2 base = ivec2(floor(position));
+  vec2 f = fract(position);
+  float interpolated = 0.0;
+  float nearest = 0.0;
+  float nearestGap = 1e38;
+  float widestGap = 0.0;
+  for (int i = 0; i < 4; i++) {
+    ivec2 offset = ivec2(i & 1, i >> 1);
+    vec2 texel = texelFetch(beamTexture, clamp(base + offset, ivec2(0), size - 1), 0).rg;
+    float gap = abs(texel.g - depth);
+    vec2 weights = mix(1.0 - f, f, vec2(offset));
+    interpolated += weights.x * weights.y * texel.r;
+    if (gap < nearestGap) {
+      nearestGap = gap;
+      nearest = texel.r;
+    }
+    widestGap = max(widestGap, gap);
+  }
+  return widestGap < SOFT_DEPTH ? interpolated : nearest;
+}
+
+void main() {
+  vec4 sceneColor = texture(colorTexture, v_textureCoordinates);
+  Cone spot;
+  if (!spotlightCone(spot)) {
+    out_FragColor = sceneColor;
+    return;
+  }
+  vec3 color = sceneColor.rgb;
+  vec3 ambient = czm_saturation(color, 1.0 - darkness) * (1.0 - darkness);
+  vec4 eye = eyeAt(depthTexture, v_textureCoordinates);
+
+  // eye.w is 0 for the sky, where the view ray goes on
+  float sceneDistance = eye.w == 0.0 ? 1e30 : length(eye.xyz);
+  float scattered = beam > 0.0 ? beamAt(v_textureCoordinates, log2(sceneDistance)) : 0.0;
+  vec3 haze = LIGHT_COLOR * (power * beam * scattered);
+  if (eye.w == 0.0) {
+    out_FragColor = vec4(filmic(ambient + haze), sceneColor.a);
+    return;
+  }
+
+  vec3 toLight = spot.light - eye.xyz;
+  // the normal over wider steps where the surface is seen at a grazing angle, where the facets
+  // of the terrain mesh would show as blotches; over fine ones elsewhere, for the relief
+  vec3 coarse = normalize(normalAt(depthTexture, v_textureCoordinates, eye.xyz, 6.0 * czm_pixelRatio)
+    + normalAt(depthTexture, v_textureCoordinates, eye.xyz, 18.0 * czm_pixelRatio));
+  float grazing = smoothstep(0.7, 0.95, 1.0 - abs(dot(coarse, normalize(-eye.xyz))));
+  vec3 normal = normalize(mix(smoothNormalAt(depthTexture, v_textureCoordinates, eye.xyz), coarse, grazing));
+  float lambert = max(dot(normal, normalize(toLight)), 0.0);
+  vec3 light = LIGHT_COLOR * (power * INTENSITY * spotAt(-toLight, up, spot.height, spot.coneCos, spot.penumbraCos) * lambert);
+  out_FragColor = vec4(filmic(ambient + color * light + haze), sceneColor.a);
+}