@geoblocks/cesium-post-process 0.1.2 → 0.1.3

package/README.md

@@ -233,4 +233,6 @@ Its `snow`, from 0 to 1, turns the rain to snow in one population, so that nothi
 
 `SnowLine`, `ValleyFog`, `Precipitation`, `Clouds`, `Lightning`, `Toy`, `WhiteModel`, `TiltShift`, `Spotlight` and `MotionBlur` read the depth buffer. The post-process stages only get the terrain's depth when it is depth tested, so `globe.depthTestAgainstTerrain` is on while any of them is active and restored when the last one is deactivated: billboards and labels that show through the terrain can be hidden by it meanwhile.
 
+The depth they read is the nearest of Cesium's frustums': with `scene.logarithmicDepthBuffer` off, Cesium splits the view into frustums of `farToNearRatio` (1000 by default) from the near plane, and only the nearest one's depth reaches the stages. What lies past the split has no depth there: `Toy` and `WhiteModel` paint their sky over it and draw no edge on it, `TiltShift` blurs it as the far background, `SnowLine` and `ValleyFog` take it for sky. Keep the logarithmic depth buffer on, or set `camera.frustum.near` so that one frustum holds the scene (a near plane of 0.3 m reaches 300 m).
+
 Each effect is a full-screen pass, about 1 to 5 ms per frame at full HD on an integrated GPU, on top of a scene that may already be near its budget: Chrome then stalls for hundreds of milliseconds at a time rather than slowing down evenly. If activating an effect brings that on, the cheapest lever is `scene.msaaSamples = 1` while it is active, restored when it is deactivated, as `@geoblocks/cesium-flyto` does for its flights: 4x multisampling costs more than the effect itself, and a moving picture hides the aliasing.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geoblocks/cesium-post-process",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "license": "BSD-3-Clause",
   "type": "module",
   "repository": {
@@ -53,5 +53,5 @@
     "@cesium/core": ">=0.1.0",
     "@cesium/engine": ">=10"
   },
-  "gitHead": "0abb7f3381fdf13b15d50047a46d3789f5f95a9e"
+  "gitHead": "5c6ee12b4e35f46ff733cf628da105f55121fbf3"
 }

package/shaders/DepthEdges.js

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

package/shaders/Toy.js

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

package/shaders/WhiteModel.js

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

package/toy.js

@@ -16,6 +16,9 @@ const skyBottomScratch = new Cartesian4();
  * outward and shaded where it bends inward, rounded close up, the silhouettes
  * outlined in a darker shade of their color, the colors a little richer and
  * warmer, the sky a soft gradient if asked.
+ * The edges are found in the depth of the nearest of Cesium's frustums only: with `scene.logarithmicDepthBuffer` off,
+ * Cesium splits the view at `farToNearRatio` times the near plane, and what lies past the split has no depth here, so
+ * the sky gradient is painted over it; keep the logarithmic depth, or a near plane that keeps the scene in one frustum.
  */
 export default class Toy extends Effect {
   /**