@baimingtao/lbs-agent 1.0.0

package/extensions/skills/builtin/creative/ascii-video/references/shaders.md

@@ -0,0 +1,683 @@
+# Shader Pipeline & Composable Effects
+
+在字符渲染之后、编码之前，对像素画布（`numpy uint8 array, shape (H,W,3)`）应用后处理效果。还涵盖 **pixel-level blend modes**、**feedback buffers** 以及 **ShaderChain** 合成器。
+
+> **另见:** composition.md (blend modes, tonemap) · effects.md · scenes.md · architecture.md · optimization.md · troubleshooting.md
+>
+> **Blend modes:** 关于 20 种 pixel blend modes 和 `blend_canvas()`，请参阅 `composition.md`。所有混合均使用 `blend_canvas(base, top, mode, opacity)`。
+
+## 设计理念
+
+shader pipeline 将原始的 ASCII 渲染转化为电影级的输出。该系统专为**可组合性**（composability）而设计——每个 shader、blend mode 和 feedback 转换都是独立的构建块。通过组合它们，可以利用少量的图元创造出无限的视觉多样性。
+
+选择能够强化氛围的 shader：
+- **复古终端**：CRT + 扫描线 + 颗粒 + 绿色/琥珀色调
+- **干净现代**：轻微的 bloom + 细微的晕影
+- **故障艺术**：强烈的色差 + 故障条 + 色彩摆动 + pixel sort
+- **电影感**：bloom + 晕影 + 颗粒 + color grade
+- **梦幻感**：强烈的 bloom + 柔焦 + 色彩摆动 + 低对比度
+- **粗粝/工业风**：高对比度 + 颗粒 + 扫描线 + 无 bloom
+- **迷幻风**：色彩摆动 + 色差 + 万花筒镜像 + 高饱和度 + 带有色相偏移的 feedback
+- **数据损坏**：pixel sort + data bend + block glitch + 色调分离
+- **递归/无限**：带缩放的 feedback buffer + screen blend + 色相偏移
+
+---
+
+## 像素级混合模式 (Pixel-Level Blend Modes)
+
+所有操作均在 float32 [0,1] 画布上进行以保证精度。请使用 `blend_canvas(base, top, mode, opacity)`，它会自动处理 uint8 与 float 之间的转换。
+
+### 可用模式 (Available Modes)
+
+```python
+BLEND_MODES = {
+    "normal":       lambda a, b: b,
+    "add":          lambda a, b: np.clip(a + b, 0, 1),
+    "subtract":     lambda a, b: np.clip(a - b, 0, 1),
+    "multiply":     lambda a, b: a * b,
+    "screen":       lambda a, b: 1 - (1-a)*(1-b),
+    "overlay":      # 2*a*b if a<0.5, else 1-2*(1-a)*(1-b)
+    "softlight":    lambda a, b: (1-2*b)*a*a + 2*b*a,
+    "hardlight":    # like overlay but keyed on b
+    "difference":   lambda a, b: abs(a - b),
+    "exclusion":    lambda a, b: a + b - 2*a*b,
+    "colordodge":   lambda a, b: a / (1-b),
+    "colorburn":    lambda a, b: 1 - (1-a)/b,
+    "linearlight":  lambda a, b: a + 2*b - 1,
+    "vividlight":   # burn if b<0.5, dodge if b>=0.5
+    "pin_light":    # min(a,2b) if b<0.5, max(a,2b-1) if b>=0.5
+    "hard_mix":     lambda a, b: 1 if a+b>=1 else 0,
+    "lighten":      lambda a, b: max(a, b),
+    "darken":       lambda a, b: min(a, b),
+    "grain_extract": lambda a, b: a - b + 0.5,
+    "grain_merge":  lambda a, b: a + b - 0.5,
+}
+```
+
+### 用法
+
+```python
+def blend_canvas(base, top, mode="normal", opacity=1.0):
+    """Blend two uint8 canvases (H,W,3) using a named blend mode + opacity."""
+    af = base.astype(np.float32) / 255.0
+    bf = top.astype(np.float32) / 255.0
+    result = BLEND_MODES[mode](af, bf)
+    if opacity < 1.0:
+        result = af * (1-opacity) + result * opacity
+    return np.clip(result * 255, 0, 255).astype(np.uint8)
+
+# Multi-layer compositing
+result = blend_canvas(base, layer_a, "screen", 0.7)
+result = blend_canvas(result, layer_b, "difference", 0.5)
+result = blend_canvas(result, layer_c, "multiply", 0.3)
+```
+
+### 创意组合 (Creative Combinations)
+
+- **Feedback + difference** = 迷幻的色彩演变（每一帧都与上一帧进行 XOR）
+- **Screen + screen** = 加性发光叠加
+- 在两种不同效果上使用 **Multiply** = 仅显示两者同时具有亮度的部分（交集）
+- 在两层之间使用 **Exclusion** = 在它们存在差异的地方创建互补图案
+- **Color dodge/burn** = 在重叠区域进行极端的对比度增强
+- **Hard mix** = 在相交处将所有内容简化为纯黑/纯白/纯色
+
+---
+
+## Feedback Buffer
+
+递归时间效果：第 N-1 帧经过衰减和可选的空间变换后反馈到第 N 帧。可创建拖尾、回声、涂抹、缩放隧道、旋转 feedback 以及彩虹拖尾。
+
+```python
+class FeedbackBuffer:
+    def __init__(self):
+        self.buf = None  # previous frame (float32, 0-1)
+    
+    def apply(self, canvas, decay=0.85, blend="screen", opacity=0.5,
+              transform=None, transform_amt=0.02, hue_shift=0.0):
+        """Mix current frame with decayed/transformed previous frame.
+        
+        Args:
+            canvas: current frame (uint8 H,W,3)
+            decay: how fast old frame fades (0=instant, 1=permanent)
+            blend: blend mode for mixing feedback
+            opacity: strength of feedback mix
+            transform: None, "zoom", "shrink", "rotate_cw", "rotate_ccw",
+                       "shift_up", "shift_down", "mirror_h"
+            transform_amt: strength of spatial transform per frame
+            hue_shift: rotate hue of feedback buffer each frame (0-1)
+        """
+```
+
+### Feedback 预设
+
+```python
+# Infinite zoom tunnel
+fb_cfg = {"decay": 0.8, "blend": "screen", "opacity": 0.4,
+          "transform": "zoom", "transform_amt": 0.015}
+
+# Rainbow trails (psychedelic)
+fb_cfg = {"decay": 0.7, "blend": "screen", "opacity": 0.3,
+          "transform": "zoom", "transform_amt": 0.01, "hue_shift": 0.02}
+
+# Ghostly echo (horror)
+fb_cfg = {"decay": 0.9, "blend": "add", "opacity": 0.15,
+          "transform": "shift_up", "transform_amt": 0.01}
+
+# Kaleidoscopic recursion
+fb_cfg = {"decay": 0.75, "blend": "screen", "opacity": 0.35,
+          "transform": "rotate_cw", "transform_amt": 0.005, "hue_shift": 0.01}
+
+# Color evolution (abstract)
+fb_cfg = {"decay": 0.8, "blend": "difference", "opacity": 0.4, "hue_shift": 0.03}
+
+# Multiplied depth
+fb_cfg = {"decay": 0.65, "blend": "multiply", "opacity": 0.3, "transform": "mirror_h"}
+
+# Rising heat haze
+fb_cfg = {"decay": 0.5, "blend": "add", "opacity": 0.2,
+          "transform": "shift_up", "transform_amt": 0.02}
+```
+
+---
+
+## ShaderChain
+
+可组合的 shader pipeline。构建具有参数的命名 shader 链。顺序很重要——shader 会按顺序依次应用于画布。
+
+```python
+class ShaderChain:
+    """Composable shader pipeline.
+    
+    Usage:
+        chain = ShaderChain()
+        chain.add("bloom", thr=120)
+        chain.add("chromatic", amt=5)
+        chain.add("kaleidoscope", folds=6)
+        chain.add("vignette", s=0.2)
+        chain.add("grain", amt=12)
+        canvas = chain.apply(canvas, f=features, t=time)
+    """
+    def __init__(self):
+        self.steps = []
+
+    def add(self, shader_name, **kwargs):
+        self.steps.append((shader_name, kwargs))
+        return self  # chainable
+
+    def apply(self, canvas, f=None, t=0):
+        if f is None: f = {}
+        for name, kwargs in self.steps:
+            canvas = _apply_shader_step(canvas, name, kwargs, f, t)
+        return canvas
+```
+
+### `_apply_shader_step()` — 完整的分发函数
+
+将 shader 名称路由到具体实现。某些 shader 具有**音频反应缩放**——分发函数会读取 `f["bdecay"]` 和 `f["rms"]`，以在节拍上对参数进行调制。
+
+```python
+def _apply_shader_step(canvas, name, kwargs, f, t):
+    """Dispatch a single shader by name with kwargs.
+    
+    Args:
+        canvas: uint8 (H,W,3) pixel array
+        name: shader key string (e.g. "bloom", "chromatic")
+        kwargs: dict of shader parameters
+        f: audio features dict (keys: bdecay, rms, sub, etc.)
+        t: current time in seconds (float)
+    Returns:
+        canvas: uint8 (H,W,3) — processed
+    """
+    bd = f.get("bdecay", 0)    # beat decay (0-1, high on beat)
+    rms = f.get("rms", 0.3)   # audio energy (0-1)
+
+    # --- Geometry ---
+    if name == "crt":
+        return sh_crt(canvas, kwargs.get("strength", 0.05))
+    elif name == "pixelate":
+        return sh_pixelate(canvas, kwargs.get("block", 4))
+    elif name == "wave_distort":
+        return sh_wave_distort(canvas, t,
+            kwargs.get("freq", 0.02), kwargs.get("amp", 8), kwargs.get("axis", "x"))
+    elif name == "kaleidoscope":
+        return sh_kaleidoscope(canvas.copy(), kwargs.get("folds", 6))
+    elif name == "mirror_h":
+        return sh_mirror_h(canvas.copy())
+    elif name == "mirror_v":
+        return sh_mirror_v(canvas.copy())
+    elif name == "mirror_quad":
+        return sh_mirror_quad(canvas.copy())
+    elif name == "mirror_diag":
+        return sh_mirror_diag(canvas.copy())
+
+    # --- Channel ---
+    elif name == "chromatic":
+        base = kwargs.get("amt", 3)
+        return sh_chromatic(canvas, max(1, int(base * (0.4 + bd * 0.8))))
+    elif name == "channel_shift":
+        return sh_channel_shift(canvas,
+            kwargs.get("r", (0,0)), kwargs.get("g", (0,0)), kwargs.get("b", (0,0)))
+    elif name == "channel_swap":
+        return sh_channel_swap(canvas, kwargs.get("order", (2,1,0)))
+    elif name == "rgb_split_radial":
+        return sh_rgb_split_radial(canvas, kwargs.get("strength", 5))
+
+    # --- Color ---
+    elif name == "invert":
+        return sh_invert(canvas)
+    elif name == "posterize":
+        return sh_posterize(canvas, kwargs.get("levels", 4))
+    elif name == "threshold":
+        return sh_threshold(canvas, kwargs.get("thr", 128))
+    elif name == "solarize":
+        return sh_solarize(canvas, kwargs.get("threshold", 128))
+    elif name == "hue_rotate":
+        return sh_hue_rotate(canvas, kwargs.get("amount", 0.1))
+    elif name == "saturation":
+        return sh_saturation(canvas, kwargs.get("factor", 1.5))
+    elif name == "color_grade":
+        return sh_color_grade(canvas, kwargs.get("tint", (1,1,1)))
+    elif name == "color_wobble":
+        return sh_color_wobble(canvas, t, kwargs.get("amt", 0.3) * (0.5 + rms * 0.8))
+    elif name == "color_ramp":
+        return sh_color_ramp(canvas, kwargs.get("ramp", [(0,0,0),(255,255,255)]))
+
+    # --- Glow / Blur ---
+    elif name == "bloom":
+        return sh_bloom(canvas, kwargs.get("thr", 130))
+    elif name == "edge_glow":
+        return sh_edge_glow(canvas, kwargs.get("hue", 0.5))
+    elif name == "soft_focus":
+        return sh_soft_focus(canvas, kwargs.get("strength", 0.3))
+    elif name == "radial_blur":
+        return sh_radial_blur(canvas, kwargs.get("strength", 0.03))
+
+    # --- Noise ---
+    elif name == "grain":
+        return sh_grain(canvas, int(kwargs.get("amt", 10) * (0.5 + rms * 0.8)))
+    elif name == "static":
+        return sh_static_noise(canvas, kwargs.get("density", 0.05), kwargs.get("color", True))
+
+    # --- Lines / Patterns ---
+    elif name == "scanlines":
+        return sh_scanlines(canvas, kwargs.get("intensity", 0.08), kwargs.get("spacing", 3))
+    elif name == "halftone":
+        return sh_halftone(canvas, kwargs.get("dot_size", 6))
+
+    # --- Tone ---
+    elif name == "vignette":
+        return sh_vignette(canvas, kwargs.get("s", 0.22))
+    elif name == "contrast":
+        return sh_contrast(canvas, kwargs.get("factor", 1.3))
+    elif name == "gamma":
+        return sh_gamma(canvas, kwargs.get("gamma", 1.5))
+    elif name == "levels":
+        return sh_levels(canvas,
+            kwargs.get("black", 0), kwargs.get("white", 255), kwargs.get("midtone", 1.0))
+    elif name == "brightness":
+        return sh_brightness(canvas, kwargs.get("factor", 1.5))
+
+    # --- Glitch / Data ---
+    elif name == "glitch_bands":
+        return sh_glitch_bands(canvas, f)
+    elif name == "block_glitch":
+        return sh_block_glitch(canvas, kwargs.get("n_blocks", 8), kwargs.get("max_size", 40))
+    elif name == "pixel_sort":
+        return sh_pixel_sort(canvas, kwargs.get("threshold", 100), kwargs.get("direction", "h"))
+    elif name == "data_bend":
+        return sh_data_bend(canvas, kwargs.get("offset", 1000), kwargs.get("chunk", 500))
+
+    else:
+        return canvas  # unknown shader — passthrough
+```
+
+### 音频反应 Shader (Audio-Reactive Shaders)
+
+三个 shader 会根据音频特征缩放其参数：
+
+| Shader | 响应源 | 效果 |
+|--------|------------|--------|
+| `chromatic` | `bdecay` | `amt * (0.4 + bdecay * 0.8)` —— 色差在节拍上增强 |
+| `color_wobble` | `rms` | `amt * (0.5 + rms * 0.8)` —— 摆动强度跟随能量变化 |
+| `grain` | `rms` | `amt * (0.5 + rms * 0.8)` —— 响亮部分的颗粒更粗糙 |
+| `glitch_bands` | `bdecay`, `sub` | 条带数量和位移随节拍能量而缩放 |
+
+要使任何 shader 具备节拍反应能力，请在分发函数中缩放其参数：`base_val * (low + bd * range)`。
+
+---
+
+## 完整的 Shader 目录 (Full Shader Catalog)
+
+### 几何 Shader (Geometry Shaders)
+
+| Shader | 主要参数 | 说明 |
+|--------|-----------|-------------|
+| `crt` | `strength=0.05` | CRT 桶形畸变（缓存的 remap） |
+| `pixelate` | `block=4` | 降低有效分辨率 |
+| `wave_distort` | `freq, amp, axis` | 正弦波形的行/列位移 |
+| `kaleidoscope` | `folds=6` | 通过极坐标重映射实现径向对称 |
+| `mirror_h` | — | 水平镜像 |
+| `mirror_v` | — | 垂直镜像 |
+| `mirror_quad` | — | 4 重镜像 |
+| `mirror_diag` | — | 对角线镜像 |
+
+### 通道操作 (Channel Manipulation)
+
+| Shader | 主要参数 | 说明 |
+|--------|-----------|-------------|
+| `chromatic` | `amt=3` | R/B 通道水平偏移（节拍反应） |
+| `channel_shift` | `r=(sx,sy), g, b` | 独立按通道进行 x,y 偏移 |
+| `channel_swap` | `order=(2,1,0)` | 重排 RGB 通道 (BGR, GRB 等) |
+| `rgb_split_radial` | `strength=5` | 从中心向外辐射的色差 |
+
+### 颜色操作 (Color Manipulation)
+
+| Shader | 主要参数 | 说明 |
+|--------|-----------|-------------|
+| `invert` | — | 反相所有颜色 |
+| `posterize` | `levels=4` | 将颜色深度降低至 N 个级别 |
+| `threshold` | `thr=128` | 二值化为黑白 |
+| `solarize` | `threshold=128` | 反相超过阈值的像素 |
+| `hue_rotate` | `amount=0.1` | 将所有色相旋转指定数值 (0-1) |
+| `saturation` | `factor=1.5` | 缩放饱和度 (>1=更高, <1=更低) |
+| `color_grade` | `tint=(r,g,b)` | 按通道的乘数 |
+| `color_wobble` | `amt=0.3` | 随时间变化的按通道正弦调制 |
+| `color_ramp` | `ramp=[(R,G,B),...]` | 将亮度映射到自定义的颜色渐变 |
+
+### 发光 / 模糊 (Glow / Blur)
+
+| Shader | 主要参数 | 说明 |
+|--------|-----------|-------------|
+| `bloom` | `thr=130` | 亮区发光（4倍下采样 + 方框模糊） |
+| `edge_glow` | `hue=0.5` | 检测边缘，添加彩色叠加层 |
+| `soft_focus` | `strength=0.3` | 与模糊版本混合 |
+| `radial_blur` | `strength=0.03` | 从中心向外的缩放模糊 |
+
+### 噪点 / 颗粒 (Noise / Grain)
+
+| Shader | 主要参数 | 说明 |
+|--------|-----------|-------------|
+| `grain` | `amt=10` | 2倍下采样的胶片颗粒（节拍反应） |
+| `static` | `density=0.05, color=True` | 随机像素噪点（电视雪花点） |
+
+### 线条 / 图案 (Lines / Patterns)
+
+| Shader | 主要参数 | 说明 |
+|--------|-----------|-------------|
+| `scanlines` | `intensity=0.08, spacing=3` | 使每第 N 行变暗 |
+| `halftone` | `dot_size=6` | 半色调点阵图案叠加 |
+
+### 色调 (Tone)
+
+| Shader | 主要参数 | 说明 |
+|--------|-----------|-------------|
+| `vignette` | `s=0.22` | 边缘变暗（缓存的距离场） |
+| `contrast` | `factor=1.3` | 围绕中点 128 调整对比度 |
+| `gamma` | `gamma=1.5` | Gamma 校正 (>1=中间调更亮) |
+| `levels` | `black, white, midtone` | 色阶调整（Photoshop 风格） |
+| `brightness` | `factor=1.5` | 全局亮度乘数 |
+
+### 故障 / 数据 (Glitch / Data)
+
+| Shader | 主要参数 | 说明 |
+|--------|-----------|-------------|
+| `glitch_bands` | (使用 `f`) | 节拍反应的水平行位移 |
+| `block_glitch` | `n_blocks=8, max_size=40` | 随机矩形块位移 |
+| `pixel_sort` | `threshold=100, direction="h"` | 按亮度在行/列中排序像素 |
+| `data_bend` | `offset, chunk` | 原始字节位移（datamoshing 故障艺术） |
+
+---
+
+## Shader 实现 (Shader Implementations)
+
+每个 shader 函数都接收一个画布（`uint8 H,W,3`）并返回一个相同形状的画布。命名约定为 `sh_<name>`。构建坐标重映射表的几何 shader 应该**缓存**它们，因为该表仅取决于分辨率和参数，而不取决于帧内容。
+
+### 辅助函数 (Helpers)
+
+操作色调/饱和度的 shader 需要向量化的 HSV 转换：
+
+```python
+def rgb2hsv(r, g, b):
+    """Vectorized RGB (0-255 uint8) -> HSV (float32 0-1)."""
+    rf = r.astype(np.float32) / 255.0
+    gf = g.astype(np.float32) / 255.0
+    bf = b.astype(np.float32) / 255.0
+    cmax = np.maximum(np.maximum(rf, gf), bf)
+    cmin = np.minimum(np.minimum(rf, gf), bf)
+    delta = cmax - cmin + 1e-10
+    h = np.zeros_like(rf)
+    m = cmax == rf; h[m] = ((gf[m] - bf[m]) / delta[m]) % 6
+    m = cmax == gf; h[m] = (bf[m] - rf[m]) / delta[m] + 2
+    m = cmax == bf; h[m] = (rf[m] - gf[m]) / delta[m] + 4
+    h = h / 6.0 % 1.0
+    s = np.where(cmax > 0, delta / (cmax + 1e-10), 0)
+    return h, s, cmax
+
+def hsv2rgb(h, s, v):
+    """Vectorized HSV->RGB. h,s,v are numpy float32 arrays."""
+    h = h % 1.0
+    c = v * s; x = c * (1 - np.abs((h * 6) % 2 - 1)); m = v - c
+    r = np.zeros_like(h); g = np.zeros_like(h); b = np.zeros_like(h)
+    mask = h < 1/6;            r[mask]=c[mask]; g[mask]=x[mask]
+    mask = (h>=1/6)&(h<2/6);   r[mask]=x[mask]; g[mask]=c[mask]
+    mask = (h>=2/6)&(h<3/6);   g[mask]=c[mask]; b[mask]=x[mask]
+    mask = (h>=3/6)&(h<4/6);   g[mask]=x[mask]; b[mask]=c[mask]
+    mask = (h>=4/6)&(h<5/6);   r[mask]=x[mask]; b[mask]=c[mask]
+    mask = h >= 5/6;            r[mask]=c[mask]; b[mask]=x[mask]
+    R = np.clip((r+m)*255, 0, 255).astype(np.uint8)
+    G = np.clip((g+m)*255, 0, 255).astype(np.uint8)
+    B = np.clip((b+m)*255, 0, 255).astype(np.uint8)
+    return R, G, B
+
+def mkc(R, G, B, rows, cols):
+    """Stack R,G,B uint8 arrays into (rows,cols,3) canvas."""
+    o = np.zeros((rows, cols, 3), dtype=np.uint8)
+    o[:,:,0] = R; o[:,:,1] = G; o[:,:,2] = B
+    return o
+```
+
+---
+
+### 几何 Shader (Geometry Shaders)
+
+#### CRT 桶形畸变 (CRT Barrel Distortion)
+缓存坐标重映射——它逐帧从不改变：
+```python
+_crt_cache = {}
+def sh_crt(c, strength=0.05):
+    k = (c.shape[0], c.shape[1], round(strength, 3))
+    if k not in _crt_cache:
+        h, w = c.shape[:2]; cy, cx = h/2, w/2
+        Y = np.arange(h, dtype=np.float32)[:, None]
+        X = np.arange(w, dtype=np.float32)[None, :]
+        ny = (Y - cy) / cy; nx = (X - cx) / cx
+        r2 = nx**2 + ny**2
+        factor = 1 + strength * r2
+        sx = np.clip((nx * factor * cx + cx), 0, w-1).astype(np.int32)
+        sy = np.clip((ny * factor * cy + cy), 0, h-1).astype(np.int32)
+        _crt_cache[k] = (sy, sx)
+    sy, sx = _crt_cache[k]
+    return c[sy, sx]
+```
+
+#### 像素化 (Pixelate)
+```python
+def sh_pixelate(c, block=4):
+    """Reduce effective resolution."""
+    sm = c[::block, ::block]
+    return np.repeat(np.repeat(sm, block, axis=0), block, axis=1)[:c.shape[0], :c.shape[1]]
+```
+
+#### 波浪扭曲 (Wave Distort)
+```python
+def sh_wave_distort(c, t, freq=0.02, amp=8, axis="x"):
+    """Sinusoidal row/column displacement. Uses time t for animation."""
+    h, w = c.shape[:2]
+    out = c.copy()
+    if axis == "x":
+        for y in range(h):
+            shift = int(amp * math.sin(y * freq + t * 3))
+            out[y] = np.roll(c[y], shift, axis=0)
+    else:
+        for x in range(w):
+            shift = int(amp * math.sin(x * freq + t * 3))
+            out[:, x] = np.roll(c[:, x], shift, axis=0)
+    return out
+```
+
+#### 位移贴图 (Displacement Map)
+```python
+def sh_displacement_map(c, dx_map, dy_map, strength=10):
+    """Displace pixels using float32 displacement maps (same HxW as c).
+    dx_map/dy_map: positive = shift right/down."""
+    h, w = c.shape[:2]
+    Y = np.arange(h)[:, None]; X = np.arange(w)[None, :]
+    ny = np.clip((Y + (dy_map * strength).astype(int)), 0, h-1)
+    nx = np.clip((X + (dx_map * strength).astype(int)), 0, w-1)
+    return c[ny, nx]
+```
+
+#### 万花筒 (Kaleidoscope)
+```python
+def sh_kaleidoscope(c, folds=6):
+    """Radial symmetry by polar coordinate remapping."""
+    h, w = c.shape[:2]; cy, cx = h//2, w//2
+    Y = np.arange(h, dtype=np.float32)[:, None] - cy
+    X = np.arange(w, dtype=np.float32)[None, :] - cx
+    angle = np.arctan2(Y, X)
+    dist = np.sqrt(X**2 + Y**2)
+    wedge = 2 * np.pi / folds
+    folded_angle = np.abs((angle % wedge) - wedge/2)
+    ny = np.clip((cy + dist * np.sin(folded_angle)).astype(int), 0, h-1)
+    nx = np.clip((cx + dist * np.cos(folded_angle)).astype(int), 0, w-1)
+    return c[ny, nx]
+```
+
+#### 镜像变体 (Mirror Variants)
+```python
+def sh_mirror_h(c):
+    """Horizontal mirror — left half reflected to right."""
+    w = c.shape[1]; c[:, w//2:] = c[:, :w//2][:, ::-1]; return c
+
+def sh_mirror_v(c):
+    """Vertical mirror — top half reflected to bottom."""
+    h = c.shape[0]; c[h//2:, :] = c[:h//2, :][::-1, :]; return c
+
+def sh_mirror_quad(c):
+    """4-fold mirror — top-left quadrant reflected to all four."""
+    h, w = c.shape[:2]; hh, hw = h//2, w//2
+    tl = c[:hh, :hw].copy()
+    c[:hh, hw:hw+tl.shape[1]] = tl[:, ::-1]
+    c[hh:hh+tl.shape[0], :hw] = tl[::-1, :]
+    c[hh:hh+tl.shape[0], hw:hw+tl.shape[1]] = tl[::-1, ::-1]
+    return c
+
+def sh_mirror_diag(c):
+    """Diagonal mirror — top-left triangle reflected."""
+    h, w = c.shape[:2]
+    for y in range(h):
+        x_cut = int(w * y / h)
+        if x_cut > 0 and x_cut < w:
+            c[y, x_cut:] = c[y, :x_cut+1][::-1][:w-x_cut]
+    return c
+```
+
+> **注意：** Mirror shader 会进行原地修改。分发函数传递了 `canvas.copy()` 以防止损坏原始画布。
+
+---
+
+### 通道操作 Shader (Channel Manipulation Shaders)
+
+#### 色差 (Chromatic Aberration)
+```python
+def sh_chromatic(c, amt=3):
+    """R/B channel horizontal shift. Beat-reactive in dispatch (amt scaled by bdecay)."""
+    if amt < 1: return c
+    a = int(amt)
+    o = c.copy()
+    o[:, a:, 0] = c[:, :-a, 0]   # red shifts right
+    o[:, :-a, 2] = c[:, a:, 2]   # blue shifts left
+    return o
+```
+
+#### 通道偏移 (Channel Shift)
+```python
+def sh_channel_shift(c, r_shift=(0,0), g_shift=(0,0), b_shift=(0,0)):
+    """Independent per-channel x,y shifting."""
+    o = c.copy()
+    for ch_i, (sx, sy) in enumerate([r_shift, g_shift, b_shift]):
+        if sx != 0: o[:,:,ch_i] = np.roll(c[:,:,ch_i], sx, axis=1)
+        if sy != 0: o[:,:,ch_i] = np.roll(o[:,:,ch_i], sy, axis=0)
+    return o
+```
+
+#### 通道交换 (Channel Swap)
+```python
+def sh_channel_swap(c, order=(2,1,0)):
+    """Reorder RGB channels. (2,1,0)=BGR, (1,0,2)=GRB, etc."""
+    return c[:, :, list(order)]
+```
+
+#### 径向 RGB 分离 (RGB Split Radial)
+```python
+def sh_rgb_split_radial(c, strength=5):
+    """Chromatic aberration radiating from center — stronger at edges."""
+    h, w = c.shape[:2]; cy, cx = h//2, w//2
+    Y = np.arange(h, dtype=np.float32)[:, None]
+    X = np.arange(w, dtype=np.float32)[None, :]
+    dist = np.sqrt((Y-cy)**2 + (X-cx)**2)
+    max_dist = np.sqrt(cy**2 + cx**2)
+    factor = dist / max_dist * strength
+    dy = ((Y-cy) / (dist+1) * factor).astype(int)
+    dx = ((X-cx) / (dist+1) * factor).astype(int)
+    out = c.copy()
+    ry = np.clip(Y.astype(int)+dy, 0, h-1); rx = np.clip(X.astype(int)+dx, 0, w-1)
+    out[:,:,0] = c[ry, rx, 0]  # red shifts outward
+    by = np.clip(Y.astype(int)-dy, 0, h-1); bx = np.clip(X.astype(int)-dx, 0, w-1)
+    out[:,:,2] = c[by, bx, 2]  # blue shifts inward
+    return out
+```
+
+---
+
+### 颜色操作 Shader (Color Manipulation Shaders)
+
+#### 反相 (Invert)
+```python
+def sh_invert(c):
+    return 255 - c
+```
+
+#### 色调分离 (Posterize)
+```python
+def sh_posterize(c, levels=4):
+    """Reduce color depth to N levels per channel."""
+    step = 256.0 / levels
+    return (np.floor(c.astype(np.float32) / step) * step).astype(np.uint8)
+```
+
+#### 阈值 (Threshold)
+```python
+def sh_threshold(c, thr=128):
+    """Binary black/white at threshold."""
+    gray = c.astype(np.float32).mean(axis=2)
+    out = np.zeros_like(c); out[gray > thr] = 255
+    return out
+```
+
+#### 日光化 (Solarize)
+```python
+def sh_solarize(c, threshold=128):
+    """Invert pixels above threshold — classic darkroom effect."""
+    o = c.copy(); mask = c > threshold; o[mask] = 255 - c[mask]
+    return o
+```
+
+#### 色相旋转 (Hue Rotate)
+```python
+def sh_hue_rotate(c, amount=0.1):
+    """Rotate all hues by amount (0-1)."""
+    h, s, v = rgb2hsv(c[:,:,0], c[:,:,1], c[:,:,2])
+    h = (h + amount) % 1.0
+    R, G, B = hsv2rgb(h, s, v)
+    return mkc(R, G, B, c.shape[0], c.shape[1])
+```
+
+#### 饱和度 (Saturation)
+```python
+def sh_saturation(c, factor=1.5):
+    """Adjust saturation. >1=more saturated, <1=desaturated."""
+    h, s, v = rgb2hsv(c[:,:,0], c[:,:,1], c[:,:,2])
+    s = np.clip(s * factor, 0, 1)
+    R, G, B = hsv2rgb(h, s, v)
+    return mkc(R, G, B, c.shape[0], c.shape[1])
+```
+
+#### 颜色分级 (Color Grade)
+```python
+def sh_color_grade(c, tint):
+    """Per-channel multiplier. tint=(r_mul, g_mul, b_mul)."""
+    o = c.astype(np.float32)
+    o[:,:,0] *= tint[0]; o[:,:,1] *= tint[1]; o[:,:,2] *= tint[2]
+    return np.clip(o, 0, 255).astype(np.uint8)
+```
+
+#### 色彩摆动 (Color Wobble)
+```python
+def sh_color_wobble(c, t, amt=0.3):
+    """Time-varying per-channel sine modulation. Audio-reactive in dispatch (amt scaled by rms)."""
+    o = c.astype(np.float32)
+    o[:,:,0] *= 1.0 + amt * math.sin(t * 5.0)
+    o[:,:,1] *= 1.0 + amt * math.sin(t * 5.0 + 2.09)
+    o[:,:,2] *= 1.0 + amt * math.sin(t * 5.0 + 4.19)
+    return np.clip(o, 0, 255).astype(np.uint8)
+```
+
+#### 色彩渐变 (Color Ramp)
+```python
+def sh_color_ramp(c, ramp_colors):
+    """Map luminance to a custom color gradient.
+    ramp_colors = list of (R,G,B) tuples, evenly spaced from dark to bright."""
+    gray = c.astype(np.float32).mean(axis=2) / 255.0
+    n = len(ramp_colors)
+    idx =