@vibesdotdev/runnable 0.0.0-stage → 1.0.0-rc.1

package/dist/svelte/viz/mfd/renderer/shaders.js

@@ -0,0 +1,837 @@
+// ═══════════════════════════════════════════════════════════════
+// NERV MFD — Shader Compilation & Common GLSL
+// ═══════════════════════════════════════════════════════════════
+export function compileShader(gl, type, source) {
+    const shader = gl.createShader(type);
+    gl.shaderSource(shader, source);
+    gl.compileShader(shader);
+    if (!gl.getShaderParameter(shader, gl.COMPILE_STATUS)) {
+        const log = gl.getShaderInfoLog(shader);
+        gl.deleteShader(shader);
+        throw new Error(`Shader compile: ${log}`);
+    }
+    return shader;
+}
+export function linkProgram(gl, vertSrc, fragSrc) {
+    const vs = compileShader(gl, gl.VERTEX_SHADER, vertSrc);
+    const fs = compileShader(gl, gl.FRAGMENT_SHADER, fragSrc);
+    const prog = gl.createProgram();
+    gl.attachShader(prog, vs);
+    gl.attachShader(prog, fs);
+    gl.bindAttribLocation(prog, 0, 'a_position');
+    gl.linkProgram(prog);
+    if (!gl.getProgramParameter(prog, gl.LINK_STATUS)) {
+        const log = gl.getProgramInfoLog(prog);
+        gl.deleteProgram(prog);
+        throw new Error(`Program link: ${log}`);
+    }
+    gl.deleteShader(vs);
+    gl.deleteShader(fs);
+    return prog;
+}
+export function getUniforms(gl, program, names) {
+    const map = new Map();
+    for (const n of names) {
+        map.set(n, gl.getUniformLocation(program, n));
+    }
+    return map;
+}
+// ─── Shared GLSL Blocks ──────────────────────────────────────────────────
+export const QUAD_VERT = /*glsl*/ `#version 300 es
+precision highp float;
+in vec2 a_position;
+out vec2 v_uv;
+void main() {
+  v_uv = a_position * 0.5 + 0.5;
+  gl_Position = vec4(a_position, 0.0, 1.0);
+}
+`;
+export const FRAG_COMMON = /*glsl*/ `#version 300 es
+precision highp float;
+
+in vec2 v_uv;
+out vec4 fragColor;
+
+uniform float     u_time;
+uniform vec2      u_resolution;
+uniform vec3      u_color;
+uniform vec3      u_accent;
+uniform vec3      u_dim;
+uniform vec3      u_grid;
+uniform vec3      u_glow;
+uniform vec3      u_warning;
+uniform float     u_intensity;
+uniform vec4      u_params;
+uniform float     u_dataCount;
+uniform sampler2D u_data;
+
+#define PI  3.14159265359
+#define TAU 6.28318530718
+
+float pulse(float x, float center, float width) {
+  float hw = width * 0.5;
+  return smoothstep(center - hw, center, x) - smoothstep(center, center + hw, x);
+}
+
+float sdCircle(vec2 p, float r) {
+  return length(p) - r;
+}
+
+float sdBox(vec2 p, vec2 b) {
+  vec2 d = abs(p) - b;
+  return length(max(d, 0.0)) + min(max(d.x, d.y), 0.0);
+}
+
+float sdRoundBox(vec2 p, vec2 b, float r) {
+  vec2 d = abs(p) - b + r;
+  return length(max(d, 0.0)) + min(max(d.x, d.y), 0.0) - r;
+}
+
+float sdSegment(vec2 p, vec2 a, vec2 b) {
+  vec2 pa = p - a, ba = b - a;
+  float h = clamp(dot(pa, ba) / dot(ba, ba), 0.0, 1.0);
+  return length(pa - ba * h);
+}
+
+float sdArc(vec2 p, float angle, float aperture, float ra, float rb) {
+  float ca = cos(angle), sa = sin(angle);
+  p = mat2(ca, sa, -sa, ca) * p;
+  p.x = abs(p.x);
+  float an = aperture;
+  vec2 scb = vec2(sin(an), cos(an));
+  float k = (scb.y * p.x > scb.x * p.y) ? dot(p, scb) : length(p);
+  return sqrt(max(dot(p, p) + ra * ra - 2.0 * ra * k, 0.0)) - rb;
+}
+
+float hash(vec2 p) {
+  return fract(sin(dot(p, vec2(127.1, 311.7))) * 43758.5453);
+}
+
+float noise(vec2 p) {
+  vec2 i = floor(p);
+  vec2 f = fract(p);
+  f = f * f * (3.0 - 2.0 * f);
+  return mix(
+    mix(hash(i), hash(i + vec2(1, 0)), f.x),
+    mix(hash(i + vec2(0, 1)), hash(i + vec2(1, 1)), f.x),
+    f.y
+  );
+}
+
+float sampleData(float x) {
+  return texture(u_data, vec2(x, 0.5)).r;
+}
+
+float sampleScope(float x) {
+  float index = clamp(x, 0.0, 1.0) * max(u_dataCount - 1.0, 0.0);
+  return texture(u_data, vec2((index + 0.5) / float(textureSize(u_data, 0).x), 0.5)).r;
+}
+
+float sampleData2D(vec2 uv) {
+  return texture(u_data, uv).r;
+}
+
+float gridLines(vec2 uv, float spacing, float thickness) {
+  vec2 g = abs(fract(uv * spacing) - 0.5);
+  float d = min(g.x, g.y);
+  return 1.0 - smoothstep(0.0, thickness, d);
+}
+
+vec3 glow(float d, vec3 color, float intensity, float radius) {
+  return color * intensity * exp(-abs(d) / radius);
+}
+`;
+// ─── CRT Post-Process Shader ─────────────────────────────────────────────
+export const CRT_FRAG = /*glsl*/ `#version 300 es
+precision highp float;
+
+in vec2 v_uv;
+out vec4 fragColor;
+
+uniform sampler2D u_scene;
+uniform vec2      u_resolution;
+uniform float     u_time;
+uniform float     u_scanlineIntensity;
+uniform float     u_scanlineCount;
+uniform float     u_barrelDistortion;
+uniform float     u_chromaticAberration;
+uniform float     u_bloom;
+uniform float     u_noise;
+uniform float     u_vignette;
+uniform float     u_flicker;
+
+float hash(vec2 p) {
+  return fract(sin(dot(p, vec2(127.1, 311.7))) * 43758.5453);
+}
+
+vec2 distort(vec2 uv, float k) {
+  vec2 c = uv - 0.5;
+  float r2 = dot(c, c);
+  return uv + c * r2 * k;
+}
+
+void main() {
+  vec2 uv = v_uv;
+
+  vec2 duv = distort(uv, u_barrelDistortion);
+
+  float sceneAlpha = texture(u_scene, duv).a;
+
+  if (sceneAlpha < 0.005) {
+    fragColor = vec4(0.0);
+    return;
+  }
+
+  float ca = u_chromaticAberration;
+  float r = texture(u_scene, distort(uv, u_barrelDistortion + ca)).r;
+  float g = texture(u_scene, duv).g;
+  float b = texture(u_scene, distort(uv, u_barrelDistortion - ca)).b;
+  vec3 color = vec3(r, g, b);
+
+  vec3 bloom = vec3(0.0);
+  float bloomAlpha = 0.0;
+  float bw = 3.0 / u_resolution.x;
+  float bh = 3.0 / u_resolution.y;
+  for (int x = -2; x <= 2; x++) {
+    for (int y = -2; y <= 2; y++) {
+      vec4 s = texture(u_scene, duv + vec2(float(x) * bw, float(y) * bh));
+      bloom += s.rgb;
+      bloomAlpha += s.a;
+    }
+  }
+  bloom /= 25.0;
+  bloomAlpha /= 25.0;
+  color += bloom * u_bloom;
+  sceneAlpha = max(sceneAlpha, bloomAlpha * u_bloom);
+
+  float scanline = sin(duv.y * u_scanlineCount * 3.14159) * 0.5 + 0.5;
+  color *= 1.0 - u_scanlineIntensity * (1.0 - scanline);
+
+  float px = fract(gl_FragCoord.x / 3.0);
+  vec3 mask = vec3(
+    smoothstep(0.0, 0.33, px) - smoothstep(0.33, 0.66, px),
+    smoothstep(0.33, 0.66, px) - smoothstep(0.66, 1.0, px),
+    smoothstep(0.66, 1.0, px)
+  );
+  color *= mix(vec3(1.0), mask * 1.5 + 0.5, 0.12);
+
+  float n = hash(uv * u_resolution + u_time * 1000.0) * u_noise;
+  color += n * sceneAlpha;
+
+  vec2 vc = uv - 0.5;
+  float vig = 1.0 - dot(vc, vc) * u_vignette * 2.5;
+  color *= vig;
+
+  float flicker = 1.0 - u_flicker * sin(u_time * 8.3) * sin(u_time * 11.7);
+  color *= flicker;
+
+  if (duv.x < 0.0 || duv.x > 1.0 || duv.y < 0.0 || duv.y > 1.0) {
+    fragColor = vec4(0.0);
+    return;
+  }
+
+  fragColor = vec4(color, sceneAlpha);
+}
+`;
+// ─── Module Fragment Shaders ─────────────────────────────────────────────
+export const SCOPE_FRAG = FRAG_COMMON +
+    /*glsl*/ `
+void main() {
+  vec2 uv = v_uv;
+  float thickness = max(u_params.x, 1.5) / u_resolution.y;
+  float trail = u_params.y;
+  float trigger = u_params.z;
+  float gridDensity = u_params.w;
+
+  vec3 col = mix(vec3(0.008, 0.012, 0.008), vec3(0.0), length(uv - 0.5) * 1.2);
+
+  if (gridDensity > 0.0) {
+    float gMajor = gridLines(uv, 4.0 * gridDensity, 0.008);
+    float gMinor = gridLines(uv, 16.0 * gridDensity, 0.004);
+    col += u_grid * (gMajor * 0.6 + gMinor * 0.2);
+    float cx = abs(uv.x - 0.5);
+    float cy = abs(uv.y - 0.5);
+    col += u_grid * 0.5 * (1.0 - smoothstep(0.0, 0.002, min(cx, cy)));
+    float tickX = abs(fract(uv.x * 20.0) - 0.5);
+    float tickY = abs(fract(uv.y * 20.0) - 0.5);
+    float onCrossX = 1.0 - smoothstep(0.0, 0.003, cy);
+    float onCrossY = 1.0 - smoothstep(0.0, 0.003, cx);
+    float tick = (1.0 - smoothstep(0.0, 0.03, tickX)) * onCrossX
+               + (1.0 - smoothstep(0.0, 0.03, tickY)) * onCrossY;
+    col += u_grid * 0.25 * tick;
+  }
+
+  if (trigger > 0.0) {
+    float tLine = abs(uv.y - trigger);
+    col += u_accent * 0.3 * (1.0 - smoothstep(0.0, 0.003, tLine));
+  }
+
+  float minDist = 1.0;
+
+  if (u_dataCount > 0.0) {
+
+  for (int i = -2; i <= 2; i++) {
+    float sx = uv.x + float(i) * 0.5 / u_resolution.x;
+    float val = sampleScope(sx);
+    float dy = abs(uv.y - val);
+    minDist = min(minDist, dy);
+  }
+
+  float traceLine = 1.0 - smoothstep(0.0, thickness, minDist);
+  col += u_color * traceLine * u_intensity;
+  col += glow(minDist, u_glow, 0.4 * u_intensity, thickness * 4.0);
+
+  if (trail > 0.0) {
+    float trailVal = sampleScope(uv.x - 0.01);
+    float trailDist = abs(uv.y - trailVal);
+    col += u_dim * trail * (1.0 - smoothstep(0.0, thickness * 3.0, trailDist));
+  }
+
+  float deriv = abs(sampleScope(uv.x + 0.002) - sampleScope(uv.x - 0.002));
+  float beamBright = 1.0 + (1.0 - min(deriv * 5.0, 1.0)) * 0.4;
+  col *= beamBright;
+  }
+
+  float scan = 1.0 - 0.04 * (1.0 - smoothstep(0.0, 0.4, abs(fract(uv.y * u_resolution.y * 0.5) - 0.5)));
+  col *= scan;
+
+  fragColor = vec4(col, 1.0);
+}
+`;
+export const MULTI_LINE_SCOPE_FRAG = FRAG_COMMON +
+    /*glsl*/ `
+void main() {
+  vec2 uv = v_uv;
+  float thickness = max(u_params.x, 1.5) / u_resolution.y;
+  float trail = u_params.y;
+  float trigger = u_params.z;
+  float gridDensity = u_params.w;
+
+  vec3 col = mix(vec3(0.008, 0.012, 0.008), vec3(0.0), length(uv - 0.5) * 1.2);
+
+  if (gridDensity > 0.0) {
+    float gMajor = gridLines(uv, 4.0 * gridDensity, 0.008);
+    float gMinor = gridLines(uv, 16.0 * gridDensity, 0.004);
+    col += u_grid * (gMajor * 0.6 + gMinor * 0.2);
+    float cx = abs(uv.x - 0.5);
+    float cy = abs(uv.y - 0.5);
+    col += u_grid * 0.5 * (1.0 - smoothstep(0.0, 0.002, min(cx, cy)));
+  }
+
+  if (trigger > 0.0) {
+    float tLine = abs(uv.y - trigger);
+    col += u_accent * 0.3 * (1.0 - smoothstep(0.0, 0.003, tLine));
+  }
+
+  float minDists0 = 1.0; float minDists1 = 1.0; float minDists2 = 1.0;
+  float minDists3 = 1.0; float minDists4 = 1.0;
+
+  if (u_dataCount > 0.0) {
+  for (int trace = 0; trace < 5; trace++) {
+    float md = 1.0;
+    for (int i = -2; i <= 2; i++) {
+      float sx = uv.x + float(i) * 0.5 / u_resolution.x;
+      float traceOffset = float(trace) * 0.2;
+      float val = sampleData(sx + traceOffset);
+      float dy = abs(uv.y - val);
+      md = min(md, dy);
+    }
+    if (trace == 0) minDists0 = md;
+    if (trace == 1) minDists1 = md;
+    if (trace == 2) minDists2 = md;
+    if (trace == 3) minDists3 = md;
+    if (trace == 4) minDists4 = md;
+  }
+
+  vec3 tc0 = u_color;
+  vec3 tc1 = u_accent;
+  vec3 tc2 = mix(u_color, u_accent, 0.5);
+  vec3 tc3 = u_warning;
+  vec3 tc4 = mix(u_accent, u_warning, 0.5);
+
+  col += tc0 * (1.0 - smoothstep(0.0, thickness, minDists0)) * u_intensity;
+  col += tc1 * (1.0 - smoothstep(0.0, thickness, minDists1)) * u_intensity;
+  col += tc2 * (1.0 - smoothstep(0.0, thickness, minDists2)) * u_intensity;
+  col += tc3 * (1.0 - smoothstep(0.0, thickness, minDists3)) * u_intensity;
+  col += tc4 * (1.0 - smoothstep(0.0, thickness, minDists4)) * u_intensity;
+
+  col += glow(minDists0, tc0, 0.2 * u_intensity, thickness * 4.0);
+  col += glow(minDists1, tc1, 0.2 * u_intensity, thickness * 4.0);
+
+  float deriv = abs(sampleData(uv.x + 0.002) - sampleData(uv.x - 0.002));
+  float beamBright = 1.0 + (1.0 - min(deriv * 5.0, 1.0)) * 0.4;
+  col *= beamBright;
+  }
+
+  fragColor = vec4(col, 1.0);
+}
+`;
+export const ARC_GAUGE_FRAG = FRAG_COMMON +
+    /*glsl*/ `
+void main() {
+  vec2 uv = v_uv;
+  vec2 p = uv - vec2(0.5);
+  p.x *= u_resolution.x / u_resolution.y;
+
+  float startAngle = u_params.x;
+  float sweepAngle = u_params.y;
+  float segments = u_params.z;
+  float value = clamp(u_params.w, 0.0, 1.0);
+  float r = length(p);
+  float a = mod(atan(p.y, p.x) - startAngle + TAU, TAU);
+
+  float outerR = 0.42, innerR = 0.30, needleR = 0.44;
+  vec3 col = vec3(0.0);
+  float inArc = step(a, sweepAngle) * step(innerR, r) * step(r, outerR);
+  float fillAngle = value * sweepAngle;
+  float filled = step(a, fillAngle);
+
+  if (segments > 0.0) {
+    float segAngle = sweepAngle / segments;
+    float segIdx = floor(a / segAngle);
+    float segFrac = fract(a / segAngle);
+    filled *= (1.0 - smoothstep(0.88, 0.92, segFrac)) * step(a, fillAngle);
+    float segNorm = segIdx / segments;
+    vec3 segColor = mix(u_color, u_warning, smoothstep(0.7, 1.0, segNorm));
+    col += segColor * filled * inArc * u_intensity;
+  } else {
+    vec3 fillColor = mix(u_color, u_warning, smoothstep(0.6, 1.0, a / sweepAngle));
+    col += fillColor * filled * inArc * u_intensity;
+  }
+  col += u_dim * 0.3 * (1.0 - filled) * inArc;
+
+  col += u_grid * 0.5 * (1.0 - smoothstep(0.0, 0.004, abs(r - outerR)));
+  col += u_grid * 0.5 * (1.0 - smoothstep(0.0, 0.004, abs(r - innerR)));
+
+  if (segments > 0.0) {
+    for (float i = 0.0; i <= segments; i += 1.0) {
+      float tickA = startAngle + i / segments * sweepAngle;
+      vec2 td = vec2(cos(tickA), sin(tickA));
+      float td2 = sdSegment(p, td * innerR * 0.92, td * outerR * 1.06);
+      col += u_grid * 0.6 * (1.0 - smoothstep(0.0, 0.003, td2));
+    }
+  }
+
+  float needleAngle = startAngle + value * sweepAngle;
+  vec2 nd = vec2(cos(needleAngle), sin(needleAngle));
+  float nd2 = sdSegment(p, vec2(0.0), nd * needleR);
+  col += u_accent * (1.0 - smoothstep(0.0, 0.005, nd2)) * u_intensity;
+  col += glow(nd2, u_glow, 0.3 * u_intensity, 0.015);
+  col += u_accent * (1.0 - smoothstep(0.015, 0.02, r));
+
+  fragColor = vec4(col, 1.0);
+}
+`;
+export const BAR_METER_FRAG = FRAG_COMMON +
+    /*glsl*/ `
+void main() {
+  vec2 uv = v_uv;
+  float segments = u_params.x;
+  float vertical = u_params.y;
+  float warnThresh = u_params.z;
+  float value = u_dataCount > 0.0 ? sampleScope(0.0) : u_params.w;
+  value = clamp(value, 0.0, 1.0);
+
+  float pos = vertical > 0.5 ? uv.y : uv.x;
+  float cross = vertical > 0.5 ? uv.x : uv.y;
+  float inset = 0.08, barWidth = 1.0 - inset * 2.0, barStart = inset, crossInset = 0.15;
+  float inBar = step(barStart, pos) * step(pos, barStart + barWidth)
+              * step(crossInset, cross) * step(cross, 1.0 - crossInset);
+  float norm = (pos - barStart) / barWidth;
+  vec3 col = vec3(0.0);
+  col += u_dim * 0.15 * inBar;
+  float filled = step(norm, value) * inBar;
+
+  if (segments > 0.0) {
+    filled *= (1.0 - smoothstep(0.82, 0.88, fract(norm / (1.0 / segments))));
+  }
+
+  vec3 barColor = norm < warnThresh
+    ? mix(u_color, u_accent, norm / max(warnThresh, 0.01))
+    : mix(u_accent, u_warning, (norm - warnThresh) / max(1.0 - warnThresh, 0.01));
+  col += barColor * filled * u_intensity;
+
+  float edgePos = value * barWidth + barStart;
+  float edgeDist = abs(pos - edgePos);
+  float edgeGlow = step(crossInset, cross) * step(cross, 1.0 - crossInset);
+  col += glow(edgeDist, u_glow, 0.5 * u_intensity, 0.02) * edgeGlow;
+
+  float border = min(abs(cross - crossInset), abs(cross - (1.0 - crossInset)));
+  border = min(border, min(abs(pos - barStart), abs(pos - (barStart + barWidth))));
+  col += u_grid * 0.5 * (1.0 - smoothstep(0.0, 0.005, border)) * inBar;
+
+  fragColor = vec4(col, 1.0);
+}
+`;
+export const RADAR_FRAG = FRAG_COMMON +
+    /*glsl*/ `
+void main() {
+  vec2 uv = v_uv;
+  vec2 p = uv - vec2(0.5);
+  p.x *= u_resolution.x / u_resolution.y;
+  float sweepSpeed = u_params.x;
+  float fadeRate = u_params.y;
+  float rings = max(u_params.z, 3.0);
+  float r = length(p);
+  float angle = atan(p.y, p.x);
+  float maxR = 0.46;
+
+  vec3 col = vec3(0.0);
+  float scope = step(r, maxR);
+
+  for (float i = 1.0; i <= 8.0; i += 1.0) {
+    if (i > rings) break;
+    col += u_grid * 0.35 * (1.0 - smoothstep(0.0, 0.003, abs(r - i / rings * maxR))) * scope;
+  }
+  col += u_grid * 0.2 * (1.0 - smoothstep(0.0, 0.002, min(abs(p.y), abs(p.x)))) * scope;
+
+  float sweepAngle = mod(u_time * sweepSpeed, TAU);
+  float angleDiff = mod(angle - sweepAngle + TAU, TAU);
+  col += u_color * exp(-angleDiff * 1.5) * 0.25 * scope * u_intensity;
+  col += u_color * (1.0 - smoothstep(0.0, 0.04, angleDiff)) * scope * u_intensity * 0.8;
+  col += glow(angleDiff, u_glow, 0.15, 0.08) * scope;
+
+  for (float i = 0.0; i < 64.0; i += 1.0) {
+    float blipAngle = sampleData(i / 64.0) * TAU;
+    float blipR = sampleData((i + 0.5) / 64.0) * maxR;
+    if (blipR < 0.01) continue;
+    vec2 bp = vec2(cos(blipAngle), sin(blipAngle)) * blipR;
+    bp.x /= u_resolution.x / u_resolution.y;
+    float dist = length(p - bp);
+    float age = mod(sweepAngle - blipAngle + TAU, TAU) / TAU;
+    float brightness = exp(-age * fadeRate * 5.0);
+    col += u_accent * (1.0 - smoothstep(0.0, 0.012, dist)) * brightness * u_intensity;
+    col += glow(dist, u_glow, 0.2 * brightness * u_intensity, 0.02);
+  }
+
+  col += u_color * 0.5 * (1.0 - smoothstep(0.0, 0.004, abs(r - maxR)));
+  col *= scope;
+  col += u_accent * (1.0 - smoothstep(0.005, 0.008, r)) * 0.8;
+
+  fragColor = vec4(col, 1.0);
+}
+`;
+export const HEX_MATRIX_FRAG = FRAG_COMMON +
+    /*glsl*/ `
+float hexDist(vec2 p) {
+  p = abs(p);
+  return max(p.x + p.y * 0.5773502692, p.y * 1.1547005384);
+}
+
+vec4 hexGrid(vec2 uv, float scale) {
+  vec2 s = vec2(1.0, 1.7320508);
+  vec2 a = mod(uv * scale, s) - s * 0.5;
+  vec2 b = mod(uv * scale + s * 0.5, s) - s * 0.5;
+  vec2 g = (dot(a, a) < dot(b, b)) ? a : b;
+  vec2 id = (uv * scale - g) / s;
+  return vec4(g, id);
+}
+
+void main() {
+  vec2 uv = v_uv;
+  float cols = max(u_params.x, 4.0);
+  float rows = max(u_params.y, 4.0);
+  float gap = u_params.z;
+  float animSpeed = u_params.w;
+
+  vec4 hex = hexGrid(uv, cols);
+  float d = hexDist(hex.xy);
+  vec3 col = vec3(0.0);
+  float cellEdge = smoothstep(0.48, 0.46 - gap * 0.1, d);
+
+  vec2 dataUV = clamp(vec2(
+    (hex.z + cols * 0.5) / cols,
+    (hex.w + rows * 0.5) / rows
+  ), 0.0, 1.0);
+  float value = sampleData2D(dataUV);
+  float pulse = sin(u_time * animSpeed + value * TAU + hex.z * 0.5 + hex.w * 0.3) * 0.1 + 0.9;
+  value *= pulse;
+
+  vec3 cellColor = mix(u_dim, u_color, smoothstep(0.0, 0.5, value));
+  cellColor = mix(cellColor, u_accent, smoothstep(0.5, 0.8, value));
+  cellColor = mix(cellColor, u_warning, smoothstep(0.8, 1.0, value));
+  col += cellColor * cellEdge * value * u_intensity;
+  col += u_grid * 0.3 * (1.0 - smoothstep(0.0, 0.02, abs(d - 0.46 + gap * 0.1))) * cellEdge;
+
+  if (value > 0.6) col += glow(d, u_glow, value * 0.15 * u_intensity, 0.15);
+
+  fragColor = vec4(col, 1.0);
+}
+`;
+export const WATERFALL_FRAG = FRAG_COMMON +
+    /*glsl*/ `
+vec3 heatmap(float t) {
+  t = clamp(t, 0.0, 1.0);
+  if (t < 0.33) return mix(vec3(0.0, 0.0, 0.1), vec3(0.0, 0.4, 0.8), t * 3.0);
+  if (t < 0.66) return mix(vec3(0.0, 0.4, 0.8), vec3(0.9, 0.8, 0.0), (t - 0.33) * 3.0);
+  return mix(vec3(0.9, 0.8, 0.0), vec3(1.0, 0.1, 0.05), (t - 0.66) * 3.0);
+}
+
+vec3 spectral(float t) {
+  t = clamp(t, 0.0, 1.0);
+  if (t < 0.2) return mix(vec3(0.0, 0.0, 0.15), vec3(0.0, 0.3, 0.7), t * 5.0);
+  if (t < 0.4) return mix(vec3(0.0, 0.3, 0.7), vec3(0.0, 0.85, 0.4), (t - 0.2) * 5.0);
+  if (t < 0.6) return mix(vec3(0.0, 0.85, 0.4), vec3(0.95, 0.9, 0.0), (t - 0.4) * 5.0);
+  if (t < 0.8) return mix(vec3(0.95, 0.9, 0.0), vec3(1.0, 0.15, 0.05), (t - 0.6) * 5.0);
+  return mix(vec3(1.0, 0.15, 0.05), vec3(1.0, 0.95, 0.9), (t - 0.8) * 5.0);
+}
+
+void main() {
+  vec2 uv = v_uv;
+  float colorMode = u_params.y;
+  float boost = max(u_params.z, 1.0);
+  float value = sampleData2D(uv) * boost;
+  vec3 col = colorMode < 0.5 ? heatmap(value) : spectral(value);
+  col *= u_intensity;
+  float scanline = sin(uv.y * u_resolution.y * 0.5) * 0.03;
+  col *= 1.0 - scanline;
+  col += u_grid * gridLines(vec2(uv.x, 0.0), 8.0, 0.006) * 0.15;
+  col += u_grid * gridLines(vec2(0.0, uv.y), 4.0, 0.006) * 0.1;
+  fragColor = vec4(col, 1.0);
+}
+`;
+export const TOPO_FRAG = FRAG_COMMON +
+    /*glsl*/ `
+void main() {
+  vec2 uv = v_uv;
+  float intervals = max(u_params.x, 5.0);
+  float thickness = max(u_params.y, 0.5) * 0.003;
+  float showGrad = u_params.z;
+  float animSpeed = u_params.w;
+
+  float h = sampleData2D(uv) + sin(u_time * animSpeed) * 0.03;
+  float dx = sampleData2D(uv + vec2(1.0 / u_resolution.x, 0.0)) - h;
+  float dy = sampleData2D(uv + vec2(0.0, 1.0 / u_resolution.y)) - h;
+
+  vec3 col = vec3(0.0);
+  if (showGrad > 0.5) {
+    col = h < 0.5 ? mix(u_dim, u_color * 0.4, h * 2.0) : mix(u_color * 0.4, u_accent * 0.5, (h - 0.5) * 2.0);
+    col *= clamp(0.5 + dx * 3.0 - dy * 3.0, 0.3, 1.2);
+  }
+
+  float contourH = fract(h * intervals);
+  float contourD = min(contourH, 1.0 - contourH);
+  col += u_color * (1.0 - smoothstep(0.0, thickness, contourD)) * 0.5 * u_intensity;
+
+  float majorH = fract(h * intervals / 5.0);
+  float majorD = min(majorH, 1.0 - majorH);
+  col += u_accent * (1.0 - smoothstep(0.0, thickness * 2.0, majorD)) * 0.8 * u_intensity;
+  col += glow(majorD, u_glow, 0.1 * u_intensity, thickness * 8.0);
+
+  fragColor = vec4(col, 1.0);
+}
+`;
+export const VECTOR_SCOPE_FRAG = FRAG_COMMON +
+    /*glsl*/ `
+void main() {
+  vec2 uv = v_uv;
+  vec2 p = uv - vec2(0.5);
+  float r = length(p);
+  float dotSize = max(u_params.x, 2.0) / u_resolution.y;
+  float trail = u_params.y;
+  float gratStyle = u_params.z;
+
+  vec3 col = vec3(0.0);
+  if (gratStyle < 0.5) {
+    col += u_grid * 0.3 * (1.0 - smoothstep(0.0, 0.002, min(abs(p.x), abs(p.y))));
+    col += u_grid * 0.15 * gridLines(uv, 4.0, 0.006);
+  } else {
+    for (float i = 1.0; i <= 4.0; i += 1.0) {
+      col += u_grid * 0.25 * (1.0 - smoothstep(0.0, 0.003, abs(r - i * 0.1)));
+    }
+    col += u_grid * 0.2 * (1.0 - smoothstep(0.0, 0.002, min(abs(p.x), abs(p.y))));
+  }
+
+  float minDist = 1.0;
+  for (float i = 0.0; i < 128.0; i += 2.0) {
+    float dx = sampleData(i / 256.0) - 0.5;
+    float dy = sampleData((i + 1.0) / 256.0) - 0.5;
+    float dist = length(p - vec2(dx, dy));
+    minDist = min(minDist, dist);
+  }
+
+  float dot = 1.0 - smoothstep(0.0, dotSize, minDist);
+  col += u_color * dot * u_intensity;
+  col += glow(minDist, u_glow, 0.3 * u_intensity, dotSize * 4.0);
+
+  if (trail > 0.0) col += u_dim * trail * 0.5 * (1.0 - smoothstep(0.0, dotSize * 8.0, minDist));
+  col += u_grid * 0.4 * (1.0 - smoothstep(0.0, 0.003, abs(r - 0.48)));
+
+  fragColor = vec4(col, 1.0);
+}
+`;
+export const PROGRESS_RING_FRAG = FRAG_COMMON +
+    /*glsl*/ `
+void main() {
+  vec2 uv = v_uv;
+  vec2 p = uv - vec2(0.5);
+  p.x *= u_resolution.x / u_resolution.y;
+  float ringWidth = max(u_params.x, 0.06);
+  float segments = u_params.y;
+  float rotSpeed = u_params.z;
+  float value = clamp(u_params.w, 0.0, 1.0);
+  float r = length(p);
+  float angle = atan(p.y, p.x);
+
+  float outerR = 0.42, innerR = outerR - ringWidth;
+  float inRing = smoothstep(innerR - 0.005, innerR, r) * (1.0 - smoothstep(outerR, outerR + 0.005, r));
+  float startA = -PI * 0.5 + u_time * rotSpeed;
+  float a = mod(angle - startA + TAU, TAU);
+  float filled = step(a, value * TAU);
+
+  if (segments > 0.0) filled *= (1.0 - smoothstep(0.85, 0.92, fract(a / (TAU / segments))));
+
+  vec3 fillColor = mix(u_color, u_accent, value * value);
+  vec3 col = fillColor * filled * inRing * u_intensity + u_dim * 0.15 * (1.0 - filled) * inRing;
+  col += u_grid * 0.4 * (1.0 - smoothstep(0.0, 0.003, abs(r - outerR)));
+  col += u_grid * 0.4 * (1.0 - smoothstep(0.0, 0.003, abs(r - innerR)));
+
+  float endAngle = startA + value * TAU;
+  vec2 endPos = vec2(cos(endAngle), sin(endAngle)) * (outerR + innerR) * 0.5;
+  col += glow(length(p - endPos), u_glow, 0.5 * u_intensity * value, ringWidth * 0.5);
+  col += u_accent * (1.0 - smoothstep(0.02, 0.025, r)) * 0.5;
+
+  fragColor = vec4(col, 1.0);
+}
+`;
+export const DIGITAL_READOUT_FRAG = FRAG_COMMON +
+    /*glsl*/ `
+float segment(vec2 p, int seg) {
+  float d = 1.0, w = 0.12, len = 0.32;
+  if (seg == 0) d = sdBox(p - vec2(0.5, 0.88), vec2(len, w));
+  if (seg == 1) d = sdBox(p - vec2(0.82, 0.69), vec2(w, len));
+  if (seg == 2) d = sdBox(p - vec2(0.82, 0.31), vec2(w, len));
+  if (seg == 3) d = sdBox(p - vec2(0.5, 0.12), vec2(len, w));
+  if (seg == 4) d = sdBox(p - vec2(0.18, 0.31), vec2(w, len));
+  if (seg == 5) d = sdBox(p - vec2(0.18, 0.69), vec2(w, len));
+  if (seg == 6) d = sdBox(p - vec2(0.5, 0.50), vec2(len, w));
+  return d;
+}
+
+float digitSegment(int digit, int seg) {
+  int patterns[12] = int[12](0x3F, 0x06, 0x5B, 0x4F, 0x66, 0x6D, 0x7D, 0x07, 0x7F, 0x6F, 0x40, 0x00);
+  if (digit < 0 || digit > 11) return 0.0;
+  return float((patterns[digit] >> seg) & 1);
+}
+
+void main() {
+  vec2 uv = v_uv;
+  float digitCount = clamp(u_params.x, 1.0, 8.0);
+  float blinkRate = u_params.z;
+  float blink = blinkRate > 0.0 ? step(0.0, sin(u_time * blinkRate * TAU)) : 1.0;
+  vec3 col = u_dim * 0.05;
+  float digitWidth = 0.85 / digitCount;
+  float startX = (1.0 - digitWidth * digitCount) * 0.5;
+
+  for (float d = 0.0; d < 8.0; d += 1.0) {
+    if (d >= digitCount) break;
+    float dx = startX + d * digitWidth;
+    vec2 duv = vec2((uv.x - dx) / digitWidth, uv.y);
+    if (duv.x < 0.0 || duv.x > 1.0 || duv.y < 0.05 || duv.y > 0.95) continue;
+    duv.y = (duv.y - 0.05) / 0.9;
+    duv.x = duv.x * 0.9 + 0.05;
+    int digitVal = int(sampleData(d / 8.0) + 0.5);
+
+    for (int s = 0; s < 7; s++) {
+      float on = digitSegment(digitVal, s);
+      float dist = segment(duv, s);
+      col += u_color * (1.0 - smoothstep(-0.01, 0.005, dist)) * on * blink * u_intensity;
+      col += glow(dist, u_glow, 0.15 * on * blink * u_intensity, 0.04);
+      col += u_dim * (1.0 - smoothstep(-0.01, 0.005, dist)) * (1.0 - on) * 0.08;
+    }
+  }
+
+  fragColor = vec4(col, 1.0);
+}
+`;
+export const STATUS_GRID_FRAG = FRAG_COMMON +
+    /*glsl*/ `
+void main() {
+  vec2 uv = v_uv;
+  float cols = max(u_params.x, 2.0);
+  float rows = max(u_params.y, 2.0);
+  float style = u_params.z;
+  float pulseSpeed = u_params.w;
+
+  vec2 cellSize = vec2(1.0 / cols, 1.0 / rows);
+  vec2 cellId = floor(uv / cellSize);
+  vec2 cellUV = fract(uv / cellSize);
+  vec2 cellCenter = cellUV - 0.5;
+  float dataIdx = (cellId.y * cols + cellId.x) / (cols * rows);
+  float value = sampleData(dataIdx);
+
+  vec3 col = u_grid * 0.15 * gridLines(uv, cols, 0.008);
+  float d;
+  if (style < 0.5) d = sdCircle(cellCenter, 0.3);
+  else if (style < 1.5) d = sdBox(cellCenter, vec2(0.25));
+  else d = sdBox(vec2(cellCenter.x + cellCenter.y, cellCenter.y - cellCenter.x) * 0.707, vec2(0.22));
+
+  vec3 stateColor;
+  float brightness;
+  if (value < 0.15) { stateColor = u_dim; brightness = 0.15; }
+  else if (value < 0.45) { stateColor = u_color * 0.5; brightness = 0.4; }
+  else if (value < 0.78) {
+    stateColor = u_color; brightness = 0.9 * (1.0 + sin(u_time * pulseSpeed + cellId.x * 0.7 + cellId.y * 1.1) * 0.1);
+  } else { stateColor = u_warning; brightness = step(0.0, sin(u_time * pulseSpeed * 3.0)); }
+
+  col += stateColor * (1.0 - smoothstep(-0.01, 0.01, d)) * brightness * u_intensity;
+  if (value > 0.45) col += glow(d, u_glow * stateColor / max(max(stateColor.r, stateColor.g), stateColor.b + 0.01), 0.2 * brightness * u_intensity, 0.06);
+  col += u_grid * 0.3 * (1.0 - smoothstep(0.0, 0.015, abs(d)));
+
+  fragColor = vec4(col, 1.0);
+}
+`;
+export const TOGGLE_FRAG = FRAG_COMMON +
+    /*glsl*/ `
+void main() {
+  vec2 uv = v_uv;
+  vec2 p = uv - vec2(0.5);
+  float state = u_params.x;
+  float style = u_params.y;
+  float flashTime = u_params.z;
+  vec3 col = vec3(0.0);
+
+  float panelD = sdRoundBox(p, vec2(0.38, 0.42), 0.05);
+  col += u_dim * 0.08 * (1.0 - smoothstep(-0.005, 0.0, panelD));
+  col += u_grid * 0.4 * (1.0 - smoothstep(0.0, 0.008, abs(panelD)));
+
+  if (style < 0.5) {
+    float switchY = mix(-0.14, 0.14, state);
+    float switchD = sdRoundBox(p - vec2(0.0, switchY), vec2(0.10, 0.10), 0.02);
+    col += mix(u_dim * 0.4, u_color, state) * (1.0 - smoothstep(-0.005, 0.005, switchD)) * u_intensity;
+    col += u_accent * 0.3 * (1.0 - smoothstep(0.0, 0.008, abs(switchD))) * state;
+  } else if (style < 1.5) {
+    float knobD = sdCircle(p - vec2(mix(-0.16, 0.16, state), 0.0), 0.08);
+    col += mix(u_dim * 0.5, u_color, state) * (1.0 - smoothstep(-0.005, 0.005, knobD)) * u_intensity;
+    col += glow(knobD, u_glow, 0.2 * state * u_intensity, 0.03);
+  } else {
+    float flash = flashTime > 0.0 ? exp(-u_time / flashTime) : 0.0;
+    float brightness = max(state, flash);
+    float innerD = sdCircle(p, 0.16);
+    col += mix(u_dim * 0.3, u_color, brightness) * (1.0 - smoothstep(-0.005, 0.005, innerD)) * u_intensity;
+    col += glow(innerD, u_glow, 0.3 * brightness * u_intensity, 0.04);
+  }
+
+  float ledD = sdCircle(p - vec2(0.0, 0.35), 0.03);
+  vec3 ledColor = mix(u_dim * 0.2, u_accent, state);
+  col += ledColor * (1.0 - smoothstep(-0.003, 0.003, ledD)) * u_intensity;
+  col += glow(ledD, u_glow * ledColor / max(max(ledColor.r, ledColor.g), ledColor.b + 0.01), 0.3 * state * u_intensity, 0.02);
+
+  fragColor = vec4(col, 1.0);
+}
+`;
+export const MODULE_SHADERS = {
+    scope: SCOPE_FRAG,
+    'multi-line-scope': MULTI_LINE_SCOPE_FRAG,
+    'arc-gauge': ARC_GAUGE_FRAG,
+    'bar-meter': BAR_METER_FRAG,
+    radar: RADAR_FRAG,
+    'hex-matrix': HEX_MATRIX_FRAG,
+    waterfall: WATERFALL_FRAG,
+    topo: TOPO_FRAG,
+    'vector-scope': VECTOR_SCOPE_FRAG,
+    'progress-ring': PROGRESS_RING_FRAG,
+    'digital-readout': DIGITAL_READOUT_FRAG,
+    'status-grid': STATUS_GRID_FRAG,
+    toggle: TOGGLE_FRAG
+};