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