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, 14 insertions, 9 deletions

diff --git a/src/macos.zig b/src/macos.zig
index 4d8f2883..0bad86ee 100644
--- a/src/macos.zig
+++ b/src/macos.zig
@@ -850,16 +850,18 @@ export fn pardes_should_quit() bool {
     return st.core.quit;
 }
 
-fn encodeSceneEffects(effects: animation.SceneEffect) u32 {
+// The Metal shell keeps its own CRT, ripple and glitch kernel: the bundled
+// passes of the GUI's post chain, as flags.
+fn encodeSceneEffects(post: *const pardes.config.Runtime.Post) u32 {
     var flags: u32 = 0;
-    if (effects.crt) flags |= scene_flag_crt;
-    if (effects.ripple) flags |= scene_flag_ripple;
-    if (effects.glitch) flags |= scene_flag_glitch;
+    if (post.has(.crt)) flags |= scene_flag_crt;
+    if (post.has(.ripple)) flags |= scene_flag_ripple;
+    if (post.has(.glitch)) flags |= scene_flag_glitch;
     return flags;
 }
 
 fn currentSceneFlags(st: *const State) u32 {
-    return encodeSceneEffects(st.core.settings.scene_effects);
+    return encodeSceneEffects(&st.core.settings.post);
 }
 
 fn advanceSceneClock(st: *State, elapsed_ns: u64) void {
@@ -2912,10 +2914,13 @@ test "pardes.h matches the Zig boundary" {
 
 test "scene effect flags and display clock are compact and independent" {
     const expectEqual = std.testing.expectEqual;
-    try expectEqual(@as(u32, 0), encodeSceneEffects(.{}));
-    try expectEqual(scene_flag_crt, encodeSceneEffects(.{ .crt = true }));
-    try expectEqual(scene_flag_ripple, encodeSceneEffects(.{ .ripple = true }));
-    try expectEqual(scene_flag_glitch, encodeSceneEffects(.{ .glitch = true }));
+    var post: pardes.config.Runtime.Post = .{};
+    try expectEqual(@as(u32, 0), encodeSceneEffects(&post));
+    _ = post.set(.crt, "", true);
+    try expectEqual(scene_flag_crt, encodeSceneEffects(&post));
+    _ = post.set(.ripple, "", true);
+    _ = post.set(.glitch, "", true);
+    try expectEqual(scene_flag_crt | scene_flag_ripple | scene_flag_glitch, encodeSceneEffects(&post));
     try expectEqual(
         scene_flag_crt | scene_flag_ripple | scene_flag_glitch,
         encodeSceneEffects(.{ .crt = true, .ripple = true, .glitch = true }),