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, 116 insertions, 0 deletions

diff --git a/shaders/prebuilt/post-ripple.frag.glsl b/shaders/prebuilt/post-ripple.frag.glsl
new file mode 100644
index 00000000..28059def
--- /dev/null
+++ b/shaders/prebuilt/post-ripple.frag.glsl
@@ -0,0 +1,116 @@
+#version 450
+// pardes's Shadertoy prefix (docs/render-pipeline.md §6), put before every
+// post pass: a bundled one in shaders/post/ at build time, a user's file at
+// run time. The uniform names, types and std140 order are ghostty 1.3.2's
+// (src/renderer/shaders/shadertoy_prefix.glsl), so a shader written for
+// ghostty runs here; only the bindings are SDL GPU's (a fragment shader's
+// textures in set 2, its uniform blocks in set 3). Y is down everywhere, as
+// on ghostty's Metal renderer: fragCoord, iChannel0's uv and the cursor
+// rectangles share one top-left space, and iCurrentCursor is (left x,
+// BOTTOM-edge y, width, height) in framebuffer pixels.
+
+layout(set = 3, binding = 0, std140) uniform Globals {
+    uniform vec3  iResolution;
+    uniform float iTime;
+    uniform float iTimeDelta;
+    uniform float iFrameRate;
+    uniform int   iFrame;
+    uniform float iChannelTime[4];
+    uniform vec3  iChannelResolution[4];
+    uniform vec4  iMouse;
+    uniform vec4  iDate;
+    uniform float iSampleRate;
+    uniform vec4  iCurrentCursor;
+    uniform vec4  iPreviousCursor;
+    uniform vec4  iCurrentCursorColor;
+    uniform vec4  iPreviousCursorColor;
+    uniform int   iCurrentCursorStyle;
+    uniform int   iPreviousCursorStyle;
+    uniform int   iCursorVisible;
+    uniform float iTimeCursorChange;
+    uniform float iTimeFocus;
+    uniform int iFocus;
+    uniform vec3  iPalette[256];
+    uniform vec3  iBackgroundColor;
+    uniform vec3  iForegroundColor;
+    uniform vec3  iCursorColor;
+    uniform vec3  iCursorText;
+    uniform vec3  iSelectionForegroundColor;
+    uniform vec3  iSelectionBackgroundColor;
+};
+
+// pardes's own: 1 when the window is opaque, so a pass cannot punch holes
+// in it through its alpha.
+layout(set = 3, binding = 1, std140) uniform PardesPost {
+    float pardesOpaque;
+};
+
+#define CURSORSTYLE_BLOCK        0
+#define CURSORSTYLE_BLOCK_HOLLOW 1
+#define CURSORSTYLE_BAR          2
+#define CURSORSTYLE_UNDERLINE    3
+#define CURSORSTYLE_LOCK         4
+
+layout(set = 2, binding = 0) uniform sampler2D iChannel0;
+
+layout(location = 0) out vec4 _fragColor;
+
+#define texture2D texture
+
+void mainImage(out vec4 fragColor, in vec2 fragCoord);
+void main() {
+    mainImage(_fragColor, gl_FragCoord.xy);
+    if (pardesOpaque > 0.5) _fragColor.a = 1.0;
+}
+
+// The shader's own lines count from 1, so glslc's errors name them.
+#line 1
+// 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; 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 WAVELENGTH_PX = 150.0;
+const float SPEED_PX = 55.0;        // outward, per second
+const float AMPLITUDE_PX = 2.2;
+const float SHADE = 0.035;          // light on a slope, linear
+const float EASE_IN = 0.5;          // seconds
+
+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, 0.95, radius / reach));
+    float ease = smoothstep(0.0, EASE_IN, iTime);
+    float phase = (radius - iTime * SPEED_PX) * TAU / WAVELENGTH_PX;
+    float height = sin(phase);
+    float slope = cos(phase);
+    vec2 dir = offset / max(radius, 1e-3);
+    vec2 moved = fragCoord + dir * height * AMPLITUDE_PX * 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);
+}