/*{
  "DESCRIPTION": "The 3D Pipes screensaver, raymarched, and it never stops. The pipes are one endless stream of corners walking a 16x16x16 lattice on black: the head lays corners down at a steady rate and the tail eats them away a set distance behind, both ends fractional, so a pipe is consumed as smoothly as it is drawn and new pipes are always being laid while older ones are taken apart. Nothing fades out and the picture never empties. It is still a closed form of the clock - the head is just TIME times a rate - so it can be scrubbed, paused or resumed anywhere and it draws exactly the state that instant deserves; there is no feedback buffer and no state between frames. Right-angle turns, ball joints or real quarter-torus elbows, and a polished floor below that really mirrors the network - that reflection is a second march, grazing-weighted and eaten by distance so the horizon dissolves. The pipes carry animated procedural surfaces driven by distance along the pipe, angle around it and time, so a pattern flows the length of a pipe and round its corners instead of restarting at every joint. Twenty-four of them: plain, flowing rainbow, racing pulses, candy helix, plasma, electric arcs, oil-film iridescence, furnace heat, hazard stripes, circuit traces, overlapping scales, wave beats, zebra, starfield, thermal false-colour, time-quantised glitch, obsidian, blacklight, hologram, magma cracks, falling code, ice, hammered gold and broken static - each with its own emissive glow, which reaches the interreflections and the mirror as well as the surface. Every joint also flashes as it lands and cools off behind the advancing tip, which the shader can only draw because it knows not just where each corner is but exactly how long ago it was laid. Sliders for growth speed, how much pipe stays alive, corners per pipe, straight length, wander, spread, pipe radius, joint size, ball or elbow, bend radius, chrome, saturation, hue, metalness, roughness, interreflection, shadows, ambient occlusion, key light, ambient, sheen, pattern style, pattern blend, pattern scale, pattern speed, glow, floor, mirror, tip glow, orbit speed, distance, height, field of view, exposure, vignette and grain.",
  "CREDIT": "CC0",
  "CATEGORIES": ["generator", "3d", "retro", "screensaver"],
  "INPUTS": [
    { "NAME": "uSpeed",    "TYPE": "float", "DEFAULT": 1.00,  "MIN": 0.0,  "MAX": 4.0 },
    { "NAME": "uCount",    "TYPE": "float", "DEFAULT": 88.0,  "MIN": 16.0,  "MAX": 88.0 },
    { "NAME": "uRun",      "TYPE": "float", "DEFAULT": 24.0,  "MIN": 8.0,  "MAX": 32.0 },
    { "NAME": "uLen",      "TYPE": "float", "DEFAULT": 4.0,   "MIN": 1.0,  "MAX": 6.0 },
    { "NAME": "uWander",   "TYPE": "float", "DEFAULT": 0.70,  "MIN": 0.0,  "MAX": 1.0 },
    { "NAME": "uSpread",   "TYPE": "float", "DEFAULT": 0.60,  "MIN": 0.0,  "MAX": 1.0 },
    { "NAME": "uRadius",   "TYPE": "float", "DEFAULT": 0.155, "MIN": 0.06, "MAX": 0.30 },
    { "NAME": "uJoint",    "TYPE": "float", "DEFAULT": 0.245, "MIN": 0.08, "MAX": 0.40 },
    { "NAME": "uElbow",    "TYPE": "float", "DEFAULT": 0.0,   "MIN": 0.0,  "MAX": 1.0 },
    { "NAME": "uBend",     "TYPE": "float", "DEFAULT": 0.40,  "MIN": 0.20, "MAX": 0.45 },
    { "NAME": "uChrome",   "TYPE": "float", "DEFAULT": 0.14,  "MIN": 0.0,  "MAX": 1.0 },
    { "NAME": "uSat",      "TYPE": "float", "DEFAULT": 0.92,  "MIN": 0.0,  "MAX": 1.0 },
    { "NAME": "uHue",      "TYPE": "float", "DEFAULT": 0.0,   "MIN": 0.0,  "MAX": 1.0 },
    { "NAME": "uMetal",    "TYPE": "float", "DEFAULT": 0.60,  "MIN": 0.0,  "MAX": 1.0 },
    { "NAME": "uRough",    "TYPE": "float", "DEFAULT": 0.12,  "MIN": 0.02, "MAX": 0.60 },
    { "NAME": "uReflect",  "TYPE": "float", "DEFAULT": 0.70,  "MIN": 0.0,  "MAX": 1.0 },
    { "NAME": "uShadow",   "TYPE": "float", "DEFAULT": 0.70,  "MIN": 0.0,  "MAX": 1.0 },
    { "NAME": "uAO",       "TYPE": "float", "DEFAULT": 0.80,  "MIN": 0.0,  "MAX": 1.0 },
    { "NAME": "uLight",    "TYPE": "float", "DEFAULT": 1.35,  "MIN": 0.0,  "MAX": 3.0 },
    { "NAME": "uAmbient",  "TYPE": "float", "DEFAULT": 0.42,  "MIN": 0.0,  "MAX": 1.0 },
    { "NAME": "uSheen",    "TYPE": "float", "DEFAULT": 0.85,  "MIN": 0.0,  "MAX": 1.5 },
    { "NAME": "uStyle",    "TYPE": "float", "DEFAULT": 1.0,   "MIN": 0.0,  "MAX": 23.0 },
    { "NAME": "uPatMix",   "TYPE": "float", "DEFAULT": 1.00,  "MIN": 0.0,  "MAX": 1.0 },
    { "NAME": "uPatScale", "TYPE": "float", "DEFAULT": 1.00,  "MIN": 0.2,  "MAX": 4.0 },
    { "NAME": "uPatSpeed", "TYPE": "float", "DEFAULT": 1.00,  "MIN": 0.0,  "MAX": 3.0 },
    { "NAME": "uEmit",     "TYPE": "float", "DEFAULT": 1.00,  "MIN": 0.0,  "MAX": 3.0 },
    { "NAME": "uFloor",    "TYPE": "float", "DEFAULT": 1.00,  "MIN": 0.0,  "MAX": 1.0 },
    { "NAME": "uMirror",   "TYPE": "float", "DEFAULT": 0.80,  "MIN": 0.0,  "MAX": 1.0 },
    { "NAME": "uTipGlow",  "TYPE": "float", "DEFAULT": 0.65,  "MIN": 0.0,  "MAX": 2.0 },
    { "NAME": "uOrbit",    "TYPE": "float", "DEFAULT": 0.22,  "MIN": 0.0,  "MAX": 1.0 },
    { "NAME": "uDist",     "TYPE": "float", "DEFAULT": 21.0,  "MIN": 10.0,  "MAX": 48.0 },
    { "NAME": "uHeight",   "TYPE": "float", "DEFAULT": 2.20,  "MIN": -4.0, "MAX": 6.0 },
    { "NAME": "uFov",      "TYPE": "float", "DEFAULT": 1.25,  "MIN": 0.6,  "MAX": 2.2 },
    { "NAME": "uExposure", "TYPE": "float", "DEFAULT": 1.00,  "MIN": 0.2,  "MAX": 2.5 },
    { "NAME": "uVignette", "TYPE": "float", "DEFAULT": 0.45,  "MIN": 0.0,  "MAX": 1.0 },
    { "NAME": "uGrain",    "TYPE": "float", "DEFAULT": 0.03,  "MIN": 0.0,  "MAX": 0.30 }
  ]
}*/
#define PI 3.14159265359

// iq's anti-unroll guard. ANGLE hands GLSL to the D3D compiler, which tries to
// fully unroll every constant-bound loop; with a 7x8 scene loop inlined into a
// march, an AO tap, a shadow and a reflection bounce, the D3D backend gave up
// and returned a link failure with an EMPTY info log. Starting each loop at a
// value it cannot prove is zero stops the unrolling dead: 45 ms to link.
//
// It cannot ship in the ISF - GLSL ES 1.00 demands a constant loop initialiser
// and rejects this outright - so isf_convert.py rewrites the line below to
// "#define ZERO 0", which the preprocessor folds back into a constant.
#define ZERO 0

// 120 lattice corners, plus two sentinels so reading k+1 and k+2 is always in
// range. The sentinels carry pipe id 31, which no real pipe ever gets (a run is
// at least 8 corners long, so 120 corners hold at most 15 pipes, ids 0..14),
// and a pipe id mismatch is exactly how the shader spots the end of a pipe.
// The pipe field had to widen from 8 ids to 32 for that headroom: at 120
// corners the old sentinel value 15 was reachable by a real pipe.
#define NSEG 120
#define NPT  122
#define NCH  15
#define GRID 16.0

float gPts[NPT];   // packed lattice corners
vec4  gB[NCH];     // bounding sphere per chunk of 8 corners: xyz centre, w radius
// The network is an endless stream of corners with a window cut out of it.
// gHead is how far the stream has been drawn (fractional, unbounded); gTail is
// how far it has been eaten from behind. Nothing ever fades: pipes grow at the
// head while older ones are consumed at the tail, so there is always about
// uCount corners of pipe alive and the picture never empties.
float gHead;       // leading corner index, fractional
float gTail;       // trailing corner index, fractional
float gG0;         // stream index of array slot 0 - always a pipe boundary
float gRun;        // corners per pipe, whole
float gEmit;       // how hard the surface under the last surfAt() is glowing
float gGloss;      // and whether that style wants to stay a mirror

// Dave Hoskins' hash, not the usual fract(sin(x)*43758.5): the sin version
// wants sin() of arguments in the tens of thousands, where float32 argument
// reduction is worth only a few bits and two implementations disagree.
//
// This one now drives the film grain and nothing else. Grain is the one place
// where a value that differs in its last bits between two GPUs does not matter,
// because nobody can point at a grain speckle and say it is in the wrong place.
// Everything that decides the shape uses ihash() below.
float h11(float p){
  p = fract(p * 0.1031);
  p *= p + 33.33;
  p *= p + p;
  return fract(p);
}
// Anything that decides the SHAPE uses this instead: integer arithmetic
// carried in floats, where every intermediate is a whole number below 2^24 and
// float32 is exact, so two implementations cannot disagree about it.
//
// The float hash above was the second one to get this wrong. It is stable for
// small inputs, but the walk feeds it corner index times a multiplier, so by
// corner 47 it was handing fract() numbers in the hundreds - and up there
// float32 has already discarded the bits that decide which way a pipe turns.
// The WebGL2 build and the ISF build drew measurably different networks from
// the same seed: mean pixel difference 0.02/255 at TIME 8, 9.2/255 at TIME
// 61.6, with whole segments present in one and missing in the other.
//
// 4091 is prime and 3 does not divide 4090, so n -> n^3 is a permutation of the
// residues; three affine-then-cube rounds measure as well as a true RNG on
// lag-1 autocorrelation at every stride the shader actually steps by. The
// cube is split in two so the largest intermediate is 4090^2, just inside
// exact range.
#define IM 4091.0
float ihash(float n){
  n = mod(n, IM);
  n = mod(n * 3192.0 + 3096.0, IM); n = mod(mod(n * n, IM) * n, IM);
  n = mod(n *  745.0 +  531.0, IM); n = mod(mod(n * n, IM) * n, IM);
  n = mod(n * 1109.0 + 3358.0, IM); n = mod(mod(n * n, IM) * n, IM);
  return n * (1.0 / IM);
}
vec3 ihash3(float n){
  return vec3(ihash(n), ihash(n + 1949.0), ihash(n + 3803.0));
}

// ---- packing ---------------------------------------------------------------
// A corner is just a cell in a 16x16x16 lattice now, one exact integer in
// 0..4095. The pipe id and the "starts here" flag used to be packed alongside
// it; with pipes a fixed number of corners long, both are arithmetic on the
// stream index instead - which also retired the sentinel value that had to be
// widened every time the corner budget grew.
float packPt(vec3 c){ return c.x + 16.0 * c.y + 256.0 * c.z; }
vec3 cellOf(float v){
  float q = mod(v, 4096.0);
  return vec3(mod(q, 16.0), mod(floor(q / 16.0), 16.0), floor(q / 256.0));
}
float pipeAtG(float g){ return floor(g / gRun); }          // which pipe
float startsAt(float g){ return mod(g, gRun) < 0.5 ? 1.0 : 0.0; }
float endsAt(float g){ return mod(g + 1.0, gRun) < 0.5 ? 1.0 : 0.0; }
vec3  posOf(float v){ return cellOf(v) - vec3((GRID - 1.0) * 0.5); }

// ---- the walk --------------------------------------------------------------
// A self-avoiding-ish random walk on the lattice: every corner is a 90 degree
// turn, straights are 1..uLen cells, and each candidate direction is scored on
// three things - a random roll, how far it moves away from where the pipe has
// just been (a running mean of recent corners), and a pull back toward the
// middle of the box. That last term is what keeps a pipe from crawling along a
// wall, and the middle one is what stops it folding back through itself.
void buildPath(){
  vec3 cell = vec3(0.0), dir = vec3(1.0, 0.0, 0.0), ema = vec3(0.0);
  float last = 0.0;

  for (int i = ZERO; i < NSEG; i++){
    float g = gG0 + float(i);
    if (g > gHead + 1.0) break;               // not drawn yet, and not needed
    // The pipe index, wrapped so the hash keys stay exact integers however long
    // the shader has been running. 512 pipes is well over an hour.
    float pw = mod(pipeAtG(g), 512.0);

    if (startsAt(g) > 0.5){                   // a new pipe begins at this corner
      float sk = pw * 571.0;
      vec3  r  = ihash3(sk);
      cell = floor(r * (GRID - 2.0)) + 1.0;
      float a = floor(ihash(sk + 11.0) * 3.0);
      dir  = (1.0 - min(abs(a - vec3(0.0, 1.0, 2.0)), 1.0))
             * (ihash(sk + 23.0) < 0.5 ? -1.0 : 1.0);
      ema  = cell;
    }

    gPts[i] = packPt(cell);
    last    = gPts[i];

    float within = mod(g, gRun);
    float best = -1e9, blen = 1.0;
    vec3  bdir = dir;
    for (int d = ZERO; d < 6; d++){
      float ax = floor(float(d) * 0.5);
      float sg = 1.0 - 2.0 * mod(float(d), 2.0);
      vec3  v  = (1.0 - min(abs(ax - vec3(0.0, 1.0, 2.0)), 1.0)) * sg;
      if (abs(dot(v, dir)) > 0.5) continue;                 // it has to turn
      float ln  = 1.0 + floor(ihash(pw * 911.0 + within * 13.0 + float(d) * 7.0)
                              * max(uLen, 1.0));
      vec3  tgt = clamp(cell + v * ln, vec3(0.0), vec3(GRID - 1.0));
      float act = length(tgt - cell);
      if (act < 0.5) continue;                              // wall, no room
      // Normalised, or the spread term swamps the roll and the walk collapses
      // into a plane: the first build zigzagged across two axes and never used
      // the third. The centre pull stays unnormalised on purpose - it should do
      // nothing in the middle of the box and shove hard at the wall, and its
      // weight scales inversely with the box or it doubles when the box does.
      vec3  away = cell - ema;
      float al   = length(away);
      float sc = ihash(pw * 337.0 + within * 29.0 + float(d) * 3.0 + 1.0) * uWander
               + dot(v, al > 0.001 ? away / al : vec3(0.0)) * uSpread * 0.50
               + dot(v, vec3((GRID - 1.0) * 0.5) - cell) * (0.8 / GRID);
      if (sc > best){ best = sc; bdir = v; blen = act; }
    }

    dir  = bdir;
    cell = clamp(cell + bdir * blen, vec3(0.0), vec3(GRID - 1.0));
    ema  = mix(ema, cell, 0.40);
  }

  gPts[NSEG] = last;                          // never read as geometry, but the
  gPts[NSEG + 1] = last;                      // k+1 / k+2 reads must be in range

  // One bounding sphere per 8 corners. Nine corners go into each, because the
  // eighth segment of a chunk reaches into the next one. This is the whole
  // acceleration structure: a march step tests fifteen spheres and only opens
  // the chunks that could possibly be nearer than what it already holds.
  float pad = max(uJoint, uBend + uRadius) + 0.35;
  for (int c = ZERO; c < NCH; c++){
    vec3  lo = vec3(1e6), hi = vec3(-1e6);
    float any = 0.0;
    for (int j = ZERO; j < 9; j++){
      float g = gG0 + float(c * 8 + j);
      if (g > gHead) break;
      if (g + 1.0 < gTail) continue;          // eaten; contributes no geometry
      vec3 w = posOf(gPts[c * 8 + j]);
      lo = min(lo, w); hi = max(hi, w); any = 1.0;
    }
    gB[c] = any > 0.5 ? vec4((lo + hi) * 0.5, length(hi - lo) * 0.5 + pad)
                      : vec4(0.0, 0.0, 0.0, -1000.0);
  }
}

// ---- primitives ------------------------------------------------------------
float sdCapsule(vec3 p, vec3 a, vec3 b, float r){
  vec3 pa = p - a, ba = b - a;
  float h = clamp(dot(pa, ba) / max(dot(ba, ba), 1e-6), 0.0, 1.0);
  return length(pa - ba * h) - r;
}

// A real quarter torus. The pipe arrives along a and leaves along b; the arc
// centre sits at R*(b-a) from the corner, which is the one point R away from
// both pipe axes, and the arc sweeps from -R*b round to +R*a. Clamping the
// in-plane coordinates into that quadrant before projecting onto the circle is
// what keeps the elbow a quarter and not a full ring hanging in the air.
float sdElbow(vec3 p, vec3 a, vec3 b, float R, float r){
  vec3  o  = R * (b - a);
  vec3  q  = p - o;
  float qa = max(dot(q, a), 0.0);
  float qb = min(dot(q, b), 0.0);
  float l  = length(vec2(qa, qb));
  vec3  nr = l > 1e-5 ? o + (a * qa + b * qb) * (R / l) : o + a * R;
  return length(p - nr) - r;
}

// ---- the scene -------------------------------------------------------------
float mapPipes(vec3 p){
  float d = 1e6;
  float bend = uElbow > 0.5 ? uBend : 0.0;

  for (int c = ZERO; c < NCH; c++){
    if (length(p - gB[c].xyz) - gB[c].w > d) continue;

    for (int j = ZERO; j < 8; j++){
      float g = gG0 + float(c * 8 + j);
      if (g >= gHead) break;                       // not drawn yet

      // How much of the segment from corner g to g+1 is alive: the tail has
      // eaten up to s0 and the head has drawn up to s1. Both ends are
      // fractional, so a pipe is consumed as smoothly as it is laid down.
      float s0 = clamp(gTail - g, 0.0, 1.0);
      float s1 = clamp(gHead - g, 0.0, 1.0);
      if (s1 <= s0) continue;                      // wholly eaten

      vec3  A = posOf(gPts[c * 8 + j]);
      if (endsAt(g) > 0.5){                        // last corner of its pipe
        if (g >= gTail) d = min(d, length(p - A) - uJoint);
        continue;
      }
      if (startsAt(g) > 0.5 && s0 <= 0.0) d = min(d, length(p - A) - uJoint);

      vec3  B  = posOf(gPts[c * 8 + j + 1]);
      vec3  ab = normalize(B - A);
      vec3  P0 = mix(A, B, s0), P1 = mix(A, B, s1);
      float goes = endsAt(g + 1.0) > 0.5 ? 0.0 : 1.0;   // does it turn at B
      float e0 = (startsAt(g) > 0.5 || s0 > 0.0) ? 0.0 : bend;
      float e1 = (s1 >= 1.0 ? goes : 0.0) * bend;
      d = min(d, sdCapsule(p, P0 + ab * e0, P1 - ab * e1, uRadius));

      if (s1 < 1.0) continue;                      // still growing toward B
      if (goes < 0.5){ d = min(d, length(p - B) - uJoint); continue; }

      if (uElbow > 0.5){
        d = min(d, sdElbow(p - B, ab, normalize(posOf(gPts[c * 8 + j + 2]) - B),
                           uBend, uRadius));
      } else {
        d = min(d, length(p - B) - uJoint);
      }
    }
  }
  return d;
}

// Where on the network a surface point is: which pipe owns it, how far along
// that pipe it lies, and where it sits around the pipe's circumference. The
// distance-along is what makes a pattern able to FLOW: it is accumulated across
// segments in order and reset at each pipe's start, so a stripe can run the
// length of a pipe and round its corners instead of restarting at every joint.
//
// Nearest segment, not nearest corner - the corner version painted a pipe in
// two colours wherever another pipe crossed nearer to it than its own next
// joint. Only ever asked at a hit point, so a linear scan is fine; the chunk
// bounding spheres are skipped here because the running length has to be
// accumulated in order.
void surfAt(vec3 p, out float id, out float flow, out float ang){
  float best = 1e6, run = 0.0;
  vec3  bA = vec3(0.0), bax = vec3(1.0, 0.0, 0.0);
  float bh = 0.0;
  id = 0.0; flow = 0.0; ang = 0.0;

  for (int c = ZERO; c < NCH; c++){
    // The chunk bounding spheres still apply, but a skipped chunk cannot just
    // be jumped over: the running length has to pass through it. So a far
    // chunk still walks its segments, it just does not do the geometry.
    bool near = length(p - gB[c].xyz) - gB[c].w <= best;
    for (int j = ZERO; j < 8; j++){
      float g = gG0 + float(c * 8 + j);
      if (g >= gHead) break;
      // The running length is measured from where the pipe originally started,
      // not from where the tail has eaten to, so a pattern stays put on the
      // pipe while it is being consumed instead of sliding along it.
      if (startsAt(g) > 0.5) run = 0.0;
      if (endsAt(g) > 0.5) continue;
      vec3  A   = posOf(gPts[c * 8 + j]);
      vec3  ba  = posOf(gPts[c * 8 + j + 1]) - A;
      // Every segment is axis-aligned, so its length is the sum of the
      // magnitudes of its components - no square root anywhere in this loop.
      float len = max(dot(abs(ba), vec3(1.0)), 1e-4);
      if (near && gHead - g > 0.0 && gTail - g < 1.0){
        vec3  ax = ba / len;
        float h  = clamp(dot(p - A, ax), 0.0, len);
        float d  = length(p - A - ax * h);
        if (d < best){
          best = d; id = pipeAtG(g); flow = run + h;
          bA = A; bax = ax; bh = h;
        }
      }
      run += len;
    }
  }

  // The angle needs a frame perpendicular to the axis, built once for the
  // winner rather than for every segment tested.
  vec3 u = normalize(abs(bax.y) < 0.9 ? cross(bax, vec3(0.0, 1.0, 0.0))
                                      : cross(bax, vec3(1.0, 0.0, 0.0)));
  vec3 w = cross(bax, u);
  vec3 r = p - bA - bax * bh;
  ang = atan(dot(r, w) + 1e-7, dot(r, u) + 1e-7);
}

// Tetrahedron, not central differences: four scene lookups instead of six for
// the same normal. Normals are taken at the primary hit, at the mirror hit and
// at the interreflection hit, so the two saved lookups are worth three each.
vec3 normalAt(vec3 p){
  vec2 k = vec2(1.0, -1.0) * 0.0016;
  return normalize(k.xyy * mapPipes(p + k.xyy) + k.yyx * mapPipes(p + k.yyx)
                 + k.yxy * mapPipes(p + k.yxy) + k.xxx * mapPipes(p + k.xxx));
}

float aoAt(vec3 p, vec3 n){
  float s = 0.0, w = 1.0;
  for (int i = ZERO + 1; i <= 5; i++){
    float h = 0.035 * float(i) * float(i);
    s += w * max(h - mapPipes(p + n * h), 0.0) / h;
    w *= 0.65;
  }
  return clamp(1.0 - s * 0.55 * uAO, 0.0, 1.0);
}

float shadowAt(vec3 ro, vec3 rd){
  float res = 1.0, t = 0.08;
  for (int i = ZERO; i < 20; i++){
    float h = mapPipes(ro + rd * t);
    res = min(res, 13.0 * h / t);
    t += clamp(h, 0.07, 0.75);
    if (res < 0.02 || t > 16.0) break;
  }
  return clamp(res, 0.0, 1.0);
}

// ---- the light -------------------------------------------------------------
// There is no room. The background is black, permanently: no walls, no floor
// checker, no ceiling panel, no slider to bring any of it back. What is left is
// one key light above and to one side - off camera, and off-centre on purpose,
// because straight overhead every shadow lands directly under its pipe and
// reads as a smudge.
#define LIGHTP vec3(3.6, 5.85, 2.6)

// ...and a two-lobe studio gradient, which is what a reflection lands on now
// that there is nothing to reflect. It is a lighting function, not a scene: it
// is never drawn, only sampled by reflected rays, and uSheen turns it off.
vec3 envAt(vec3 dir){
  float up  = dir.y * 0.5 + 0.5;
  vec3  col = mix(vec3(0.020, 0.023, 0.032), vec3(0.10, 0.12, 0.16), up * up);
  vec3  L   = normalize(LIGHTP);
  col += vec3(0.85, 0.87, 0.95) * pow(max(dot(dir, L), 0.0), 6.0) * 0.55;
  col += vec3(0.30, 0.42, 0.70) * pow(max(dot(dir, normalize(vec3(-4.0, 1.2, -3.0))), 0.0), 4.0) * 0.22;
  return col * uSheen;
}

// ---- colour ----------------------------------------------------------------
vec3 hue2rgb(float h){
  return clamp(abs(mod(h * 6.0 + vec3(0.0, 4.0, 2.0), 6.0) - 3.0) - 1.0, 0.0, 1.0);
}

vec3 pipeColour(float id){
  // The run picks one random hue and the pipes in it step away by the golden
  // angle. Hashing each pipe independently kept handing a run two blues a few
  // degrees apart, and two pipes the same colour is two pipes you cannot tell
  // apart - the one thing the colour is there to do.
  // Consecutive pipes step by the golden angle, wrapped so the multiply stays
  // precise however far into the stream we are.
  float h = fract(mod(id, 512.0) * 0.381966 + uHue);
  vec3  c = hue2rgb(h);
  c = mix(vec3(1.0), c, uSat);                       // toward white
  return mix(c, vec3(0.86, 0.87, 0.90), uChrome);    // toward chrome
}

// ---- the pipe patterns -----------------------------------------------------
// Eight surface treatments, all of them functions of (distance along the pipe,
// angle around it, world position, time) - which is exactly the coordinate set
// surfAt() hands back. `emit` comes back separately because these are meant to
// glow: an emissive term is added after shading, so a pattern is not something
// the key light has to find in order to be visible.
vec3 pipePattern(vec3 p, vec3 base, float id, float flow, float ang,
                 vec3 n, vec3 rd, out float emit){
  float T = TIME * uPatSpeed;
  float f = flow * uPatScale;
  emit = 0.0;

  if (uStyle < 0.5) return base;                                    // 0 plain

  if (uStyle < 1.5){                                                // 1 flow
    float h = fract(f * 0.10 - T * 0.25 + id * 0.13 + uHue);
    emit = 0.40;
    return hue2rgb(h);
  }
  if (uStyle < 2.5){                                                // 2 pulse
    // Sawtooth, so the leading edge is a wall and the tail is a fade: a comet
    // running down the pipe rather than a sine that breathes in place.
    float k = fract(f * 0.09 - T * 0.55 + id * 0.31);
    float g = pow(1.0 - k, 16.0) + 0.30 * pow(1.0 - k, 3.0);
    emit = g * 1.9;
    return mix(base * 0.30, mix(base, vec3(1.0), 0.80), g);
  }
  if (uStyle < 3.5){                                                // 3 candy
    // Two saturated colours with a hard edge between them. Mixing toward
    // "one minus the base" gave a pair of near-greys and the helix vanished.
    float st = sin(f * 1.7 + ang * 2.0 - T * 2.0);
    vec3  c2 = hue2rgb(fract(id * 0.381966 + 0.47 + uHue));
    emit = 0.28;
    return mix(base, c2, smoothstep(-0.14, 0.14, st));
  }
  if (uStyle < 4.5){                                                // 4 plasma
    float v = sin(p.x * 1.7 + T) + sin(p.y * 1.9 - T * 1.3)
            + sin(p.z * 1.5 + T * 0.7) + sin(length(p.xz) * 2.3 - T * 1.7);
    emit = 0.50;
    return hue2rgb(fract(v * 0.11 + id * 0.2 + uHue));
  }
  if (uStyle < 5.5){                                                // 5 arc
    float a1 = sin(f * 2.7 + T * 3.1 + id * 2.0) * sin(ang * 2.0 - T * 1.9);
    float a2 = sin(f * 5.3 - T * 4.3) * sin(ang * 3.0 + T * 2.7);
    float arc = pow(max(0.0, 1.0 - abs(a1 + a2 * 0.6) * 2.2), 5.0);
    emit = arc * 3.0;
    return mix(base * 0.24, vec3(0.72, 0.90, 1.0), arc);
  }
  if (uStyle < 6.5){                                                // 6 oil
    // Thin film: the hue is a function of how edge-on the surface is, so the
    // bands sit still on the pipe and swim when the camera moves.
    float ct = 1.0 - abs(dot(n, -rd));
    emit = 0.22;
    return mix(base, hue2rgb(fract(ct * 1.7 + f * 0.02 - T * 0.10 + uHue)), 0.9);
  }
  if (uStyle < 7.5){                                                // 7 furnace
    // Cold iron with hot bands running through it. The first version used a
    // soft falloff and a mid-orange floor, so every pipe sat at the same
    // lukewarm tan; the body has to be nearly black for the hot part to read.
    float q    = fract(f * 0.06 - T * 0.40);
    float turb = 0.5 + 0.5 * sin(f * 2.3 + T * 3.0 + ang * 1.7)
                           * sin(f * 0.7 - T * 1.1);
    float heat = clamp(pow(1.0 - q, 6.0) * (0.5 + 0.9 * turb), 0.0, 1.0);
    vec3  c    = mix(vec3(0.040, 0.018, 0.010), vec3(1.0, 0.30, 0.03), sqrt(heat));
    c = mix(c, vec3(1.0, 0.85, 0.45), pow(heat, 4.0));
    emit = heat * 2.2;
    return c;
  }
  if (uStyle < 8.5){                                                // 8 hazard
    // Mixing axial and angular in one fract is what tilts the stripes: the
    // ratio between the two is the barber-pole pitch.
    float k = fract(f * 0.55 + ang * 0.55 - T * 0.35);
    float m = smoothstep(0.46, 0.54, k);
    emit = m * 0.55;
    return mix(vec3(0.035, 0.030, 0.020), vec3(1.0, 0.76, 0.04), m);
  }
  if (uStyle < 9.5){                                                // 9 circuit
    float gx = abs(fract(f * 0.5) - 0.5);
    float gy = abs(fract(ang * 1.6) - 0.5);
    float ln = smoothstep(0.07, 0.0, min(gx, gy));
    float dt = pow(max(0.0, 1.0 - abs(fract(f * 0.5 - T * 0.55) - 0.5) * 9.0), 4.0);
    emit = ln * 0.55 + dt * 2.2;
    return mix(vec3(0.015, 0.045, 0.028), vec3(0.24, 1.0, 0.55), ln * 0.65 + dt);
  }
  if (uStyle < 10.5){                                               // 10 scales
    // Every other row offset by half a scale, which is what makes them overlap
    // like roof tiles instead of sitting in a grid.
    float u1  = f * 0.8;
    float v1  = ang * 1.8 + 0.5 * mod(floor(u1), 2.0);
    float d1  = length(vec2(fract(u1) - 0.5, (fract(v1) - 0.5) * 1.2));
    float sc  = smoothstep(0.46, 0.22, d1);
    emit = sc * 0.55;
    return mix(base * 0.12, mix(base, vec3(1.0), 0.55), sc);
  }
  if (uStyle < 11.5){                                               // 11 beat
    // Two travelling waves at different speeds; what you see is the beat
    // between them, which drifts along the pipe on its own schedule.
    float iw = (sin(f * 1.6 - T * 2.0) + sin(f * 2.3 + T * 1.4)) * 0.5;
    float m  = smoothstep(0.55, 0.95, iw);
    emit = m * 1.8;
    return mix(base * 0.12, vec3(0.55, 0.92, 1.0), m);
  }
  if (uStyle < 12.5){                                               // 12 zebra
    float w = sin(f * 1.2 + sin(ang * 2.0 + T * 0.8) * 1.6 + T * 0.5);
    emit = 0.06;
    return mix(vec3(0.025), vec3(0.97), smoothstep(-0.09, 0.09, w));
  }
  if (uStyle < 13.5){                                               // 13 stars
    float ca = floor(f * 6.0), cb = floor(ang * 5.0);
    float r1 = h11(ca * 3.7 + cb * 17.3 + 0.5);
    float tw = 0.5 + 0.5 * sin(T * 3.0 + r1 * 40.0);
    float st = step(0.86, r1) * pow(tw, 3.0);
    emit = st * 3.0;
    return mix(vec3(0.020, 0.020, 0.045), vec3(1.0, 0.95, 0.85), st);
  }
  if (uStyle < 14.5){                                               // 14 thermal
    float w = sin(f * 0.7 + T * 0.5) * 0.5 + sin(ang * 1.5 - T * 0.7) * 0.3
            + sin(f * 0.21 - T * 0.31) * 0.5;
    float k = clamp(w * 0.55 + 0.5, 0.0, 1.0);
    emit = k * 0.9;
    return vec3(smoothstep(0.35, 0.92, k),
                smoothstep(0.12, 0.98, k) * smoothstep(1.06, 0.52, k),
                smoothstep(0.52, 0.0, k));
  }
  if (uStyle < 15.5){                                               // 15 glitch
    // Quantised in space AND in time - the block index and the frame index are
    // both floored, so it jumps rather than slides.
    float blk = floor(f * 2.5) + floor(ang * 3.0) * 31.0;
    float r2  = h11(blk + floor(T * 6.0) * 7.31);
    vec3  c   = hue2rgb(fract(r2 * 3.0 + uHue));
    float hot = step(0.93, r2);
    emit = 0.55 + hot * 1.6;
    return mix(c, vec3(1.0), hot);
  }
  if (uStyle < 16.5){                                             // 16 obsidian
    // Black, and it stays black: no emission at all, so the whole read is the
    // key light skidding off the curve and a cold rim where the surface turns
    // away. This is the one style that wants MORE specular, not less, which is
    // why the gloss damp below is per-style rather than "any pattern is matte".
    float rim = pow(1.0 - abs(dot(n, -rd)), 3.0);
    emit = 0.0;
    return vec3(0.012, 0.013, 0.016) + vec3(0.10, 0.12, 0.17) * rim;
  }
  if (uStyle < 17.5){                                           // 17 blacklight
    float b1 = sin(f * 1.5 - T * 1.1) * sin(ang * 1.7 + T * 0.7);
    float gl = smoothstep(0.1, 0.9, b1);
    emit = gl * 2.0;
    return mix(vec3(0.030, 0.010, 0.055), vec3(0.65, 0.18, 1.0), gl)
         + vec3(0.35, 0.55, 0.30) * pow(gl, 6.0);
  }
  if (uStyle < 18.5){                                            // 18 hologram
    // Scanlines across the pipe plus a fresnel edge, and a flicker that drops
    // the whole thing for a frame now and then the way a bad projection does.
    float scan  = 0.55 + 0.45 * sin(f * 9.0 - T * 5.0);
    float edge  = pow(1.0 - abs(dot(n, -rd)), 2.0);
    float flick = step(0.06, h11(floor(T * 12.0) * 3.7)) * 0.75 + 0.25;
    emit = (scan * 0.5 + edge * 1.6) * flick;
    return vec3(0.20, 0.95, 1.0) * (0.25 + 0.55 * scan + edge) * flick;
  }
  if (uStyle < 19.5){                                               // 19 magma
    // Cracks, not bands: the product of two waves is near zero along curves,
    // and thresholding that gives a branching seam instead of a stripe.
    float w  = sin(f * 1.3 + ang * 2.1) * sin(f * 0.7 - ang * 1.3 + T * 0.3);
    float cr = 1.0 - smoothstep(0.0, 0.10, abs(w));
    float pu = 0.65 + 0.35 * sin(T * 2.0 + f * 0.5);
    emit = cr * 2.4 * pu;
    return mix(vec3(0.018, 0.015, 0.014), vec3(1.0, 0.35, 0.05), cr * pu);
  }
  if (uStyle < 20.5){                                              // 20 matrix
    float cm = floor(ang * 4.0);
    float r3 = h11(cm * 7.3 + 1.7);
    float y  = fract(f * 0.25 - T * (0.45 + r3 * 0.9) - r3);
    float hd = pow(1.0 - y, 26.0);
    float tl = pow(1.0 - y, 3.0);
    emit = hd * 2.6 + tl * 0.45;
    return mix(vec3(0.010, 0.040, 0.018), vec3(0.35, 1.0, 0.45), tl)
         + vec3(0.75, 1.0, 0.80) * hd;
  }
  if (uStyle < 21.5){                                                 // 21 ice
    float w  = sin(f * 1.9 - ang * 1.1) * sin(f * 0.8 + ang * 2.3 + T * 0.2);
    float cr = 1.0 - smoothstep(0.0, 0.07, abs(w));
    float dp = 0.5 + 0.5 * sin(f * 0.6 + T * 0.25);
    emit = cr * 0.5;
    return mix(vec3(0.30, 0.52, 0.68) * (0.6 + 0.5 * dp), vec3(0.92, 0.98, 1.0), cr);
  }
  if (uStyle < 22.5){                                                // 22 gold
    // Hammered: a low-frequency wobble stands in for the dents, and the seams
    // are the lines where it turns over.
    float ham  = sin(f * 3.1 + ang * 2.7) * sin(f * 1.7 - ang * 1.9 + T * 0.15);
    float seam = smoothstep(0.02, 0.16, abs(ham));
    emit = 0.10;
    return mix(vec3(0.06, 0.035, 0.008), vec3(1.0, 0.76, 0.28), seam)
         * (0.72 + 0.38 * ham);
  }
  // 23 static. Per-cell noise re-rolled every frame - the one pattern here that
  // is meant to look broken rather than designed.
  float sn = h11(floor(f * 20.0) + floor(ang * 12.0) * 37.0 + floor(T * 14.0) * 91.0);
  emit = sn * 0.9;
  return vec3(sn * sn);
}

// One call for "what colour is the pipe here, and how much does it glow".
vec3 pipeSurface(vec3 p, vec3 n, vec3 rd, out float emit){
  float id, flow, ang;
  surfAt(p, id, flow, ang);
  vec3 base = pipeColour(id);
  vec3 pat  = pipePattern(p, base, id, flow, ang, n, rd, emit);
  emit *= uEmit * uPatMix;
  gEmit = emit;
  // Most patterns read as paint and want the metalness pulled down; plain,
  // oil, obsidian, ice and gold are surfaces whose whole point is a reflection.
  gGloss = (uStyle < 0.5
         || (uStyle > 5.5  && uStyle < 6.5)
         || (uStyle > 15.5 && uStyle < 16.5)
         || (uStyle > 20.5 && uStyle < 22.5)) ? 1.0 : 0.30;
  return mix(base, pat, uPatMix);
}

vec3 shadePipe(vec3 p, vec3 n, vec3 rd, vec3 base){
  // Taken before the interreflection bounce, which runs its own surface query
  // and would otherwise leave the neighbour's glow in the global.
  float myEmit = gEmit;
  // Most patterned pipes are paint, not chrome. Left at full metalness the
  // studio gradient and the white specular between them put a warm sheen on
  // every dark pattern, and the furnace style - cold iron with hot bands - came
  // out uniformly lukewarm tan. Which styles keep their gloss is per-style:
  // obsidian is black BECAUSE of its reflection, not in spite of it.
  float mtl  = uMetal * mix(1.0, gGloss, uPatMix);
  float damp = 1.0 / (1.0 + myEmit * 2.0);
  vec3  L    = normalize(LIGHTP - p);
  float ao   = aoAt(p, n);
  float ndl  = max(dot(n, L), 0.0);
  // A face turned away from the key gets nothing from the key, so the shadow
  // ray can only ever confirm what ndl already says. Half the pipe is facing
  // away at any moment, and this was the single most expensive thing here.
  float sh   = (uShadow > 0.001 && ndl > 0.001)
             ? mix(1.0, shadowAt(p + n * 0.01, L), uShadow) : 1.0;

  vec3  H    = normalize(L - rd);
  float gloss = 2.0 / max(uRough * uRough, 0.0008);
  float spec = pow(max(dot(n, H), 0.0), gloss) * (gloss + 8.0) * 0.02;

  // The reflection: the room in closed form, plus one bounce off the other
  // pipes when it is asked for - chrome that only reflects the walls looks like
  // plastic the moment two pipes cross.
  vec3  Rf  = reflect(rd, n);
  vec3  env = envAt(Rf);
  if (uReflect > 0.001){
    float t = 0.05, hit = 0.0;
    for (int i = ZERO; i < 28; i++){
      float d = mapPipes(p + Rf * t);
      if (d < 0.004 + t * 0.002){ hit = 1.0; break; }
      t += d * 0.95;
      if (t > 13.0) break;
    }
    if (hit > 0.5){
      vec3  q  = p + Rf * t;
      vec3  qn = normalAt(q);
      float qe;
      vec3  qc = pipeSurface(q, qn, Rf, qe);
      float qd = max(dot(qn, normalize(LIGHTP - q)), 0.0);
      // The pattern has to reach the reflections too. A pipe that pulses but
      // whose reflection in its neighbour does not is a decal, not a material.
      env = mix(env, qc * (0.10 + 0.55 * qd + qe) * 0.85, uReflect);
    }
  }

  // Reflection is added on top of a lit body rather than crossfaded with it.
  // The crossfade version handed 86% of the pixel to a reflection of a very
  // dark room, and every pipe came out the colour of pond weed.
  float fres = 0.04 + 0.96 * pow(1.0 - max(dot(n, -rd), 0.0), 5.0);
  vec3  diff = base * (ndl * sh * uLight * 0.62 + uAmbient * ao * 0.55)
             * mix(1.0, 0.42, mtl);
  // A glowing surface stops being a mirror. Without this the studio gradient
  // lifted every dark pattern - the furnace style came out a uniform lukewarm
  // tan instead of cold iron with hot bands running through it.
  vec3  refl = env * mix(vec3(1.0), base, mtl) * mix(0.30, 1.0, fres) * ao
             * (0.55 + 0.95 * mtl) * damp;
  vec3  hi   = vec3(1.0, 0.98, 0.94) * spec * sh * uLight
             * mix(1.0, 0.6, clamp(uRough * 2.0, 0.0, 1.0)) * damp;

  return diff + refl + hi;
}

// ---- the void --------------------------------------------------------------
// Below the lattice is a black polished floor, and it is a real mirror: the
// reflection is a second march, not a trick. The air above it is not empty
// either - a shaft of light comes down through the network, and the network
// stands in its own shadow inside it.
#define FLOORY (-(GRID - 1.0) * 0.5 - 0.5)

// A reflection does not need a reflection of its own. This is shadePipe minus
// the interreflection bounce, the AO taps and the shadow ray - three of the
// four expensive things - and at one bounce nobody can tell.
vec3 shadeCheap(vec3 p, vec3 n, vec3 rd, vec3 base){
  vec3  L   = normalize(LIGHTP - p);
  float ndl = max(dot(n, L), 0.0);
  vec3  Rf  = reflect(rd, n);
  vec3  env = envAt(Rf);
  float fres = 0.04 + 0.96 * pow(1.0 - max(dot(n, -rd), 0.0), 5.0);
  float mtl  = uMetal * mix(1.0, gGloss, uPatMix);
  return base * (ndl * uLight * 0.55 + uAmbient * 0.50) * mix(1.0, 0.42, mtl)
       + env * mix(vec3(1.0), base, mtl) * mix(0.30, 1.0, fres)
             * (0.55 + 0.95 * mtl) / (1.0 + gEmit * 2.0);
}

vec3 shadeFloor(vec3 p, vec3 rd){
  vec3 n = vec3(0.0, 1.0, 0.0);
  vec3 col = vec3(0.0);

  if (uMirror > 0.001){
    vec3  Rf = reflect(rd, n);
    float t = 0.05, hit = 0.0;
    for (int i = ZERO; i < 34; i++){
      float d = mapPipes(p + Rf * t);
      if (d < 0.004 + t * 0.003){ hit = 1.0; break; }
      t += d * 0.99;
      if (t > 20.0) break;
    }
    if (hit > 0.5){
      vec3 q = p + Rf * t;
      // Grazing angles mirror hardest and distance eats the rest. A floor that
      // reflects perfectly at every angle and every range is not a floor, it is
      // a hole with a copy of the scene in it.
      float fres = 0.06 + 0.94 * pow(1.0 - max(-dot(rd, n), 0.0), 4.0);
      vec3  qn = normalAt(q);
      float qe;
      vec3  qb = pipeSurface(q, qn, Rf, qe);
      col += (shadeCheap(q, qn, Rf, qb) + qb * qe)
           * uMirror * mix(0.26, 1.0, fres) * exp(-t * 0.075);
    }
  }

  float sh = uShadow > 0.001
           ? mix(1.0, shadowAt(p + n * 0.03, normalize(LIGHTP - p)), uShadow) : 1.0;
  col += vec3(0.055, 0.058, 0.070) * uLight * sh * exp(-dot(p.xz, p.xz) * 0.016);
  return col * uFloor * exp(-dot(p.xz, p.xz) * 0.0040);   // the horizon dissolves
}

// The advancing tip, and the joints that have just landed. Only possible
// because the run is a closed form: the shader knows not just where every joint
// is but exactly how long ago it was placed: the stream index of a corner and
// the current head are the same quantity, so the difference is its age.
vec3 tipGlow(vec3 ro, vec3 rd, float tHit){
  if (uTipGlow < 0.001) return vec3(0.0);
  vec3 g = vec3(0.0);
  for (int i = ZERO; i < NSEG; i++){
    float gi = gG0 + float(i);                    // not g: that is the glow
    if (gi >= gHead) break;
    float age = gHead - gi;
    if (age > 2.2) continue;                      // only the freshest few
    vec3  P  = posOf(gPts[i]);
    vec3  c  = mix(pipeColour(pipeAtG(gi)), vec3(1.0), 0.55);

    float tp = max(dot(P - ro, rd), 0.0);
    float dj = length(ro + rd * tp - P);
    if (tp < tHit + 0.4)
      g += c * exp(-age * 2.4)
             * (exp(-dj * dj * 22.0) * 0.55 + 0.05 / (1.0 + dj * dj * 70.0));

    if (age < 1.0){                               // this one is still moving
      if (endsAt(gi) < 0.5){
        vec3  T  = mix(P, posOf(gPts[i + 1]), age);
        float tq = max(dot(T - ro, rd), 0.0);
        float dt = length(ro + rd * tq - T);
        if (tq < tHit + 0.4)
          g += c * (exp(-dt * dt * 26.0) * 0.80 + 0.06 / (1.0 + dt * dt * 80.0));
      }
    }
  }
  return g * uTipGlow;
}

void main(){
  vec2 fragCoord = gl_FragCoord.xy;
  vec2 R  = RENDERSIZE.xy;
  vec2 uv = (fragCoord - 0.5 * R) / R.y;

  // No runs and no fade: the stream just keeps going. The head lays corners
  // down at a steady rate and the tail eats them uCount corners later, so old
  // pipes are being taken apart at the same time as new ones are being drawn.
  //
  // The window starts at a pipe boundary rather than exactly at the tail, so
  // the array always begins where some pipe began - which is what lets the walk
  // be regenerated from a pipe's own seed instead of from the beginning of
  // time. That costs up to gRun spare slots, so uCount + uRun must fit in NSEG.
  gRun   = max(floor(uRun), 4.0);
  float alive = min(uCount, float(NSEG) - gRun);
  gHead  = TIME * uSpeed * 1.6;
  gTail  = max(gHead - alive, 0.0);
  gG0    = floor(gTail / gRun) * gRun;

  buildPath();

  float ang = TIME * uOrbit * 0.35 + 0.9;
  vec3  ro  = vec3(sin(ang), 0.0, cos(ang)) * uDist
            + vec3(0.0, uHeight + 0.35 * sin(TIME * 0.11), 0.0);
  // Never let the camera get under its own floor: height can be dragged to the
  // floor level and the bob would take it through.
  if (uFloor > 0.001) ro.y = max(ro.y, FLOORY + 0.45);
  vec3 ta = vec3(0.0, 0.2 * sin(TIME * 0.07), 0.0);
  vec3 ww = normalize(ta - ro), uu = normalize(cross(ww, vec3(0.0, 1.0, 0.0)));
  vec3 vv = cross(uu, ww);
  vec3 rd = normalize(uv.x * uu + uv.y * vv + uFov * ww);

  // Nothing to hit but the pipes and the floor; a ray that misses both runs
  // out to a far clip and comes back black.
  float tRoom  = 60.0;
  float tFloor = 1e9;
  if (uFloor > 0.001 && rd.y < -1e-4){
    float tf = (FLOORY - ro.y) / rd.y;
    if (tf > 0.02) tFloor = tf;
  }
  float tBack = min(tRoom, tFloor);

  float t = 0.02, hit = 0.0;
  for (int i = ZERO; i < 96; i++){
    float d = mapPipes(ro + rd * t);
    // The scene is a plain union of exact primitives, so the distance is a
    // true bound and the march does not need to be talked down from it.
    if (d < 0.0018 + t * 0.0013){ hit = 1.0; break; }
    t += d * 0.99;
    if (t > tBack) break;
  }

  vec3 col;
  if (hit > 0.5){
    vec3  p = ro + rd * t;
    vec3  nn = normalAt(p);
    float em;
    vec3  b = pipeSurface(p, nn, rd, em);
    col = shadePipe(p, nn, rd, b) + b * em;
  } else if (tFloor < tRoom){
    t   = tFloor;                       // the march overshot; the glows need it
    col = shadeFloor(ro + rd * tFloor, rd);
  } else {
    t   = tRoom;
    col = vec3(0.0);                    // black, and there is no knob for it
  }

  // Everything from here is added in front of whatever was hit: the cage is a
  // hologram, the tip is a bloom, and the air is between you and both.
  col += tipGlow(ro, rd, t);

  col *= uExposure;
  col  = col / (1.0 + col * 0.72);                       // tonemap
  col  = pow(max(col, 0.0), vec3(0.4545));
  col *= 1.0 - uVignette * dot(uv, uv) * 0.85;
  col += (h11(fragCoord.x * 1.7 + fragCoord.y * 91.3 + TIME * 60.0) - 0.5)
       * uGrain * 0.12;

  gl_FragColor = vec4(clamp(col, 0.0, 1.0), 1.0);
}