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, 5 insertions, 45 deletions

diff --git a/src/macos/Sources/PardesView.swift b/src/macos/Sources/PardesView.swift
index 70f467e3..8ba9c84b 100644
--- a/src/macos/Sources/PardesView.swift
+++ b/src/macos/Sources/PardesView.swift
@@ -684,7 +684,7 @@ final class PardesView: NSView {
     private var latchedButton: pardes_mouse_button_e?
     private var latchedCell: GridPoint?
     /// Last physical point delivered by AppKit and its mapping through the
-    /// accepted scene. Ripple/glitch can move a source cell under a stationary
+    /// accepted scene. The CRT's barrel moves a source cell under a stationary
     /// hand, so successful scene presentations reconcile this point again.
     private var pointerPoint: CGPoint?
     private var pointerCell: GridPoint?
diff --git a/src/macos/Sources/ScenePostprocessor.swift b/src/macos/Sources/ScenePostprocessor.swift
index cf7892b3..41d54e34 100644
--- a/src/macos/Sources/ScenePostprocessor.swift
+++ b/src/macos/Sources/ScenePostprocessor.swift
@@ -205,11 +205,9 @@ final class ScenePostprocessor {
 
         if scene.flags != 0 {
             let crt: Float = scene.flags & UInt32(PARDES_SCENE_CRT) != 0 ? 1 : 0
-            let ripple: Float = scene.flags & UInt32(PARDES_SCENE_RIPPLE) != 0 ? 1 : 0
-            let glitch: Float = scene.flags & UInt32(PARDES_SCENE_GLITCH) != 0 ? 1 : 0
             // SDL samples the scene with CLAMP_TO_EDGE. A finite Core Image
             // instead supplies transparent black outside its extent, which
-            // would make ripple/glitch tear dark seams at the window edge.
+            // would tear dark seams at the window edge.
             // Clamp the input only; the kernel still emits true black before
             // sampling when a destination lies outside the CRT tube.
             let sceneInput = filtered.clampedToExtent()
@@ -218,7 +216,7 @@ final class ScenePostprocessor {
                 roiCallback: { _, _ in extent },
                 arguments: [
                     sceneInput, scene.time_seconds, Float(scene.frame),
-                    crt, ripple, glitch,
+                    crt,
                     CIVector(x: extent.width, y: extent.height),
                     CIVector(x: extent.minX, y: extent.minY),
                 ])
@@ -291,7 +289,7 @@ final class ScenePostprocessor {
 
     /// The scene kernel is a destination-to-source mapping. Pointer input must
     /// apply that same mapping before the grid and its panel tracks see a cell,
-    /// otherwise a visible word under ripple/glitch is not the word Look gets.
+    /// otherwise a visible word under the barrel is not the word Look gets.
     static func sourcePoint(
         _ point: CGPoint,
         size: CGSize,
@@ -311,27 +309,8 @@ final class ScenePostprocessor {
         ccY *= barrel
         uvX = ccX * 0.5 + 0.5
         uvY = ccY * 0.5 + 0.5
-        // Only CRT has a black tube. Ripple/glitch without CRT sample through
-        // the texture's clamp-to-edge policy and remain clickable there.
+        // The CRT's black tube has no cell under it.
         if crt > 0.5 && min(min(uvX, uvY), min(1 - uvX, 1 - uvY)) <= 0 { return nil }
-
-        let time = scene.time_seconds
-        if scene.flags & UInt32(PARDES_SCENE_RIPPLE) != 0 {
-            let centeredX = uvX - 0.5
-            let centeredY = uvY - 0.5
-            let radius = sqrtf(centeredX * centeredX + centeredY * centeredY)
-            let envelope = 1 - smoothstep(0.04, 0.72, radius)
-            let wave = sinf(radius * 42 - time * 5.2)
-            let travel = wave * envelope * 0.0032 / max(radius, 0.00001)
-            uvX += centeredX * travel
-            uvY += centeredY * travel
-        }
-        if scene.flags & UInt32(PARDES_SCENE_GLITCH) != 0 {
-            let band = floorf(uvY * 96)
-            let seed = noise(band, floorf(time * 13))
-            let tear = smoothstep(0.955, 1, seed)
-            uvX += (noise(seed, band) - 0.5) * tear * 0.020
-        }
         uvX = min(max(uvX, 0), max(0, 1 - 1 / Float(size.width)))
         uvY = min(max(uvY, 0), max(0, 1 - 1 / Float(size.height)))
         return CGPoint(
@@ -339,23 +318,4 @@ final class ScenePostprocessor {
             y: CGFloat(1 - uvY) * size.height)
     }
 
-    private static func smoothstep(_ edge0: Float, _ edge1: Float, _ x: Float) -> Float {
-        let t = min(max((x - edge0) / (edge1 - edge0), 0), 1)
-        return t * t * (3 - 2 * t)
-    }
-
-    /// Scalar spelling of pardesNoise in crt.ci.metal. Float arithmetic is
-    /// deliberate: the shader's band decision must not move at a Double round.
-    private static func noise(_ x: Float, _ y: Float) -> Float {
-        var qx = fract(x * 0.1031)
-        var qy = fract(y * 0.1031)
-        var qz = fract(x * 0.1031)
-        let d = qx * (qy + 33.33) + qy * (qz + 33.33) + qz * (qx + 33.33)
-        qx += d
-        qy += d
-        qz += d
-        return fract((qx + qy) * qz)
-    }
-
-    private static func fract(_ x: Float) -> Float { x - floorf(x) }
 }