@geoblocks/cesium-post-process 0.3.0 → 0.5.0

package/src/shaders/SpotlightBeam.glsl

@@ -0,0 +1,49 @@
+// The haze lit by the searchlight's beam, at a fraction of the resolution, as in Killzone Shadow
+// Fall's volumetrics (Valient, SIGGRAPH 2014): r is the light scattered along the view ray, g the
+// log2 of the scene distance for SpotlightBeamBlur.glsl and the upsampling: half floats hold it, and
+// distances compare as ratios. Needs EyeFromDepth, Hash, Noise, SpotlightCone and Beam.
+// brightness of the beam in the air, 0 to 1
+uniform float beam;
+// Henyey-Greenstein asymmetry of the haze, 0 to 1: it scatters mostly forward, so the beam is
+// brighter when looking toward the light
+uniform float beamAnisotropy;
+in vec2 v_textureCoordinates;
+
+// radius of the beam's bright core around the light, in heights: the inverse square is softened
+// within it, as the pool's is capped, so that the top of the beam does not burn out
+const float BEAM_CORE = 0.25;
+// brightness of the lit haze, over the height so that it keeps with the radius, matched to the
+// searchlight's former analytic beam at the default anisotropy
+const float BEAM_DENSITY = 19.0;
+// contrast and density of the dust streaks in the beam, across its width
+const float STREAKS = 0.2;
+const float STREAK_SCALE = 4.0;
+
+void main() {
+  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);
+  Cone spot;
+  if (beam <= 0.0 || !spotlightCone(spot)) {
+    out_FragColor = vec4(0.0, log2(sceneDistance), 0.0, 1.0);
+    return;
+  }
+  Beam cone;
+  cone.apex = spot.light;
+  cone.forward = -up;
+  cone.edgeCos = spot.coneCos;
+  cone.coreCos = spot.penumbraCos;
+  cone.hotCore = 0.0;
+  cone.light = spot.light;
+  cone.reference = spot.height;
+  cone.core = BEAM_CORE * spot.height;
+  cone.reach = 1e30;
+  cone.extinction = 0.0;
+  cone.anisotropy = beamAnisotropy;
+  cone.spacing = 1.0;
+  cone.nearFade = vec2(0.0);
+  cone.dust = STREAKS;
+  cone.dustScale = STREAK_SCALE;
+  float scattered = BEAM_DENSITY / spot.height * beamAlong(normalize(eye.xyz), sceneDistance, cone);
+  out_FragColor = vec4(scattered, log2(sceneDistance), 0.0, 1.0);
+}

package/src/shaders/SpotlightBeamBlur.glsl

@@ -0,0 +1,27 @@
+// The beam's haze, blurred over the neighboring texels at its own resolution, each weighted by how
+// close its scene distance is to the texel's: the dither of the samples along the rays smooths
+// out, but the haze in front of a ridge does not spill onto the ridge.
+precision highp sampler2D;
+uniform sampler2D beamTexture;
+in vec2 v_textureCoordinates;
+
+// difference of the log2 of the distances at which a neighbor no longer counts, about 10 %
+const float SOFT_DEPTH = 0.14;
+
+void main() {
+  // czm_viewport is this pass's texture, the size of the beam's
+  vec2 texel = 1.0 / czm_viewport.zw;
+  float centerDepth = texture(beamTexture, v_textureCoordinates).g;
+  float sum = 0.0;
+  float total = 0.0;
+  for (int y = -1; y <= 1; y++) {
+    for (int x = -1; x <= 1; x++) {
+      vec2 sample_ = texture(beamTexture, v_textureCoordinates + vec2(float(x), float(y)) * texel).rg;
+      float gap = abs(sample_.g - centerDepth);
+      float weight = (x == 0 ? 2.0 : 1.0) * (y == 0 ? 2.0 : 1.0) * clamp(1.0 - gap / SOFT_DEPTH, 0.0, 1.0);
+      sum += weight * sample_.r;
+      total += weight;
+    }
+  }
+  out_FragColor = vec4(sum / total, centerDepth, 0.0, 1.0);
+}

package/src/shaders/SpotlightCone.glsl

@@ -0,0 +1,37 @@
+// The searchlight's cone, for its beam and for its pool of light: the light hangs above the focus,
+// pointing down. Needs EyeFromDepth.
+precision highp sampler2D;
+uniform sampler2D depthTexture;
+// in eye coordinates; w is 0 for what is in the middle of the screen
+uniform vec4 focus;
+// local up direction, in eye coordinates
+uniform vec3 up;
+// meters
+uniform float radius;
+// width of the penumbra, as a fraction of the radius
+uniform float softness;
+
+// height of the light above the focus, in radii: a cone of 53 degrees
+const float HEIGHT = 2.0;
+
+struct Cone {
+  vec3 light;
+  float height;
+  // cosines of the angles, from the light's axis, at which the pool ends and its penumbra starts
+  float coneCos;
+  float penumbraCos;
+};
+
+// false without a focus in front of the camera (the sky in the middle, a focus behind)
+bool spotlightCone(out Cone cone) {
+  vec4 target = focus.w > 0.0 ? focus : eyeAt(depthTexture, vec2(0.5));
+  if (target.w == 0.0 || target.z >= 0.0) {
+    return false;
+  }
+  cone.height = HEIGHT * radius;
+  cone.light = target.xyz + cone.height * up;
+  float inner = radius * (1.0 - softness);
+  cone.coneCos = cone.height / sqrt(cone.height * cone.height + radius * radius);
+  cone.penumbraCos = cone.height / sqrt(cone.height * cone.height + inner * inner);
+  return true;
+}

package/src/shaders/Super8.glsl

@@ -0,0 +1,90 @@
+// A Super 8 home movie: faded warm colors, halation around the highlights, heavy grain, the frame
+// drifting in the gate, flicker, light leaks, a strong vignette and the rounded corners of the
+// camera gate.
+precision highp sampler2D;
+uniform sampler2D colorTexture;
+// the scene blurred, for the halation
+uniform sampler2D blurTexture;
+// seconds
+uniform float time;
+// 0 to 1
+uniform float fade;
+uniform float grain;
+// in CSS pixels
+uniform float weave;
+// 0 to 1
+uniform float flicker;
+uniform float lightLeaks;
+uniform float halation;
+// width over height of the visible frame, 0 for the whole canvas
+uniform float aspectRatio;
+in vec2 v_textureCoordinates;
+
+// Super 8 runs at 18 frames per second
+const float FRAME_RATE = 18.0;
+// radius of the rounded corners, as a fraction of the frame height
+const float CORNER = 0.05;
+const vec3 LEAK = vec3(1.0, 0.45, 0.15);
+// size of the grain clumps, in CSS pixels, and how much they differ between the dye layers
+const float GRAIN_SIZE = 2.0;
+const float GRAIN_COLOR = 0.3;
+// light scattered back through the film base is red-orange
+const vec3 HALATION = vec3(1.0, 0.35, 0.15);
+
+float hash(float n) {
+  return fract(sin(n) * 43758.5453);
+}
+
+// smooth noise in [0, 1) over time
+float noise(float t) {
+  float i = floor(t);
+  float f = fract(t);
+  return mix(hash(i), hash(i + 1.0), f * f * (3.0 - 2.0 * f));
+}
+
+void main() {
+  vec2 size = czm_viewport.zw;
+  // the time of the film frame, and its number for the noise
+  float t = floor(time * FRAME_RATE) / FRAME_RATE;
+  float frame = mod(floor(time * FRAME_RATE), 1000.0);
+
+  // gate weave: the whole picture drifts by a pixel or two, from frame to frame
+  vec2 drift = vec2(noise(t * 3.0), noise(t * 3.0 + 17.0)) * 2.0 - 1.0;
+  vec2 uv = v_textureCoordinates + weave * czm_pixelRatio * drift / size;
+
+  // the gate, with rounded corners, in pixels
+  vec2 frameHalf = 0.5 * frameSize(aspectRatio) * size;
+  float radius = CORNER * 2.0 * frameHalf.y;
+  vec2 q = abs((v_textureCoordinates - 0.5) * size) - frameHalf + radius;
+  float outside = length(max(q, 0.0)) + min(max(q.x, q.y), 0.0) - radius;
+  float gate = 1.0 - smoothstep(-czm_pixelRatio, czm_pixelRatio, outside);
+  // -0.5 to 0.5 inside the frame
+  vec2 inFrame = (v_textureCoordinates - 0.5) * size / (2.0 * frameHalf);
+
+  vec3 color = texture(colorTexture, uv).rgb;
+  // faded film: less saturation, lifted blacks, a warm cast
+  color = mix(color, vec3(czm_luminance(color)), 0.4 * fade);
+  color = mix(color, color * vec3(1.05, 0.95, 0.78) * 0.88 + vec3(0.09, 0.07, 0.05), fade);
+  // halation: a warm glow bleeding around the highlights
+  float glow = smoothstep(0.45, 0.9, czm_luminance(texture(blurTexture, uv).rgb));
+  color = 1.0 - (1.0 - color) * (1.0 - halation * glow * HALATION);
+  // vignette
+  color *= 1.0 - 0.6 * smoothstep(0.35, 0.85, length(inFrame));
+  // a warm light leak, drifting along the right edge and coming and going
+  vec2 leakAt = vec2(0.6, noise(time * 0.15) - 0.5);
+  float leak = lightLeaks * smoothstep(0.3, 0.9, noise(time * 0.3 + 5.0)) * exp(-6.0 * dot(inFrame - leakAt, inFrame - leakAt));
+  color = 1.0 - (1.0 - color) * (1.0 - leak * LEAK);
+  // flicker: the brightness changes from frame to frame
+  color *= 1.0 + flicker * (2.0 * hash(frame) - 1.0);
+  // grain: clumps a few pixels wide, a new pattern with each film frame, a little different in
+  // each dye layer, heaviest in the shadows and midtones and fading out in the highlights
+  vec2 grainAt = gl_FragCoord.xy / (GRAIN_SIZE * czm_pixelRatio);
+  float z = frame * 1.7 + 0.5;
+  float mono = gradientNoise(grainAt, z);
+  vec3 layers = vec3(gradientNoise(grainAt, z + 101.0), gradientNoise(grainAt, z + 211.0), gradientNoise(grainAt, z + 307.0));
+  vec3 noise = mix(vec3(mono), layers, GRAIN_COLOR);
+  float y = clamp(czm_luminance(color), 0.0, 1.0);
+  color += grain * 1.4 * noise * 2.0 * (1.0 - y) * (0.5 + y);
+
+  out_FragColor = vec4(clamp(color, 0.0, 1.0) * gate, 1.0);
+}

package/src/shaders/Technicolor.glsl

@@ -0,0 +1,30 @@
+// Three-strip Technicolor: the camera split the scene into red, green and blue records, each
+// printed with its complementary dye, the three dyes over each other. Each color gains its purity,
+// what it has over the other two, and loses some of theirs: grays stay, primaries deepen. After
+// prod80's ReShade Technicolor (MIT), https://github.com/prod80/prod80-ReShade-Repository
+precision highp sampler2D;
+uniform sampler2D colorTexture;
+// 0 to 1
+uniform float strength;
+// width over height of the visible frame, 0 for the whole canvas
+uniform float aspectRatio;
+in vec2 v_textureCoordinates;
+
+// how much of the other colors' purity each color loses
+const float COLOR_STRENGTH = 0.2;
+
+void main() {
+  vec2 inFrame = (v_textureCoordinates - 0.5) / frameSize(aspectRatio);
+  if (max(abs(inFrame.x), abs(inFrame.y)) > 0.5) {
+    out_FragColor = vec4(0.0, 0.0, 0.0, 1.0);
+    return;
+  }
+  vec4 sceneColor = texture(colorTexture, v_textureCoordinates);
+  vec3 color = sceneColor.rgb;
+  // red: r (1 - g) (1 - b), and so on
+  vec3 negative = 1.0 - color;
+  vec3 purity = color * negative.grg * negative.bbr;
+  vec3 taken = COLOR_STRENGTH * purity;
+  vec3 printed = color + purity - taken.yxy - taken.zzx;
+  out_FragColor = vec4(clamp(mix(color, printed, strength), 0.0, 1.0), sceneColor.a);
+}

package/src/shaders/TiltShift.glsl

@@ -0,0 +1,34 @@
+// Tilt-shift: a narrow band of sharpness around the focal distance and the blurred image further
+// off, with the punchy colors of miniature photographs. Distances compare as ratios, like a lens:
+// sharp within range factors of two of the focal distance, fully blurred at twice that. An
+// orthographic camera has no distance to compare: a band across the screen, as a miniature's fake,
+// sharp within range of the view's height above and below the focus, whatever stands there.
+precision highp sampler2D;
+uniform sampler2D colorTexture;
+uniform sampler2D blurTexture;
+uniform sampler2D depthTexture;
+// in eye coordinates; w is 0 for what is in the middle of the screen
+uniform vec4 focus;
+// in factors of two of the focal distance, or shares of the view's height (orthographic)
+uniform float range;
+// 0 to 1
+uniform float saturation;
+in vec2 v_textureCoordinates;
+
+void main() {
+  vec4 target = focus.w > 0.0 ? focus : eyeAt(depthTexture, vec2(0.5));
+  vec4 eye = eyeAt(depthTexture, v_textureCoordinates);
+  float fromCamera = eye.w == 0.0 ? 1e30 : length(eye.xyz);
+  // the orthographic view's height: its projection's y scale is 2 over it
+  float off = czm_orthographicIn3D == 1.0
+    ? abs(eye.y - target.y) * czm_projection[1][1] / 2.0
+    : abs(log2(fromCamera / length(target.xyz)));
+  // no blur without a focus in front of the camera (the sky in the middle, a focus behind)
+  float blur = target.w > 0.0 && target.z < 0.0 ? smoothstep(range, 2.0 * range, off) : 0.0;
+  vec4 sceneColor = mix(texture(colorTexture, v_textureCoordinates), texture(blurTexture, v_textureCoordinates), blur);
+
+  vec3 color = sceneColor.rgb;
+  color = czm_saturation(color, 1.0 + saturation);
+  color = mix(color, smoothstep(0.0, 1.0, color), saturation);
+  out_FragColor = vec4(clamp(color, 0.0, 1.0), sceneColor.a);
+}

package/src/shaders/Toy.glsl

@@ -0,0 +1,46 @@
+// A toy's look, as an isometric game's, after DepthEdges: the edges lit where the surface bends
+// outward and shaded where it bends inward, rounded as molded plastic close up; an outline along
+// the jumps, on their near side, a darker shade of the color; the colors a little richer and
+// warmer; the sky, if asked, a soft gradient.
+// its samplers read in high precision, whatever comes before (a phone's GPU's default is low)
+precision highp sampler2D;
+uniform sampler2D colorTexture;
+// how much brighter a convex edge gets, how much darker a concave one
+uniform float light;
+uniform float shade;
+// the edges' bevel, in meters, a pixel at the least; how much darker the outline, 0 for none
+uniform float bevel;
+uniform float outline;
+// the colors' saturation, and a factor each of red, green and blue
+uniform float saturation;
+uniform vec3 warm;
+// the sky's gradient, from the top of the screen to its bottom; w 0 to keep the sky
+uniform vec4 skyTop;
+uniform vec4 skyBottom;
+in vec2 v_textureCoordinates;
+
+void main() {
+  vec2 uv = v_textureCoordinates;
+  vec4 sceneColor = texture(colorTexture, uv);
+  float c = depthAt(uv);
+  if (c == SKY) {
+    out_FragColor = skyTop.w > 0.0 ? vec4(skyAt(uv, skyTop, skyBottom), 1.0) : sceneColor;
+    return;
+  }
+  float pixel = pixelAt(c);
+  // the neighbors a bevel's width away: the bend measured over it, strongest on the edge and fading
+  // to nothing a bevel off, a rounded edge's highlight
+  float steps = clamp(bevel / pixel, 1.0, BEVEL);
+  vec3 color = sceneColor.rgb;
+  // the creases' neighbours read only when they light or shade: a scene drawing its own edges asks for neither
+  if (light != 0.0 || shade != 0.0) {
+    vec4 n = neighborsAt(uv, c, steps);
+    float crease = creaseOf(n, steps * pixel, pixel);
+    color *= n.x + n.y + n.z + n.w > 0.0 ? 1.0 + light * crease : 1.0 - shade * crease;
+  }
+  if (outline > 0.0) {
+    color *= 1.0 - outline * outlineAt(uv, c, vec4(0.0), steps, pixel);
+  }
+  color = czm_saturation(color, saturation) * warm;
+  out_FragColor = vec4(clamp(color, 0.0, 1.0), sceneColor.a);
+}

package/src/shaders/ValleyFog.glsl

@@ -0,0 +1,40 @@
+// Fog filling the valleys below an altitude: the fog along the ray from the camera to the pixel
+// is the part of the ray below the top, the density thinning over a soft band under the top. Needs
+// EyeFromDepth, Height and Fog.
+precision highp sampler2D;
+uniform sampler2D colorTexture;
+uniform sampler2D depthTexture;
+// meters above the ellipsoid
+uniform float top;
+// per meter
+uniform float density;
+// meters
+uniform float softness;
+uniform vec4 color;
+in vec2 v_textureCoordinates;
+
+// the integral of clamp(x, 0, 1)
+float ramp(float x) {
+  return x <= 0.0 ? 0.0 : x < 1.0 ? 0.5 * x * x : x - 0.5;
+}
+
+// mean fraction of the density along a straight ray from height h0 to h1
+float fogFraction(float h0, float h1) {
+  float band = max(softness, 1e-3);
+  if (abs(h1 - h0) < 1e-2) {
+    return clamp((top - h0) / band, 0.0, 1.0);
+  }
+  return band * (ramp((top - h0) / band) - ramp((top - h1) / band)) / (h1 - h0);
+}
+
+void main() {
+  vec4 sceneColor = texture(colorTexture, v_textureCoordinates);
+  vec4 eye = eyeAt(depthTexture, v_textureCoordinates);
+  // the sky is a direction
+  vec3 end = eye.w == 0.0 ? eye.xyz * SKY_DISTANCE : eye.xyz;
+  float amount = 1.0 - exp(-density * length(end) * fogFraction(cameraHeight, heightAt(end)));
+  // lit by the sun, as Cesium's fog: the fog color during the day, turning around sunset to a
+  // moonlit blue as bright as the scene's fog.minimumBrightness, rather than a flat gray
+  vec3 fogColor = byDaylight(color.rgb, daylight());
+  out_FragColor = vec4(mix(sceneColor.rgb, fogColor, amount * color.a), sceneColor.a);
+}

package/src/shaders/WeatherMap.glsl

@@ -0,0 +1,33 @@
+// Where it rains: the map of the local intensity, 0 to 1 in its red channel, over a rectangle of
+// longitudes and latitudes, sampled bilinearly, which fades the rain in over a cell at its edges.
+// Without a map, a pixel over the whole globe: rain everywhere for Precipitation, none for Clouds.
+// A next map over the same rectangle crossfades from it by the blend, as the radar from one hour to
+// the next; without one, the map again.
+precision highp sampler2D;
+uniform sampler2D map;
+uniform sampler2D nextMap;
+uniform float mapBlend;
+// the rectangle in the ellipsoid's texture coordinates: its west and south, and one over its width
+// and height
+uniform vec4 mapBounds;
+
+// a point in world coordinates on the map, 0 to 1 over its rectangle: single precision rounds it to
+// about half a meter, nothing at the scale of a map
+vec2 mapUv(vec3 positionWC) {
+  vec3 normal = normalize(positionWC * czm_ellipsoidInverseRadii * czm_ellipsoidInverseRadii);
+  return (czm_ellipsoidTextureCoordinates(normal) - mapBounds.xy) * mapBounds.zw;
+}
+
+// the map's texel at a point in world coordinates, all its channels, 0 outside the map
+vec4 mapTexelAt(vec3 positionWC) {
+  vec2 uv = mapUv(positionWC);
+  if (any(lessThan(uv, vec2(0.0))) || any(greaterThan(uv, vec2(1.0)))) {
+    return vec4(0.0);
+  }
+  return mix(texture(map, uv), texture(nextMap, uv), mapBlend);
+}
+
+// the local intensity at a point in world coordinates, 0 outside the map
+float mapAt(vec3 positionWC) {
+  return mapTexelAt(positionWC).r;
+}

package/src/shaders/WhiteModel.glsl

@@ -0,0 +1,108 @@
+// A white model's look, as an architect's plaster model or clay render, after DepthEdges: every
+// color turned to its value and the values pressed into a narrow range of whites (an accent's hue
+// kept, if asked; the darkest left black, a section's poché), so the light and the shapes alone
+// tell the surfaces apart; darker where surfaces meet, an ambient obscurance from the depth; the
+// creases lit and shaded, a fine outline along the jumps; the sky, if asked, a pale gradient.
+// its samplers read in high precision, whatever comes before (a phone's GPU's default is low)
+precision highp sampler2D;
+uniform sampler2D colorTexture;
+// how much brighter a convex edge gets, how much darker a concave one
+uniform float light;
+uniform float shade;
+// the edges' bevel, in meters, a pixel at the least; how much darker the outline, 0 for none
+uniform float bevel;
+uniform float outline;
+// the colors' saturation, 0 for white, and a factor each of red, green and blue: the plaster's tint
+uniform float saturation;
+uniform vec3 warm;
+// the darkest and the lightest values, the scene's black and white; the value under which a color
+// keeps it, 0 for none
+uniform vec2 values;
+uniform float poche;
+// how much darker a corner gets, and how wide its shadow is, in meters
+uniform float occlusion;
+uniform float radius;
+// the sky's gradient, from the top of the screen to its bottom; w 0 to keep the sky
+uniform vec4 skyTop;
+uniform vec4 skyBottom;
+in vec2 v_textureCoordinates;
+
+// the darkest colors' values, under the poché's, kept as they are rather than pressed into the
+// whites, fading into them over these shares of it: an architect's poché, solid black, or a text's
+const vec2 POCHE = vec2(0.6, 1.4);
+// the occlusion: its widest, in pixels; its samples, on a spiral turned by the golden angle, the
+// spiral itself turned from pixel to pixel; how steeply above the surface a sample rises to count
+// (the normal from the depth is not exact), and how far from the pixel, in meters, a pixel and a
+// half at the least (the depth's own steps on a flat wall not counted); how many pixels wide the
+// disc is to show, fading in (zoomed out, its samples fall within the depth's noise)
+const float RING = 48.0;
+const int SAMPLES = 12;
+const float GOLDEN = 2.39996;
+const float BIAS = 0.15;
+const float NEAREST = 0.05;
+const vec2 SHOWN = vec2(3.0, 8.0);
+
+// how much the surfaces around uv close in over it, from 0 to 1, as the Alchemy ambient obscurance
+// (McGuire et al. 2011): the share of the samples around it, in a disc of the radius, that rise
+// above its surface (its normal from the depth's slopes), each the more as it rises steeper, none
+// farther than the radius; a corner's foot about a half, a flat floor none. p its eye coordinates, n
+// their slopes' normal
+float occludedAt(vec2 uv, vec3 p, vec3 n, float pixel) {
+  float reach = min(radius, RING * pixel);
+  float shown = smoothstep(SHOWN.x, SHOWN.y, reach / pixel);
+  if (shown == 0.0) {
+    return 0.0;
+  }
+  // turned toward the eye
+  vec3 eye = czm_orthographicIn3D == 1.0 ? vec3(0.0, 0.0, 1.0) : normalize(-p);
+  n = dot(n, eye) < 0.0 ? -n : n;
+  float nearest = max(NEAREST, 1.5 * pixel);
+  float spin = 6.2832 * fract(52.9829189 * fract(dot(gl_FragCoord.xy, vec2(0.06711056, 0.00583715))));
+  float sum = 0.0;
+  for (int i = 0; i < SAMPLES; i++) {
+    float a = float(i) * GOLDEN + spin;
+    vec2 o = vec2(cos(a), sin(a)) * (float(i) + 0.5) / float(SAMPLES) * reach / pixel / czm_viewport.zw;
+    vec4 q = eyeAt(depthTexture, uv + o);
+    vec3 v = q.xyz - p;
+    float d = length(v);
+    if (q.w > 0.0 && d > nearest) {
+      sum += max(0.0, dot(v / d, n) - BIAS) * (1.0 - smoothstep(0.5 * reach, reach, d));
+    }
+  }
+  return shown * sum / float(SAMPLES);
+}
+
+void main() {
+  vec2 uv = v_textureCoordinates;
+  // the surface's normal from the depth's slopes, read before any pixel returns, in step with its
+  // neighbors
+  vec3 p = eyeAt(depthTexture, uv).xyz;
+  vec3 normal = normalize(cross(dFdx(p), dFdy(p)));
+  vec4 sceneColor = texture(colorTexture, uv);
+  float c = depthAt(uv);
+  if (c == SKY) {
+    out_FragColor = skyTop.w > 0.0 ? vec4(skyAt(uv, skyTop, skyBottom), 1.0) : sceneColor;
+    return;
+  }
+  float pixel = pixelAt(c);
+  // the color's value pressed between the darkest and the lightest, but the darkest's; its hue as
+  // saturated as asked, scaled down rather than clipped where a channel would pass 1
+  float value = czm_luminance(sceneColor.rgb);
+  float kept = poche > 0.0 ? 1.0 - smoothstep(POCHE.x * poche, POCHE.y * poche, value) : 0.0;
+  float pressed = mix(mix(values.x, values.y, value), value, kept);
+  vec3 hue = sceneColor.rgb * pressed / max(value, 1e-4);
+  vec3 color = mix(vec3(pressed), hue / max(1.0, max(hue.r, max(hue.g, hue.b))), saturation);
+  float steps = clamp(bevel / pixel, 1.0, BEVEL);
+  if (light != 0.0 || shade != 0.0) {
+    vec4 n = neighborsAt(uv, c, steps);
+    float crease = creaseOf(n, steps * pixel, pixel);
+    color *= n.x + n.y + n.z + n.w > 0.0 ? 1.0 + light * crease : 1.0 - shade * crease;
+  }
+  if (occlusion > 0.0) {
+    color *= 1.0 - occlusion * occludedAt(uv, p, normal, pixel);
+  }
+  if (outline > 0.0) {
+    color *= 1.0 - outline * outlineAt(uv, c, vec4(0.0), steps, pixel);
+  }
+  out_FragColor = vec4(clamp(color * warm, 0.0, 1.0), sceneColor.a);
+}

package/{snow-line.js → src/snow-line.js}

@@ -3,6 +3,7 @@ import {PostProcessStage} from '@cesium/engine';
 import {acquireTerrainDepth, releaseTerrainDepth} from './depth-test.js';
 import Effect from './effect.js';
 import {heightUniforms} from './height.js';
+import {LocalFrame} from './local-frame.js';
 import EyeFromDepth from './shaders/EyeFromDepth.js';
 import Height from './shaders/Height.js';
 import Normal from './shaders/Normal.js';
@@ -21,7 +22,7 @@ export default class SnowLine extends Effect {
   /**
    * @param {import('@cesium/engine').CesiumWidget} viewer
    * @param {{altitude?: number, transition?: number, maxSlope?: number, coverage?: number, patchiness?: number, waterLevel?: number,
-   *   sunDirection?: Cartesian3}} [options]
+   *   sunDirection?: Cartesian3, grain?: number, sceneLight?: number, steepCover?: number, origin?: Cartesian3}} [options]
    */
   constructor(viewer, options = {}) {
     super(viewer);
@@ -32,6 +33,10 @@ export default class SnowLine extends Effect {
     this.patchiness_ = options.patchiness ?? 0;
     this.waterLevel_ = options.waterLevel;
     this.sunDirection_ = options.sunDirection && Cartesian3.normalize(options.sunDirection, new Cartesian3());
+    this.grain_ = options.grain ?? 90;
+    this.sceneLight_ = options.sceneLight ?? 0;
+    this.steepCover_ = options.steepCover ?? 0.35;
+    this.frame_ = new LocalFrame(options.origin);
   }
 
   /**
@@ -39,7 +44,7 @@ export default class SnowLine extends Effect {
    * @param {import('@cesium/engine').Scene} scene
    */
   createStage_(scene) {
-    return new PostProcessStage({
+    const stage = new PostProcessStage({
       fragmentShader: EyeFromDepth + Height + Normal + SnowLineShader,
       uniforms: {
         ...heightUniforms(scene),
@@ -51,8 +56,15 @@ export default class SnowLine extends Effect {
         waterLevel: () => this.waterLevel_ ?? NO_WATER,
         sunEC: () => this.sunDirection_ ? Matrix4.multiplyByPointAsVector(scene.camera.viewMatrix, this.sunDirection_, sunScratch) : sunScratch,
         ownSun: () => this.sunDirection_ ? 1 : 0,
+        grain: () => this.grain_,
+        sceneLight: () => this.sceneLight_,
+        steepCover: () => this.steepCover_,
+        localFromEye: () => this.frame_.fromEye(scene),
       },
     });
+    // with no coverage the pass would only copy: off
+    stage.enabled = this.coverage_ > 0;
+    return stage;
   }
 
   /**
@@ -60,6 +72,7 @@ export default class SnowLine extends Effect {
    * @param {import('@cesium/engine').Scene} scene
    */
   activated_(scene) {
+    this.frame_.anchor(scene);
     acquireTerrainDepth(scene);
   }
 
@@ -108,7 +121,7 @@ export default class SnowLine extends Effect {
   }
 
   /**
-   * Opacity of the snow, 0 to 1.
+   * Opacity of the snow, 0 (none: the stage is off) to 1.
    */
   get coverage() {
     return this.coverage_;
@@ -116,6 +129,9 @@ export default class SnowLine extends Effect {
 
   set coverage(value) {
     this.coverage_ = value;
+    if (this.stage_) {
+      this.stage_.enabled = value > 0;
+    }
     this.viewer.scene.requestRender();
   }
 
@@ -157,4 +173,56 @@ export default class SnowLine extends Effect {
     this.sunDirection_ = value && Cartesian3.normalize(value, new Cartesian3());
     this.viewer.scene.requestRender();
   }
+
+  /**
+   * The noise's largest scale, in meters, its finer ones a third and a ninth of it: the size of the patches and of the snow line's
+   * irregularities. A few meters for a garden, tens for a mountainside.
+   */
+  get grain() {
+    return this.grain_;
+  }
+
+  set grain(value) {
+    this.grain_ = value;
+    this.viewer.scene.requestRender();
+  }
+
+  /**
+   * How far the snow's brightness is the scene's own, 0 to 1: at 0 the snow is shaded by the sun alone and stays bright at dusk; at 1 it
+   * keeps the scene's shadows and darkens with its light, for a scene lit by a light of its own that goes down at night.
+   */
+  get sceneLight() {
+    return this.sceneLight_;
+  }
+
+  set sceneLight(value) {
+    this.sceneLight_ = value;
+    this.viewer.scene.requestRender();
+  }
+
+  /**
+   * The thin cover the steep slopes keep at the limit, as a fraction of the coverage, 0 to 1: the rock showing through on a mountain; 0
+   * for none on the walls of a building.
+   */
+  get steepCover() {
+    return this.steepCover_;
+  }
+
+  set steepCover(value) {
+    this.steepCover_ = value;
+    this.viewer.scene.requestRender();
+  }
+
+  /**
+   * The point of the world the noise is laid about, which keeps the snow's patches where they are as the camera moves; the camera's
+   * position when the effect is activated if none is given. Keep it within a few kilometers of what is looked at for a grain of a few meters.
+   */
+  get origin() {
+    return this.frame_.origin;
+  }
+
+  set origin(value) {
+    this.frame_.origin = value;
+    this.viewer.scene.requestRender();
+  }
 }

package/local-frame.js

@@ -1,15 +0,0 @@
-import {Matrix4} from '@cesium/core';
-
-/**
- * The local frame's coordinates from the eye's, for a shader that wants a pixel's place in a small frame (east-north-up about a point) to
- * lay a pattern over the ground that stays where it is as the camera moves. Made in double precision on the CPU: the globe's offset
- * (about 6.4 million meters) cancels in the product, so the matrix a shader gets is small and a place comes out to the millimeter. In world
- * coordinates, a single precision float steps by half a meter.
- * @param {Matrix4} frame The local frame in the world, such as `FixedFrameTransforms.eastNorthUpToFixedFrame(origin)`.
- * @param {Matrix4} viewMatrix The camera's view matrix.
- * @param {Matrix4} [result]
- * @return {Matrix4}
- */
-export function localFromEye(frame, viewMatrix, result = new Matrix4()) {
-  return Matrix4.inverseTransformation(Matrix4.multiply(viewMatrix, frame, result), result);
-}

package/shaders/SnowLine.js

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