Ripple and Glitch are gone; Crt stays

The user tried them live and wants them removed entirely: the builtins,
their levels, config keys and leader paths (tR, tg), their slots in the
built-in chain, their shaders (source and prebuilt), EffectCode paths, and
on macOS their scene flags (pardes.h), the Metal kernel's coordinate warps
and the Swift pointer mapping that mirrored them. Docs say so (decision 8
in docs/render-pipeline.md); config.md documents Crt's levels, Shader and
ShaderAnimation instead.

Shared files touched: macos.zig (flags). Not touched: pardes.zig,
Messages.zig, mouse.zig, gui.zig, detached/*.

2 files changed, 0 insertions, 116 deletions

diff --git a/shaders/post/glitch.glsl b/shaders/post/glitch.glsl
deleted file mode 100644
index 8f420d9c..00000000
--- a/shaders/post/glitch.glsl
+++ /dev/null
@@ -1,64 +0,0 @@
-// Glitch: now and then the signal slips. At the default level, every couple
-// of seconds a short
-// burst tears a few horizontal bands sideways and pulls their red and blue
-// apart; the bands are sized in pixels and the burst eases in and out over
-// a fraction of a second, so it reads as one event rather than a flicker,
-// and it looks the same at 60 or 144 Hz because every step is keyed to
-// iTime, not to frames. Between bursts the page is left exactly as it is.
-// A torn band's brightness dips in linear light. It is a Shadertoy file:
-// pardes puts its prefix before it.
-
-// Each at levels 1, 2 and 3 (`Glitch 1`..`Glitch 3`); 2 is the default. A
-// higher level slips more often and harder.
-float period() { return pardesByLevel(4.5, 2.4, 0.55); }      // seconds between bursts, on average
-float burst() { return pardesByLevel(0.2, 0.28, 0.5); }       // seconds a burst lasts
-float stepHz() { return pardesByLevel(20.0, 24.0, 30.0); }    // how often a burst re-tears
-float shiftPx() { return pardesByLevel(8.0, 14.0, 34.0); }
-float splitPx() { return pardesByLevel(1.5, 2.5, 6.0); }
-float dip() { return pardesByLevel(0.08, 0.12, 0.22); }
-float tearFrom() { return pardesByLevel(0.8, 0.72, 0.35); }   // how few bands tear
-
-float hash(vec2 p) {
-    vec3 q = fract(vec3(p.xyx) * 0.1031);
-    q += dot(q, q.yzx + 33.33);
-    return fract((q.x + q.y) * q.z);
-}
-
-vec3 toLinear(vec3 c) {
-    return mix(pow((c + 0.055) / 1.055, vec3(2.4)), c / 12.92, lessThanEqual(c, vec3(0.04045)));
-}
-
-vec3 toSrgb(vec3 c) {
-    c = max(c, vec3(0.0));
-    return mix(1.055 * pow(c, vec3(1.0 / 2.4)) - 0.055, c * 12.92, lessThanEqual(c, vec3(0.0031308)));
-}
-
-void mainImage(out vec4 fragColor, in vec2 fragCoord) {
-    vec2 size = iResolution.xy;
-    vec2 uv = fragCoord / size;
-    // Which burst window this is, when in it the burst starts, and how far
-    // into the burst we are: 0 outside one.
-    float window = floor(iTime / period());
-    float start = window * period() + hash(vec2(window, 7.0)) * (period() - burst());
-    float t = (iTime - start) / burst();
-    float live = step(0.0, t) * step(t, 1.0);
-    float envelope = live * sin(3.14159265 * clamp(t, 0.0, 1.0));
-    if (envelope <= 0.0) {
-        fragColor = texture(iChannel0, uv);
-        return;
-    }
-    // Bands of 6 to 40 px, re-cut at stepHz() during the burst; about one
-    // band in four tears.
-    float tick = floor(iTime * stepHz());
-    float band_px = mix(6.0, 40.0, hash(vec2(tick, 3.0)));
-    float band = floor(fragCoord.y / band_px);
-    float roll = hash(vec2(band, tick));
-    float tear = smoothstep(tearFrom(), tearFrom() + 0.18, roll) * envelope;
-    float shift = (hash(vec2(tick, band + 11.0)) - 0.5) * 2.0 * shiftPx() * tear;
-    vec2 at = vec2(fragCoord.x + shift, fragCoord.y);
-    vec2 split = vec2(splitPx() * tear, 0.0);
-    vec4 center = texture(iChannel0, at / size);
-    vec3 col = vec3(texture(iChannel0, (at + split) / size).r, center.g, texture(iChannel0, (at - split) / size).b);
-    col = toSrgb(toLinear(col) * (1.0 - dip() * tear));
-    fragColor = vec4(col, center.a);
-}
diff --git a/shaders/post/ripple.glsl b/shaders/post/ripple.glsl
deleted file mode 100644
index 3236d339..00000000
--- a/shaders/post/ripple.glsl
+++ /dev/null
@@ -1,52 +0,0 @@
-// Ripple: the page as a still pool a slow swell crosses. Rings travel out
-// from the middle of the window at a fixed speed in pixels, so they look
-// the same at any size and frame rate; at the default level the displacement
-// is at most a couple of pixels, so text stays readable, and it eases in over its first half
-// second instead of snapping on. Each ring catches the light a little on its
-// rising side, in linear light, and the result is dithered so the shading
-// never bands. It is a Shadertoy file: pardes puts its prefix before it.
-
-const float TAU = 6.28318530718;
-const float EASE_IN = 0.5;          // seconds
-
-// Each at levels 1, 2 and 3 (`Ripple 1`..`Ripple 3`); 2 is the default.
-float wavelengthPx() { return pardesByLevel(170.0, 150.0, 120.0); }
-float speedPx() { return pardesByLevel(40.0, 55.0, 80.0); }        // outward, per second
-float amplitudePx() { return pardesByLevel(1.2, 2.2, 5.0); }
-float shade() { return pardesByLevel(0.02, 0.035, 0.09); }         // light on a slope, linear
-float reachEnd() { return pardesByLevel(0.85, 0.95, 1.3); }        // how far out it dies away
-
-vec3 toLinear(vec3 c) {
-    return mix(pow((c + 0.055) / 1.055, vec3(2.4)), c / 12.92, lessThanEqual(c, vec3(0.04045)));
-}
-
-vec3 toSrgb(vec3 c) {
-    c = max(c, vec3(0.0));
-    return mix(1.055 * pow(c, vec3(1.0 / 2.4)) - 0.055, c * 12.92, lessThanEqual(c, vec3(0.0031308)));
-}
-
-float ign(vec2 p) {
-    return fract(52.9829189 * fract(dot(p, vec2(0.06711056, 0.00583715))));
-}
-
-void mainImage(out vec4 fragColor, in vec2 fragCoord) {
-    vec2 size = iResolution.xy;
-    vec2 center = 0.5 * size;
-    vec2 offset = fragCoord - center;
-    float radius = length(offset);
-    float reach = 0.5 * length(size);
-    // Strongest a third of the way out, fading to nothing at the middle
-    // and at the edges, so the window's frame never wobbles.
-    float envelope = smoothstep(0.0, 0.18, radius / reach) * (1.0 - smoothstep(0.35, reachEnd(), radius / reach));
-    float ease = smoothstep(0.0, EASE_IN, iTime);
-    float phase = (radius - iTime * speedPx()) * TAU / wavelengthPx();
-    float height = sin(phase);
-    float slope = cos(phase);
-    vec2 dir = offset / max(radius, 1e-3);
-    vec2 moved = fragCoord + dir * height * amplitudePx() * envelope * ease;
-
-    vec4 s = texture(iChannel0, moved / size);
-    vec3 col = toLinear(s.rgb) * (1.0 + shade() * slope * envelope * ease);
-    vec3 srgb = toSrgb(col) + (ign(fragCoord + float(iFrame % 64) * 5.588238) - 0.5) / 255.0;
-    fragColor = vec4(clamp(srgb, 0.0, 1.0), s.a);
-}