Post chain: Shadertoy passes compiled by glslc; Crt, Ripple and Glitch rewritten as Shadertoy files

Stage 9 of docs/render-pipeline.md. src/gui/Post.zig runs the chain over
the finished frame: each pass reads the one before, ping-pong textures
between, the last writes the window; an empty chain is the direct path.
The prefix (shaders/post/prefix.glsl) is ghostty's uniform block, name
for name and offset for offset (tested against a copy of its Uniforms, the
selection colours by their GLSL names), at SDL GPU's bindings, y down.

A user's file (Shader <path>) is compiled by glslc with compileGlsl's own
flags on a thread of its own, taken in at the next loop step; errors name
the file's own lines; a failed compile keeps the last good pipeline;
glslc missing is said once. The bundled passes compile with the build,
through the same prefix.

Crt, Ripple and Glitch are Shadertoy files, rewritten: no barrel (input is
identity, tested), everything in linear light and dithered, keyed to iTime.
scene_effects, crt.zig and crt.frag.glsl are gone; the core keeps no clock
for the chain. ShaderAnimation off|on|always drives redraw level A: the
chain alone over the retained frame (34 us CPU a redraw, measured).

Shared files touched: pardes.zig (nextWake loses the scene line,
disableSceneEffects empties the chain, two tests), builtins.zig (one switch
arm), ninep/ctl.zig (two switch arms), macos.zig (flags from the chain),
gui.zig. Not touched: Messages.zig, mouse.zig, detached/*, host_io, tty.

1 files changed, 60 insertions, 0 deletions

diff --git a/shaders/post/glitch.glsl b/shaders/post/glitch.glsl
new file mode 100644
index 00000000..ff9ebcb8
--- /dev/null
+++ b/shaders/post/glitch.glsl
@@ -0,0 +1,60 @@
+// Glitch: now and then the signal slips. 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.
+
+const float PERIOD = 2.4;           // seconds between bursts, on average
+const float BURST = 0.28;           // seconds a burst lasts
+const float STEP_HZ = 24.0;         // how often a burst re-tears
+const float SHIFT_PX = 14.0;
+const float SPLIT_PX = 2.5;
+const float DIP = 0.12;
+
+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 STEP_HZ during the burst; about one
+    // band in four tears.
+    float tick = floor(iTime * STEP_HZ);
+    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(0.72, 0.9, roll) * envelope;
+    float shift = (hash(vec2(tick, band + 11.0)) - 0.5) * 2.0 * SHIFT_PX * tear;
+    vec2 at = vec2(fragCoord.x + shift, fragCoord.y);
+    vec2 split = vec2(SPLIT_PX * 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);
+}