react-native-webrtc-kaleidoscope 2.6.1 → 2.7.1

package/android/src/main/java/com/simiancraft/kaleidoscope/gpu/ShadersGenerated.kt

@@ -565,34 +565,38 @@ void main() {
 
     col = mix(col, sunCol, sunBody);
   } else {
-    // --- FLOOR --- perspective grid. Guard the divide; shade only below horizon.
-    float depth = 1.0 / max(h - fy, 1.5e-3); // large near the horizon
-    float depthMin = 1.0 / h;                // depth at the very front (fy = 0)
-
-    // Grid coordinates: x widens with depth (perspective); uGridDensity sets the
-    // cell count; the scroll is in cell units so its rate is density-independent.
-    vec2 g = vec2(fx * depth, depth) * uGridDensity;
-    g.y += uTime * uSpeed * 2.0;
-    vec2 cell = abs(fract(g) - 0.5); // 0 on a line .. 0.5 mid-cell, per axis
-
-    // Per-axis, depth-scaled line half-width: the rungs (g.y) compress toward the
-    // horizon as depth^2 and the verticals (g.x) ~linearly, so widening each axis'
-    // line band at its own compression rate holds the on-screen line width roughly
-    // constant. Far lines fuse into a band instead of a sub-pixel sheet that
-    // shimmers as it scrolls; near lines stay crisp. Written 1 - smoothstep(0, w, .)
-    // (NOT the reversed-edge smoothstep(w, 0, .), which is undefined on GLSL ES /
-    // Metal) and derivative-free, so it is portable and mobile-precision safe.
-    vec2 w = max(vec2(depth, depth * depth * 0.2) * uGridDensity * 0.0013, vec2(1e-4));
-    vec2 core = 1.0 - smoothstep(vec2(0.0), w, cell);
-    vec2 halo = (1.0 - smoothstep(vec2(0.0), w * 6.0, cell)) * (0.5 * uGridGlow);
-    float gridVal = clamp(core.x + core.y + halo.x + halo.y, 0.0, 1.5);
-
-    // Distance fog: fade the grid out toward the horizon for the converging look.
-    float fog = clamp(1.0 - (depth - depthMin) / (depthMin * 10.0), 0.0, 1.0);
-    fog *= fog;
-
-    vec3 floorBase = mix(vec3(0.0), uSkyHorizon * 0.16, fog * 0.6);
-    col = floorBase + uGridColor * gridVal * fog * calm;
+    // --- FLOOR --- perspective grid, a faithful port of a known-good community
+    // outrun grid (prior versions read as a too-dense, flickering sheet). Work in
+    // the reference's centered frame: cx is full-width centered x, dy is the
+    // centered distance BELOW the horizon. The additive offset caps the depth at
+    // the horizon, and putting big cells in the near field (low min depth) is what
+    // keeps the line spacing above a pixel, so it neither sheets nor shimmers.
+    float cx = 2.0 * fx;            // = (2*vUv.x - 1) * aspect
+    float dy = 2.0 * (h - fy);      // centered distance below the horizon (> 0)
+
+    // Cell count: uGridDensity 4 -> numerator 1.0 (sparse, big near cells). x
+    // widens with depth (the 0.7 factor); scroll is a slow drift toward the viewer.
+    float num = uGridDensity * 0.25;
+    float depth = num / (dy + 0.05);
+    vec2 g = vec2(cx * depth * 0.7, depth);
+    g.y += uTime * uSpeed * 0.3;
+    vec2 e = abs(fract(g) - 0.5);
+
+    // PIXEL-CALIBRATED line width: each line core is a fixed ~px wide in SCREEN
+    // PIXELS (via uResolution), the same at every depth and every resolution. The
+    // old depth^2*const width was constant in theory but landed sub-pixel, so
+    // discrete sampling rendered some rungs thick and others thin -> the uneven
+    // rungs that read as flicker. Solving sz so screen thickness == px: the rungs
+    // (g.y, compression ~depth^2/num) need sz.y = depth^2 * pf / num; the verticals
+    // (g.x) need sz.x = depth * 0.7 * pf. uGridGlow sets px (0.5 -> 2 px).
+    float pf = (uGridGlow * 4.0) / uResolution.y;
+    vec2 sz = vec2(depth * 0.7 * pf, depth * depth * pf / num);
+    vec2 lines = 1.0 - smoothstep(vec2(0.0), sz, e);
+    lines += (1.0 - smoothstep(vec2(0.0), sz * 4.0, e)) * 0.5;
+    float gridVal = clamp(lines.x + lines.y, 0.0, 1.0);
+
+    vec3 floorBase = uSkyHorizon * 0.06;
+    col = mix(floorBase, uGridColor, gridVal * calm);
   }
 
   // Glowing horizon seam where floor meets sky.
@@ -740,9 +744,11 @@ const float MIN_DIVIDE = 64.0;
 const float MAX_DIVIDE = 0.01;
 // Number of stacked starfield layers. Compile-time constant so the layer
 // loop has a fixed integer bound (cross-compile-safe; no float loop counter).
-// 8 (was 12) for low-end-mobile cost (issue #39); the work is linear in the
-// count and dimByDensity rebalances per-star brightness automatically.
-const int STARFIELD_LAYERS_COUNT = 8;
+// 7 (was 8 #74, was 12 #39) for cost; the work is linear in the count and
+// dimByDensity rebalances per-star brightness automatically. 7 keeps the dense
+// look essentially intact (6 was visibly sparser at some animation phases);
+// paired with the empty-cell early-out below it lands ~34% under the old 8.
+const int STARFIELD_LAYERS_COUNT = 7;
 
 mat2 Rotate(float angle) {
   float s = sin(angle);
@@ -810,6 +816,12 @@ vec3 StarFieldLayer(vec2 uv, float rotAngle) {
       float size = fract(randomN * 1356.33);
       float flareSwitch = smoothstep(0.9, 1.0, size);
       float star = Star(randomPosition, flareSwitch, rotAngle, randomN);
+      // The per-cell color below is multiplied by `star` at the end, so for any
+      // cell whose star is 0 (Star() returns exactly 0 for d >= 1.0, i.e. the
+      // empty-sky majority of the 8x9 = 72 cells/pixel) the whole term is 0.
+      // Skipping the sin(vec3) color work for those cells is output-identical and
+      // is the bulk of the win (issue #74).
+      if (star <= 0.0) continue;
 
       // fract trick: random colors
       float randomStarColorSeed = fract(randomN * 2150.0) * (3.0 * PI) * deltaTimeTwinkle;
@@ -1678,6 +1690,167 @@ void main() {
     // Premultiplied output; tint grades the (premultiplied) color, not alpha.
     oColor = vec4(blobCol * uColor, blobAlpha);
 }
+"""
+
+  const val DATA_MESH_FRAG = """#version 300 es
+precision highp float;
+
+uniform float uTime;        // seconds, monotonically increasing; range [0, inf)
+uniform vec2 uResolution;   // framebuffer size in pixels; both components > 0
+uniform vec3 uBgTop;        // background gradient color at the top of frame
+uniform vec3 uBgBottom;     // background gradient color at the bottom of frame
+uniform vec3 uLineColor;    // mid wireframe-line tint (the trough/body color)
+uniform vec3 uCrestColor;   // crest highlight color (brightest along the peaks)
+uniform vec3 uHazeColor;    // atmospheric haze tint on the far rows
+uniform vec3 uAccentColor;  // the one restrained accent (e.g. enterprise red)
+uniform float uWaveScale;   // wave-field spatial frequency; lower = looser, broader hills
+uniform float uWaveAmp;     // vertical wave displacement amount (near rows)
+uniform float uWaveSpeed;   // animation rate; 0 freezes the surface
+uniform float uGridX;       // column-grid density across the surface; keep loose
+uniform float uHorizon;     // horizon height in uv.y units (rows converge toward it)
+uniform float uFarScale;    // perspective scale of the farthest row, 0.05..0.5 (>0)
+uniform float uSlant;       // diagonal tilt; raises the right side for corner composition
+uniform float uLineWidth;   // wireframe line half-width (smaller = finer, sharper)
+uniform float uNodeMix;     // 0..1 emphasis of glowing intersection nodes (dot reading)
+uniform float uStrutMix;    // 0..1 emphasis of vertical struts (wireframe reading)
+uniform float uGlow;        // overall additive mesh-glow / bloom strength
+uniform float uHaze;        // atmospheric far-haze strength
+uniform float uParticles;   // floating-particle intensity; 0 disables the field
+uniform float uAccent;      // lone accent-mote intensity; 0 disables it
+uniform float uCalm;        // 0..1 eases the additive glow at frame center (face zone)
+
+in highp vec2 vUv;
+out vec4 oColor;
+
+// ROWS / PARTICLES must stay compile-time constants (GLSL ES loop bounds). ROWS is
+// kept modest on purpose (loose mesh); perspective bunching toward the horizon
+// makes it read as far more lines than it costs.
+#define ROWS                18
+#define PARTICLES           10
+#define WAVE_DEPTH_SPAN     4.5   // world-depth the eased row range maps across
+#define COL_SHARP           48.0  // column-stripe sharpness in cell-phase units
+#define Y_NEAR             (-0.62) // nearest row baseline (just below the bottom edge)
+
+// Cheap stable hash for the particle field (highp; the 43758.5453 multiplier
+// bands under mediump, same note as clouds/nebula).
+float hash11(float n) {
+  return fract(sin(n * 12.9898) * 43758.5453123);
+}
+
+// The shared surface. x is perspective world-x, z is eased world-depth, t is time.
+// A small sum of sines whose x/z cross terms produce the hills, valleys, and
+// saddles; bounded to roughly [-1.6, 1.6].
+float waveField(float x, float z, float t) {
+  float h = 0.0;
+  h += sin(x * 1.00 + z * 0.55 + t) * 0.60;
+  h += sin(x * 0.55 - z * 0.95 - t * 0.70) * 0.45;
+  h += sin((x + z) * 0.45 + t * 0.40 + 1.7) * 0.40; // diagonal ridges -> saddles
+  h += sin(x * 1.70 - z * 0.30 + t * 1.20) * 0.16;  // fine ripple
+  return h;
+}
+
+void main() {
+  vec2 fragCoord = vUv * uResolution;
+  vec2 uv = (fragCoord - 0.5 * uResolution) / uResolution.y; // centered, aspect-correct
+
+  // Background: smooth vertical gradient, no texture. g = 0 bottom .. 1 top.
+  float g = clamp(uv.y + 0.5, 0.0, 1.0);
+  vec3 col = mix(uBgBottom, uBgTop, g);
+
+  // Ease additive glow near the frame center (the subject's face sits there).
+  float calm = 1.0 - uCalm * (1.0 - smoothstep(0.18, 0.62, length(uv)));
+
+  float t = uTime * uWaveSpeed;
+  float horizon = clamp(uHorizon, -0.2, 0.45);
+
+  // Line-glow widths from the half-width. The core line keeps the one exp() (its
+  // sharp gaussian is the wireframe signature); the bloom halo and the vertical
+  // strut use rational falloffs (1/(1+k·dy^2)) instead of more exp() calls, which
+  // are ~8x-weighted transcendentals on the hot per-row path. The node reuses the
+  // core exp directly. Net: 2 exp/row (core + column), down from 5.
+  float coreSharp = 1.0 / max(uLineWidth * uLineWidth, 1e-5);
+  float haloK = coreSharp * 0.14;  // rational-bloom width (matches the old halo half-width)
+  float strutK = coreSharp * 0.14; // rational vertical-bridge width
+
+  vec3 mesh = vec3(0.0);
+  vec3 haze = vec3(0.0);
+
+  for (int i = 0; i < ROWS; i++) {
+    float rowT = float(i) / float(ROWS - 1);     // 0 near .. 1 far
+    float om = 1.0 - rowT;
+    float f = 1.0 - om * om;                      // eased depth: rows bunch toward horizon
+    float persp = mix(1.0, uFarScale, f);
+    persp = max(persp, uFarScale);                // guard the divide (uFarScale > 0)
+
+    // Row baseline in screen-y, with a diagonal tilt for corner composition.
+    float baseY = mix(Y_NEAR, horizon, f) + uv.x * uSlant * persp;
+
+    // Early-out: skip the sines for any row that cannot reach this pixel. Margin
+    // covers the max wave displacement plus the strut's vertical bridge.
+    float reach = persp * uWaveAmp * 1.7 + uLineWidth * 3.0 + 0.06;
+    if (abs(uv.y - baseY) > reach) continue;
+
+    float worldX = uv.x / persp;
+    float h = waveField(worldX * uWaveScale, f * WAVE_DEPTH_SPAN, t);
+    float surfY = baseY + persp * uWaveAmp * h;
+    float dy = uv.y - surfY;
+
+    // Crest factor: peaks of the field glow white, troughs stay the line tint.
+    float crest = smoothstep(0.2, 1.4, h);
+
+    // Horizontal ribbon: sharp gaussian core (the line) + rational bloom halo.
+    float dy2 = dy * dy;
+    float core = exp(-dy2 * coreSharp);
+    float ribbon = core + 0.22 / (1.0 + dy2 * haloK);
+
+    // Column grid: one bright stripe per cell of worldX. cph = 0 at the stripe.
+    float cph = fract(worldX * uGridX) - 0.5;
+    float colLine = exp(-cph * cph * COL_SHARP);
+
+    // Vertical strut (rational falloff in y so it bridges toward neighbors, gated
+    // by the column) and the intersection node (core line x column -> a glowing
+    // dot; reuses the core exp, no extra transcendental).
+    float strut = colLine / (1.0 + dy2 * strutK);
+    float node = core * colLine;
+
+    // Atmospheric fade: far rows dim and tint toward the haze color.
+    float fade = om * om;                          // 1 near .. 0 far
+    float lit = ribbon + uStrutMix * strut + uNodeMix * node * 2.0;
+    vec3 lineCol = mix(uLineColor, uCrestColor, crest);
+
+    // Crest-dominant brightness: troughs stay dim, peaks carry the illumination.
+    mesh += lineCol * lit * fade * (0.35 + 1.0 * crest);
+    haze += uHazeColor * ribbon * (1.0 - fade) * crest;
+  }
+
+  col += mesh * uGlow * calm;
+  col += haze * uHaze * calm;
+
+  // Sparse floating particles; index 0 is the lone accent mote (independent of
+  // uParticles so an accent can show with the particle field off).
+  if (uParticles > 0.0 || uAccent > 0.0) {
+    vec3 motes = vec3(0.0);
+    for (int p = 0; p < PARTICLES; p++) {
+      float fp = float(p);
+      vec2 seed = vec2(hash11(fp * 1.7 + 0.3), hash11(fp * 3.1 + 1.9));
+      vec2 ppos = (seed * 2.0 - 1.0) * vec2(0.92, 0.46);
+      ppos.x += sin(uTime * 0.07 + fp * 2.3) * 0.03;
+      ppos.y += cos(uTime * 0.05 + fp * 1.7) * 0.03;
+      float twinkle = 0.5 + 0.5 * sin(uTime * (0.6 + hash11(fp * 5.0)) + fp * 4.0);
+      float pd = length(uv - ppos);
+      float glint = exp(-pd * pd * 2300.0) * twinkle;
+      vec3 pcol = (p == 0) ? uAccentColor * uAccent : uCrestColor * uParticles;
+      motes += pcol * glint;
+    }
+    col += motes * calm;
+  }
+
+  // Soft highlight rolloff: fold the additive foreground pile-up into clean white
+  // crests instead of a clipped slab; leaves the dark gradient essentially intact.
+  col = vec3(1.0) - exp(-col);
+
+  oColor = vec4(col, 1.0);
+}
 """
 
   // Generative background shaders, by name. The generic shader processor and
@@ -1698,5 +1871,6 @@ void main() {
     "anamorphic-lensflare" to ANAMORPHIC_LENSFLARE_FRAG,
     "light-beams-and-motes" to LIGHT_BEAMS_AND_MOTES_FRAG,
     "corporate-blobs" to CORPORATE_BLOBS_FRAG,
+    "data-mesh" to DATA_MESH_FRAG,
   )
 }

package/catalog/shaders/data-mesh/data-mesh.form.tsx

@@ -0,0 +1,53 @@
+// Data-mesh's editor form: the shader OWNS its control layout. One
+// <Control uniform="…"/> per uniform; grouped into palette / surface / glow
+// sections so the big color levers, the structural dials, and the additive extras
+// read as three clusters. A new primitive flows in through <Control> without
+// touching this file. Conventional layer id: "mesh".
+
+import {
+  Control,
+  ControlForm,
+  ControlSection,
+  type KaleidoscopeControls,
+} from '../../../src/components/preset-control-panel';
+import { DATA_MESH_CONTROLS } from './data-mesh';
+
+export function DataMeshForm({ uniforms, onPatch, disabled }: KaleidoscopeControls) {
+  return (
+    <ControlForm
+      id="mesh"
+      uniforms={uniforms.mesh ?? {}}
+      onPatch={onPatch}
+      disabled={disabled}
+      controls={DATA_MESH_CONTROLS}
+    >
+      <ControlSection title="palette">
+        <Control uniform="uBgTop" />
+        <Control uniform="uBgBottom" />
+        <Control uniform="uLineColor" />
+        <Control uniform="uCrestColor" />
+        <Control uniform="uHazeColor" />
+        <Control uniform="uAccentColor" />
+      </ControlSection>
+      <ControlSection title="surface">
+        <Control uniform="uWaveScale" />
+        <Control uniform="uWaveAmp" />
+        <Control uniform="uWaveSpeed" />
+        <Control uniform="uGridX" />
+        <Control uniform="uHorizon" />
+        <Control uniform="uFarScale" />
+        <Control uniform="uSlant" />
+        <Control uniform="uLineWidth" />
+        <Control uniform="uNodeMix" />
+        <Control uniform="uStrutMix" />
+      </ControlSection>
+      <ControlSection title="glow">
+        <Control uniform="uGlow" />
+        <Control uniform="uHaze" />
+        <Control uniform="uParticles" />
+        <Control uniform="uAccent" />
+        <Control uniform="uCalm" />
+      </ControlSection>
+    </ControlForm>
+  );
+}

package/catalog/shaders/data-mesh/data-mesh.frag

@@ -0,0 +1,205 @@
+// Data-mesh: a mid-2000s corporate digital-futurism background. A large smooth
+// three-dimensional wave surface drawn as a fine wireframe of perspective rows,
+// with glowing nodes at the grid intersections, bent into broad hills, valleys,
+// and saddle curves and receding into deep virtual space. Electric crest glow,
+// soft turquoise bloom, faint atmospheric haze on the far rows, and a sparse
+// drift of particles (one of which is the lone accent mote). Enterprise box-art
+// and OEM-wallpaper idiom (Microsoft / Dell / SQL Server / Alienware era), clean
+// negative space for a logo. An opaque BACKGROUND layer; the masked subject
+// composites over it downstream.
+//
+// Technique (performance-first): NO raymarch, NO fbm, NO variable-exponent pow.
+// The surface is a stack of ROWS perspective-spaced ridgelines. Every row samples
+// ONE shared 2D wave field H(worldX, depth, time), so adjacent rows are continuous
+// and read as a single coherent surface rather than independent lines. A row's
+// screen height is its perspective baseline plus H scaled by that row's
+// perspective factor. Per pixel the bounded ROWS loop accumulates an analytic
+// ribbon + strut + node glow; an early-out skips any row whose baseline is outside
+// this pixel's vertical reach BEFORE the sines run, so most rows cost a compare.
+// Keep the mesh loose: ROWS and uGridX are deliberately modest, not hi-def.
+//
+// Overdrive surface: the color set is the mood (uBgTop/uBgBottom gradient,
+// uLineColor mid tint, uCrestColor peak highlight, uHazeColor far atmosphere,
+// uAccentColor the one restrained accent). Structural dials (uWaveScale/Amp/Speed,
+// uGridX, uHorizon, uFarScale, uSlant) set composition and motion; uNodeMix /
+// uStrutMix grade the lines-vs-dots reading; uGlow / uHaze / uParticles / uAccent
+// set the additive extras. uCalm eases the additive glow near frame center, where
+// the masked subject's face sits.
+//
+// UV convention: matches passthrough.vert. vUv = (0, 0) bottom-left, (1, 1)
+// top-right; fragCoord is reconstructed as vUv * uResolution and the centered,
+// aspect-correct uv divides by height. Fully procedural: no input texture, no
+// gl_FragCoord, so net texture flips are zero on every runtime (web/Android/Metal
+// alike).
+//
+// Cross-target correctness: the only divide is worldX = uv.x / persp, and persp is
+// clamped to max(persp, uFarScale) with uFarScale >= 0.05, so it never approaches
+// zero (no Inf/NaN, no highp-vs-mediump divergence at a vanishing line). No fwidth
+// or derivatives (depth fade and haze are analytic, not screen-space). No
+// variable-exponent pow, no atan, no gl_FragCoord, no arrays, no extensions. ROWS
+// and PARTICLES stay compile-time constants (GLSL ES loop bounds); the dynamic
+// continue/break inside are uniform-flow and survive the SPIR-V -> MSL step.
+//
+// Precision: highp float throughout. worldX grows up to ~0.9 / uFarScale and feeds
+// fract() for the column grid, so the field needs the range and the front-to-far
+// dynamic range; mediump would band the gradient and alias the far columns.
+
+#version 300 es
+precision highp float;
+
+uniform float uTime;        // seconds, monotonically increasing; range [0, inf)
+uniform vec2 uResolution;   // framebuffer size in pixels; both components > 0
+uniform vec3 uBgTop;        // background gradient color at the top of frame
+uniform vec3 uBgBottom;     // background gradient color at the bottom of frame
+uniform vec3 uLineColor;    // mid wireframe-line tint (the trough/body color)
+uniform vec3 uCrestColor;   // crest highlight color (brightest along the peaks)
+uniform vec3 uHazeColor;    // atmospheric haze tint on the far rows
+uniform vec3 uAccentColor;  // the one restrained accent (e.g. enterprise red)
+uniform float uWaveScale;   // wave-field spatial frequency; lower = looser, broader hills
+uniform float uWaveAmp;     // vertical wave displacement amount (near rows)
+uniform float uWaveSpeed;   // animation rate; 0 freezes the surface
+uniform float uGridX;       // column-grid density across the surface; keep loose
+uniform float uHorizon;     // horizon height in uv.y units (rows converge toward it)
+uniform float uFarScale;    // perspective scale of the farthest row, 0.05..0.5 (>0)
+uniform float uSlant;       // diagonal tilt; raises the right side for corner composition
+uniform float uLineWidth;   // wireframe line half-width (smaller = finer, sharper)
+uniform float uNodeMix;     // 0..1 emphasis of glowing intersection nodes (dot reading)
+uniform float uStrutMix;    // 0..1 emphasis of vertical struts (wireframe reading)
+uniform float uGlow;        // overall additive mesh-glow / bloom strength
+uniform float uHaze;        // atmospheric far-haze strength
+uniform float uParticles;   // floating-particle intensity; 0 disables the field
+uniform float uAccent;      // lone accent-mote intensity; 0 disables it
+uniform float uCalm;        // 0..1 eases the additive glow at frame center (face zone)
+
+in highp vec2 vUv;
+out vec4 oColor;
+
+// ROWS / PARTICLES must stay compile-time constants (GLSL ES loop bounds). ROWS is
+// kept modest on purpose (loose mesh); perspective bunching toward the horizon
+// makes it read as far more lines than it costs.
+#define ROWS                18
+#define PARTICLES           10
+#define WAVE_DEPTH_SPAN     4.5   // world-depth the eased row range maps across
+#define COL_SHARP           48.0  // column-stripe sharpness in cell-phase units
+#define Y_NEAR             (-0.62) // nearest row baseline (just below the bottom edge)
+
+// Cheap stable hash for the particle field (highp; the 43758.5453 multiplier
+// bands under mediump, same note as clouds/nebula).
+float hash11(float n) {
+  return fract(sin(n * 12.9898) * 43758.5453123);
+}
+
+// The shared surface. x is perspective world-x, z is eased world-depth, t is time.
+// A small sum of sines whose x/z cross terms produce the hills, valleys, and
+// saddles; bounded to roughly [-1.6, 1.6].
+float waveField(float x, float z, float t) {
+  float h = 0.0;
+  h += sin(x * 1.00 + z * 0.55 + t) * 0.60;
+  h += sin(x * 0.55 - z * 0.95 - t * 0.70) * 0.45;
+  h += sin((x + z) * 0.45 + t * 0.40 + 1.7) * 0.40; // diagonal ridges -> saddles
+  h += sin(x * 1.70 - z * 0.30 + t * 1.20) * 0.16;  // fine ripple
+  return h;
+}
+
+void main() {
+  vec2 fragCoord = vUv * uResolution;
+  vec2 uv = (fragCoord - 0.5 * uResolution) / uResolution.y; // centered, aspect-correct
+
+  // Background: smooth vertical gradient, no texture. g = 0 bottom .. 1 top.
+  float g = clamp(uv.y + 0.5, 0.0, 1.0);
+  vec3 col = mix(uBgBottom, uBgTop, g);
+
+  // Ease additive glow near the frame center (the subject's face sits there).
+  float calm = 1.0 - uCalm * (1.0 - smoothstep(0.18, 0.62, length(uv)));
+
+  float t = uTime * uWaveSpeed;
+  float horizon = clamp(uHorizon, -0.2, 0.45);
+
+  // Line-glow widths from the half-width. The core line keeps the one exp() (its
+  // sharp gaussian is the wireframe signature); the bloom halo and the vertical
+  // strut use rational falloffs (1/(1+k·dy^2)) instead of more exp() calls, which
+  // are ~8x-weighted transcendentals on the hot per-row path. The node reuses the
+  // core exp directly. Net: 2 exp/row (core + column), down from 5.
+  float coreSharp = 1.0 / max(uLineWidth * uLineWidth, 1e-5);
+  float haloK = coreSharp * 0.14;  // rational-bloom width (matches the old halo half-width)
+  float strutK = coreSharp * 0.14; // rational vertical-bridge width
+
+  vec3 mesh = vec3(0.0);
+  vec3 haze = vec3(0.0);
+
+  for (int i = 0; i < ROWS; i++) {
+    float rowT = float(i) / float(ROWS - 1);     // 0 near .. 1 far
+    float om = 1.0 - rowT;
+    float f = 1.0 - om * om;                      // eased depth: rows bunch toward horizon
+    float persp = mix(1.0, uFarScale, f);
+    persp = max(persp, uFarScale);                // guard the divide (uFarScale > 0)
+
+    // Row baseline in screen-y, with a diagonal tilt for corner composition.
+    float baseY = mix(Y_NEAR, horizon, f) + uv.x * uSlant * persp;
+
+    // Early-out: skip the sines for any row that cannot reach this pixel. Margin
+    // covers the max wave displacement plus the strut's vertical bridge.
+    float reach = persp * uWaveAmp * 1.7 + uLineWidth * 3.0 + 0.06;
+    if (abs(uv.y - baseY) > reach) continue;
+
+    float worldX = uv.x / persp;
+    float h = waveField(worldX * uWaveScale, f * WAVE_DEPTH_SPAN, t);
+    float surfY = baseY + persp * uWaveAmp * h;
+    float dy = uv.y - surfY;
+
+    // Crest factor: peaks of the field glow white, troughs stay the line tint.
+    float crest = smoothstep(0.2, 1.4, h);
+
+    // Horizontal ribbon: sharp gaussian core (the line) + rational bloom halo.
+    float dy2 = dy * dy;
+    float core = exp(-dy2 * coreSharp);
+    float ribbon = core + 0.22 / (1.0 + dy2 * haloK);
+
+    // Column grid: one bright stripe per cell of worldX. cph = 0 at the stripe.
+    float cph = fract(worldX * uGridX) - 0.5;
+    float colLine = exp(-cph * cph * COL_SHARP);
+
+    // Vertical strut (rational falloff in y so it bridges toward neighbors, gated
+    // by the column) and the intersection node (core line x column -> a glowing
+    // dot; reuses the core exp, no extra transcendental).
+    float strut = colLine / (1.0 + dy2 * strutK);
+    float node = core * colLine;
+
+    // Atmospheric fade: far rows dim and tint toward the haze color.
+    float fade = om * om;                          // 1 near .. 0 far
+    float lit = ribbon + uStrutMix * strut + uNodeMix * node * 2.0;
+    vec3 lineCol = mix(uLineColor, uCrestColor, crest);
+
+    // Crest-dominant brightness: troughs stay dim, peaks carry the illumination.
+    mesh += lineCol * lit * fade * (0.35 + 1.0 * crest);
+    haze += uHazeColor * ribbon * (1.0 - fade) * crest;
+  }
+
+  col += mesh * uGlow * calm;
+  col += haze * uHaze * calm;
+
+  // Sparse floating particles; index 0 is the lone accent mote (independent of
+  // uParticles so an accent can show with the particle field off).
+  if (uParticles > 0.0 || uAccent > 0.0) {
+    vec3 motes = vec3(0.0);
+    for (int p = 0; p < PARTICLES; p++) {
+      float fp = float(p);
+      vec2 seed = vec2(hash11(fp * 1.7 + 0.3), hash11(fp * 3.1 + 1.9));
+      vec2 ppos = (seed * 2.0 - 1.0) * vec2(0.92, 0.46);
+      ppos.x += sin(uTime * 0.07 + fp * 2.3) * 0.03;
+      ppos.y += cos(uTime * 0.05 + fp * 1.7) * 0.03;
+      float twinkle = 0.5 + 0.5 * sin(uTime * (0.6 + hash11(fp * 5.0)) + fp * 4.0);
+      float pd = length(uv - ppos);
+      float glint = exp(-pd * pd * 2300.0) * twinkle;
+      vec3 pcol = (p == 0) ? uAccentColor * uAccent : uCrestColor * uParticles;
+      motes += pcol * glint;
+    }
+    col += motes * calm;
+  }
+
+  // Soft highlight rolloff: fold the additive foreground pile-up into clean white
+  // crests instead of a clipped slab; leaves the dark gradient essentially intact.
+  col = vec3(1.0) - exp(-col);
+
+  oColor = vec4(col, 1.0);
+}