/*{
  "DESCRIPTION": "The Markus-Lyapunov fractal, computed rather than drawn. Take the logistic map x -> r x (1 - x), the standing summary of how order becomes chaos, and let r alternate between two values A and B following a fixed binary word - ABAB, AABAB, AAAAAABBBBBB. Put A on the horizontal axis and B on the vertical, and at every point of the plane measure how fast two neighbouring orbits pull apart: lambda = lim 1/N SUM ln |f'(x_n)|. Where lambda is negative the orbit settles and the system is ordered, drawn warm; where it is positive neighbours separate exponentially - chaos, drawn cold and dark. Nothing comes from a distance field or a noise stack: every pixel runs its own small dynamical system a few hundred steps and reports the exponent it earned, so the lace, the nested swallows strung along the diagonal and the self-similar chains are all the period-doubling cascade seen from two directions at once. Two liberties, both dialable to zero. The A/B word is generated as a rotation word - symbol i is B when fract(i*stride/period + phase) lands inside an arc of length 1-duty - which at soft = 0 is exactly the classic binary word; open the soft slider and the arc's edge blurs, so r glides between A and B instead of snapping and the phase can then be turned continuously, morphing the fractal rather than cutting between sequences. That drift is the animation, and since one full turn of the word is period steps it closes on itself. The map slider cross-fades the logistic map into the sine map r sin(pi x)/4, which shares its range and has its own rounder portrait. Relief comes free: the four anti-aliasing taps double as a finite difference, so the height of the exponent field is had from a gradient that was already paid for. The metal slider then stops treating the palette as an albedo and treats it as a conductor - a real normal is built from that gradient and it reflects a small procedural studio of a dark floor, a cool sky and two soft strip lights. Strips rather than points on purpose: a band is what makes a curved surface streak instead of sparkle. A polished conductor returns most of what strikes it, so the palette is carried most of the way to white and kept as a tint on the reflection, which is what a metal's colour physically is; there is no diffuse term at all. Two more things ride on that reflection. Anisotropy brushes the metal along lambda's OWN contours rather than along some fixed direction - a groove acts as a tiny cylindrical mirror and smears the reflection across its axis, so taking the tangent from the level sets makes the grain follow the form the way a turned or spun surface does. And a thin film sits on top: light reflects both off the film and off the metal beneath, the two paths differ by 2*n*d*cos(theta), and each wavelength lands somewhere different on that difference, so some cancel and some reinforce. That is precisely what puts straw, purple and blue onto tempered steel, it is angle-dependent so the bands follow the curvature instead of sitting on the surface, and the film's depth is driven by lambda as well, so the colour maps the dynamics too. Recipes: the default is AABAB - period 5, stride 2, duty 0.60 at centre (3.3,3.3) span 0.80, where stride 2 is what interleaves the word rather than blocking it, since stride 1 at the same period and duty would give AAABB; AAABBB is period 6, stride 1, duty 0.50 at centre (3,3) span 2; classic Markus is period 2, stride 1, duty 0.50 at the same window - the iconic AB image, though two symbols is the one word length at which a drifting phase moves both onto the arc's edge together, so it dissolves to a plain gradient twice per cycle unless soft is set to 0; Zircon Zity is period 12, stride 1, duty 0.50 at centre (3.70, 2.95) span 0.62. Twenty-seven controls: speed, the window's span and centre on both axes, the word's period, stride and duty, word softness, the logistic-to-sine blend, iterations and how many are discarded as transient, the seed, separate saturation curves for the ordered and chaotic sides, seven palettes with a continuous cross-fade, a metal dial that turns the palette from an albedo into a conductor reflecting a procedural studio, anisotropic brushing, thin-film strength, film thickness in nanometres and a travelling swell in that thickness that sets the temper colours crawling along lambda's level sets - clocked to the same phase that turns the word, so it closes on the same loop, relief and the angle the room is turned to, anti-aliasing, exposure, bloom, vignette and grain.",
  "CREDIT": "CC0",
  "CATEGORIES": ["generator", "fractal", "chaos", "lyapunov", "logistic-map", "dynamical-systems", "mathematics", "2d"],
  "INPUTS": [
    { "NAME": "uSpeed",      "TYPE": "float", "DEFAULT": 1.0,   "MIN": 0.0,   "MAX": 3.0 },
    { "NAME": "uSpan",       "TYPE": "float", "DEFAULT": 0.8,   "MIN": 0.01,  "MAX": 2.5 },
    { "NAME": "uCentreA",    "TYPE": "float", "DEFAULT": 3.3,   "MIN": 0.0,   "MAX": 4.0 },
    { "NAME": "uCentreB",    "TYPE": "float", "DEFAULT": 3.3,   "MIN": 0.0,   "MAX": 4.0 },
    { "NAME": "uPeriod",     "TYPE": "float", "DEFAULT": 5.0,   "MIN": 1.0,   "MAX": 24.0 },
    { "NAME": "uSkip",       "TYPE": "float", "DEFAULT": 2.0,   "MIN": 1.0,   "MAX": 12.0 },
    { "NAME": "uDuty",       "TYPE": "float", "DEFAULT": 0.6,   "MIN": 0.02,  "MAX": 0.98 },
    { "NAME": "uSoft",       "TYPE": "float", "DEFAULT": 0.3,   "MIN": 0.0,   "MAX": 1.0 },
    { "NAME": "uMap",        "TYPE": "float", "DEFAULT": 0.0,   "MIN": 0.0,   "MAX": 1.0 },
    { "NAME": "uIter",       "TYPE": "float", "DEFAULT": 160.0, "MIN": 16.0,  "MAX": 384.0 },
    { "NAME": "uWarm",       "TYPE": "float", "DEFAULT": 40.0,  "MIN": 0.0,   "MAX": 200.0 },
    { "NAME": "uSeed",       "TYPE": "float", "DEFAULT": 0.5,   "MIN": 0.01,  "MAX": 0.99 },
    { "NAME": "uOrderScale", "TYPE": "float", "DEFAULT": 1.8,   "MIN": 0.1,   "MAX": 3.0 },
    { "NAME": "uChaosScale", "TYPE": "float", "DEFAULT": 0.15,  "MIN": 0.05,  "MAX": 1.5 },
    { "NAME": "uPalette",    "TYPE": "float", "DEFAULT": 6.0,   "MIN": 0.0,   "MAX": 6.0 },
    { "NAME": "uMetal",      "TYPE": "float", "DEFAULT": 0.9,   "MIN": 0.0,   "MAX": 1.0 },
    { "NAME": "uAniso",      "TYPE": "float", "DEFAULT": 0.35,  "MIN": 0.0,   "MAX": 1.0 },
    { "NAME": "uFilm",       "TYPE": "float", "DEFAULT": 1.0,   "MIN": 0.0,   "MAX": 1.0 },
    { "NAME": "uFilmThick",  "TYPE": "float", "DEFAULT": 420.0, "MIN": 80.0,  "MAX": 900.0 },
    { "NAME": "uFilmFlow",   "TYPE": "float", "DEFAULT": 0.5,   "MIN": 0.0,   "MAX": 1.0 },
    { "NAME": "uRelief",     "TYPE": "float", "DEFAULT": 0.6,   "MIN": 0.0,   "MAX": 1.0 },
    { "NAME": "uLight",      "TYPE": "float", "DEFAULT": 0.9,   "MIN": -3.15, "MAX": 3.15 },
    { "NAME": "uAA",         "TYPE": "float", "DEFAULT": 1.0,   "MIN": 0.0,   "MAX": 1.0 },
    { "NAME": "uExposure",   "TYPE": "float", "DEFAULT": 1.0,   "MIN": 0.0,   "MAX": 2.5 },
    { "NAME": "uBloom",      "TYPE": "float", "DEFAULT": 0.25,  "MIN": 0.0,   "MAX": 1.0 },
    { "NAME": "uVignette",   "TYPE": "float", "DEFAULT": 0.3,   "MIN": 0.0,   "MAX": 1.0 },
    { "NAME": "uGrain",      "TYPE": "float", "DEFAULT": 0.03,  "MIN": 0.0,   "MAX": 1.0 }
  ]
}*/

// LYAPUNOV - ISF port of the Shadertoy/WebGL2 version
// (GLSL ES 1.00: gl_FragColor, TIME/RENDERSIZE).
//
// lambda = lim 1/N SUM ln |d/dx f(x_n)| for the logistic map driven by
// a binary A/B word, with A on the x axis and B on the y axis of the
// plane. Negative lambda is order, positive is chaos.

#define PI   3.14159265359
#define TAU  6.28318530718

// Hard ceiling on the iteration loop. It is constant-bound, which is
// the shape ANGLE likes to unroll flat — and this body gets inlined
// four times over for the AA taps. iq's ZERO trick is the usual
// defence, but GLSL ES 1.00 requires a constant loop initialiser and
// ISF rejects it, so the early `break` carries the cost instead. It
// is used in both builds so the two stay identical.
#define MAXI 384

float hash12(vec2 p){
    p = fract(p * vec2(123.34, 456.21));
    p += dot(p, p + 45.32);
    return fract(p.x * p.y);
}

// ------------------------------------------------------------
// The exponent at one point of the (A,B) plane.
//
// `phase` rotates the word. With a hard word that is only a cyclic
// shift, and a cyclic shift leaves lambda alone once the transient is
// discarded — so the drift stays invisible until `soft` opens the
// arc's edge and the intermediate phases become words of their own.
// ------------------------------------------------------------
float lyapunov(vec2 ab, float phase){
    int   P    = int(uPeriod + 0.5);
    float fp   = float(P);
    float invP = floor(uSkip + 0.5) / fp;

    // The symbols sample the phase circle on a grid of spacing 1/P, whatever
    // the stride. Quantising duty onto that same grid and offsetting the
    // samples by HALF a cell puts every symbol strictly INSIDE a cell and
    // never on the arc's edge. Without it, period 2 at duty 0.5 drops both
    // symbols exactly on the boundary, w comes back 0.5 for both, and the
    // alternating map quietly collapses to a constant (a+b)/2 — a smooth
    // gradient wearing a fractal's clothes.
    float d  = clamp(floor(uDuty * fp + 0.5) / fp, 0.0, 1.0);
    float hc = 0.5 / fp;               // half a cell

    // The B symbols occupy an arc of the phase circle. Measuring the
    // circular distance to that arc's CENTRE, rather than testing
    // u > duty, makes the softening wrap properly at u = 0 — a symbol
    // crossing the seam fades instead of popping.
    float c = 0.5 + 0.5 * d;           // centre of the B arc
    float L = 0.5 - 0.5 * d;           // its half-length
    float h = max(uSoft * 0.5, 1e-4);  // softening half-width

    float m = clamp(uMap, 0.0, 1.0);
    int   N = int(uIter + 0.5);
    // min() has no int overload in GLSL ES 1.00 — clamp in float, then cast.
    int   W = int(min(uWarm + 0.5, uIter - 0.5));

    // r outside [0,4] lets the orbit escape the unit interval and the
    // exponent stops meaning anything, so the window is clipped to the
    // map's own domain rather than to the frame.
    ab = clamp(ab, 0.0, 4.0);

    float x = clamp(uSeed, 0.001, 0.999);
    float sum = 0.0, cnt = 0.0;
    int j = 0;

    for (int i = 0; i < MAXI; i++){
        if (i >= N) break;

        float u  = fract(float(j) * invP + hc + phase);
        float dd = abs(fract(u - c + 0.5) - 0.5);
        float w  = 1.0 - smoothstep(L - h, L + h, dd);
        float r  = mix(ab.x, ab.y, w);

        float fx = x * (1.0 - x);   // logistic
        float dx = 1.0 - 2.0 * x;   // and its derivative
        if (m > 0.001){             // uniform branch — coherent across the warp
            fx = mix(fx, 0.25 * sin(PI * x),      m);
            dx = mix(dx, 0.25 * PI * cos(PI * x), m);
        }
        x = r * fx;

        // The derivative of the whole step is r * f'(x); the chain rule
        // over N steps turns that product into this sum of logs.
        if (i >= W){ sum += log(abs(r * dx) + 1e-9); cnt += 1.0; }

        j++; if (j >= P) j = 0;
    }
    return sum / max(cnt, 1.0);
}

// ------------------------------------------------------------
// Palettes. Three stops each way out of a SHARED colour at lambda = 0.
//
// The shared stop is the point. lambda is perfectly continuous across the
// order/chaos frontier — it just passes through zero — so any jump in colour
// there is invented by the palette, not by the dynamics. Ramping the two sides
// away from one common dark stop makes the whole lambda -> colour map
// continuous, and the frontier then reads as the soft dark seam it physically
// is, rather than as a hard cut between two unrelated hues.
// ------------------------------------------------------------
void palStops(int p, out vec3 o0, out vec3 o1, out vec3 o2, out vec3 k1, out vec3 k2){
    // 1 — violet gold.  o0 is shared: it is the colour AT lambda = 0.
    o0 = vec3(0.10, 0.03, 0.09);
    o1 = vec3(0.95, 0.55, 0.15); o2 = vec3(1.00, 0.94, 0.72);   // into order
    k1 = vec3(0.34, 0.12, 0.62); k2 = vec3(0.03, 0.01, 0.09);   // into chaos

    if (p <= 0){                        // 0 — Markus, as first published
        o0 = vec3(0.08, 0.05, 0.03);
        o1 = vec3(0.92, 0.62, 0.06); o2 = vec3(1.00, 0.97, 0.80);
        k1 = vec3(0.10, 0.22, 0.52); k2 = vec3(0.00, 0.00, 0.03);
    } else if (p == 2){                 // 2 — ember
        o0 = vec3(0.09, 0.02, 0.01);
        o1 = vec3(0.90, 0.25, 0.03); o2 = vec3(1.00, 0.88, 0.55);
        k1 = vec3(0.25, 0.05, 0.05); k2 = vec3(0.02, 0.00, 0.00);
    } else if (p == 3){                 // 3 — ice
        o0 = vec3(0.02, 0.06, 0.10);
        o1 = vec3(0.25, 0.72, 0.86); o2 = vec3(0.90, 0.99, 1.00);
        k1 = vec3(0.04, 0.10, 0.30); k2 = vec3(0.00, 0.01, 0.04);
    } else if (p == 4){                 // 4 — verdigris and copper
        o0 = vec3(0.06, 0.05, 0.03);
        o1 = vec3(0.80, 0.44, 0.20); o2 = vec3(0.98, 0.86, 0.66);
        k1 = vec3(0.05, 0.30, 0.26); k2 = vec3(0.00, 0.04, 0.04);
    } else if (p == 5){                 // 5 — ink
        o0 = vec3(0.06, 0.06, 0.06);
        o1 = vec3(0.55, 0.55, 0.55); o2 = vec3(1.00, 1.00, 1.00);
        k1 = vec3(0.16, 0.16, 0.16); k2 = vec3(0.00, 0.00, 0.00);
    } else if (p >= 6){                 // 6 — steel: reflectance, not colour
        o0 = vec3(0.09, 0.10, 0.12);
        o1 = vec3(0.52, 0.56, 0.62); o2 = vec3(0.90, 0.94, 1.00);
        k1 = vec3(0.16, 0.18, 0.22); k2 = vec3(0.02, 0.02, 0.03);
    }
}

// ------------------------------------------------------------
// A studio in a function.
//
// What actually makes a surface read as polished metal is not a highlight, it
// is a REFLECTION of something with structure. So this returns what the eye
// would see looking along a reflected ray: a dark floor, a cool sky, and two
// soft strip lights. Strips rather than points on purpose — a band is what
// makes a curved surface streak instead of sparkle, and the streaks are most
// of the look.
//
// Parameterised by the reflected ray's SCREEN-PLANE direction. Under an
// orthographic view of a near-flat height field, rv ~ (2*slope.x, 2*slope.y, 1),
// so rd is essentially the surface slope and the whole room is addressed by it.
// ------------------------------------------------------------
vec3 envMap(vec2 rd){
    float y = clamp(rd.y * 0.7 + 0.5, 0.0, 1.0);
    vec3 c = mix(vec3(0.045, 0.050, 0.060), vec3(0.56, 0.60, 0.68),
                 smoothstep(0.12, 0.95, y));

    // t*t, never pow(x, 2.0): pow() is undefined for a negative base.
    float t1 = (rd.y - 0.45) / 0.11;  float k1 = exp(-t1 * t1);   // key strip
    float t2 = (rd.y + 0.30) / 0.20;  float k2 = exp(-t2 * t2);   // fill, low and dim

    // Break the strips along azimuth so they read as a room rather than a ring.
    float az = atan(rd.y, rd.x);
    k1 *= 0.60 + 0.40 * cos(az * 2.0 + 0.7);
    k2 *= 0.55 + 0.45 * cos(az * 3.0 - 1.1);

    c += vec3(1.00, 0.99, 0.96) * k1 * 2.2;
    c += vec3(0.70, 0.79, 0.96) * k2 * 0.60;
    return c;
}

vec3 shade(float lam){
    float pf = clamp(uPalette, 0.0, 6.0);
    int   p0 = int(floor(pf));
    float f  = fract(pf);

    vec3 a0, a1, a2, b1, b2, e0, e1, e2, g1, g2;
    palStops(p0,     a0, a1, a2, b1, b2);
    palStops(p0 + 1, e0, e1, e2, g1, g2);
    // Cross-fade the STOPS, not two finished ramps: one ramp evaluation
    // instead of two, and neighbouring palettes blend rather than
    // dissolve through each other.
    vec3 o0 = mix(a0, e0, f), o1 = mix(a1, e1, f), o2 = mix(a2, e2, f);
    vec3 k1 = mix(b1, g1, f), k2 = mix(b2, g2, f);

    // exp() rather than a clamp: lambda has no bound either way — a
    // superstable orbit sends it to -inf — so nothing should saturate.
    float t = 1.0 - exp( min(lam, 0.0) / max(uOrderScale, 0.01));
    float s = 1.0 - exp(-max(lam, 0.0) / max(uChaosScale, 0.01));

    vec3 ord = (t < 0.5) ? mix(o0, o1, t * 2.0) : mix(o1, o2, t * 2.0 - 1.0);
    vec3 cha = (s < 0.5) ? mix(o0, k1, s * 2.0) : mix(k1, k2, s * 2.0 - 1.0);

    // Both ramps leave from o0, and t = s = 0 at lambda = 0, so the two
    // branches agree exactly on the frontier. No blend band is needed to hide
    // a seam, because there is no longer a seam to hide.
    return (lam < 0.0) ? ord : cha;
}

void main(){
    vec2 fragCoord = gl_FragCoord.xy;
    vec2 R = RENDERSIZE.xy;

    // Fit the window to WIDTH, so `span` always means the same slice of
    // the A axis whatever shape the frame is.
    //
    // The map is only defined for r in [0,4]. Past r = 4 the orbit escapes the
    // unit interval and the exponent is +inf EVERYWHERE, so any part of the
    // frame beyond that edge is a dead flat slab bounded by a razor-straight
    // line — it looks exactly like a clipping bug because it effectively is
    // one. There is no cleverer shading to apply: the region genuinely holds no
    // structure. So the window itself is kept inside the domain. The span is
    // capped so the frame's short axis still fits, and the centre is then
    // clamped to the remaining travel, which makes the flat slab unreachable
    // instead of merely unattractive.
    float span = min(uSpan, 4.0 * min(1.0, R.x / R.y));
    float px   = span / R.x;
    vec2  hx   = 0.5 * px * R;                  // half-extent of the frame, in r
    vec2  ctr  = clamp(vec2(uCentreA, uCentreB), hx, vec2(4.0) - hx);
    vec2  ab   = ctr + (fragCoord - 0.5 * R) * px;

    // Drift is measured in whole symbols: one full turn of the word is
    // P steps, so the animation closes on itself every P/speed seconds.
    float phase = fract(TIME * uSpeed * 0.05);

    bool quad = (uAA > 0.5) || (uRelief > 0.001);

    float l00 = lyapunov(ab + vec2(-0.25, -0.25) * px, phase);
    float lam = l00;
    vec2  g   = vec2(0.0);
    if (quad){
        float l10 = lyapunov(ab + vec2( 0.25, -0.25) * px, phase);
        float l01 = lyapunov(ab + vec2(-0.25,  0.25) * px, phase);
        float l11 = lyapunov(ab + vec2( 0.25,  0.25) * px, phase);
        lam = (l00 + l10 + l01 + l11) * 0.25;
        // The AA taps ARE the finite difference — the emboss is free.
        g = vec2((l10 + l11) - (l00 + l01),
                 (l01 + l11) - (l00 + l10)) * 0.5;
    }

    vec3 albedo = shade(lam);
    vec3 col = albedo;

    if (uRelief > 0.001){
        // Shape the ORDERED side only. Inside a chaotic region lambda is a
        // genuinely noisy estimate at this sample count, so its pixel-scale
        // gradient is sampling noise rather than shape, and lighting it just
        // renders the noise in relief. The fade reaches past lambda = 0 so
        // the order/chaos frontier itself still catches a rim.
        float om = smoothstep(0.12, -0.02, lam);
        vec2  gr = g * uRelief * om;
        float ca = cos(uLight), sa = sin(uLight);

        // --- matte: the cheap directional emboss (uMetal = 0) -------------
        float e = dot(gr, vec2(ca, sa)) * 26.0;
        e = e / (1.0 + abs(e));                     // no tanh in ES 1.00
        vec3 emb = col * (1.0 + 0.85 * e)
                 + vec3(1.0, 0.97, 0.92) * pow(max(e, 0.0), 3.0) * 0.45;

        // --- metal: treat lambda as a height field and actually shade it ---
        // A real normal, not a directional derivative. normalize() also does
        // the right thing where the gradient explodes at the order/chaos
        // frontier: the normal lies down flat and the edge takes a hard dark
        // crease, which is exactly how a struck metal surface behaves.
        vec3 N = normalize(vec3(-gr * 55.0, 1.0));

        // Orthographic view down +Z, so reflect((0,0,-1), N) folds to this.
        vec3 rv = vec3(2.0 * N.z * N.x, 2.0 * N.z * N.y, 2.0 * N.z * N.z - 1.0);
        vec2 rd = mat2(ca, -sa, sa, ca) * rv.xy;    // uLight turns the room

        // --- anisotropy: brush the metal ALONG ITS OWN CONTOURS ----------
        // A groove behaves like a tiny cylindrical mirror: it smears what it
        // reflects along its own axis. So the operation is a directional BLUR
        // of the room, not a compression of the reflected ray — compressing it
        // merely drags every sample toward the middle of the room, which dims
        // the strip lights instead of stretching them. Averaging keeps the
        // energy and lets the highlight run.
        //
        // The brush direction is not global: it is the tangent to lambda's own
        // level sets (perpendicular to the raw gradient), so the grain follows
        // the form the way a turned or spun surface does, and it falls out of
        // the field rather than being bolted on top of it.
        vec3 room = envMap(rd);
        if (uAniso > 0.001){
            float gl = length(g);
            vec2 tang = (gl > 1e-9) ? vec2(-g.y, g.x) / gl : vec2(1.0, 0.0);
            tang = mat2(ca, -sa, sa, ca) * tang;      // turn with the room
            // Radius is scaled to the STRIP WIDTH (~0.11 in rd), not to the
            // room: blur much wider than a strip and every tap averages the
            // whole room, which flattens the frame to mid-grey and throws
            // away the blacks the material depends on.
            float wd = clamp(uAniso, 0.0, 1.0) * 0.14;
            room = (envMap(rd - tang * wd) + room + envMap(rd + tang * wd))
                 * (1.0 / 3.0);
        }

        // Schlick. For a conductor there is no diffuse term at all — the
        // palette colour stops being an albedo and becomes the REFLECTANCE,
        // which is why a metal tints what it reflects instead of what it is.
        // A polished conductor returns most of what hits it: F0 sits near 0.9,
        // not at the albedo. Pulling the palette most of the way to white keeps
        // it as a TINT on the reflection - which is what a metal's colour
        // actually is - instead of letting a dark fractal swallow the light.
        float fr = pow(clamp(1.0 - N.z, 0.0, 1.0), 5.0);
        vec3  F0  = mix(albedo, vec3(1.0), 0.62);
        vec3  F   = F0 + (1.0 - F0) * fr;

        // --- thin film: the temper colours of oxidised steel --------------
        // Light reflects off the top of a thin oxide film and off the metal
        // beneath it; the two paths differ by 2*n*d*cos(theta_film), and each
        // wavelength lands somewhere different on that difference, so some
        // cancel and some reinforce. That is exactly what puts straw, purple
        // and blue on tempered steel, and it is angle-dependent, which is why
        // the bands follow the curvature rather than sitting on the surface.
        // Thickness is driven by lambda as well, so the ordered side runs to a
        // thicker film and the colour maps the dynamics too.
        if (uFilm > 0.001){
            float ordT = 1.0 - exp(min(lam, 0.0) / max(uOrderScale, 0.01));
            // A travelling swell in the film's depth, so the temper colours
            // crawl instead of sitting still. Its spatial phase is lambda
            // itself, so the bands run along the exponent's own level sets
            // rather than sweeping across the frame like a wipe.
            //
            // Driven by the SAME `phase` that turns the A/B word, at a whole
            // number of cycles per turn. Anything else — a raw TIME term, or a
            // non-integer rate — would beat against the 20 s loop and quietly
            // destroy it, and the loop is a stated property of this shader.
            // Few spatial cycles on purpose. Wind ordT's coefficient up and the
            // swell stops reading as motion and starts reading as fixed rainbow
            // banding that happens to slide — the metal disappears under it.
            float flow = uFilmFlow * 0.42 * sin(TAU * (ordT * 1.2 - phase * 2.0));
            float dnm  = uFilmThick * (0.80 + 0.35 * ordT + flow);  // depth, nm
            // A LOW film index on purpose. cos(theta) inside the film is
            // what carries the angle dependence, and a high index refracts
            // everything toward the normal so that cosine barely moves —
            // 1.42 bottoms out at 0.71 and the bands go flat, leaving a
            // uniform tint. 1.20 bottoms out near 0.55, so the hue sweeps a
            // full cycle across a ridge and the colour follows the FORM.
            float nf   = 1.20;                                // film IOR
            float ct   = clamp(N.z, 0.0, 1.0);                // cos in air
            float st2  = max(1.0 - ct * ct, 0.0);
            float ctf  = sqrt(max(1.0 - st2 / (nf * nf), 0.0));
            float opd  = 2.0 * nf * dnm * ctf;                // path difference
            // Centred on 1 rather than on 0.5, so turning the film up tints the
            // reflection instead of halving it.
            vec3 phase = TAU * opd / vec3(650.0, 550.0, 450.0) + PI;
            F *= max(vec3(1.0) + clamp(uFilm, 0.0, 1.0) * 0.55 * cos(phase), 0.0);
        }

        vec3 met = room * F;

        col = mix(emb, met, clamp(uMetal, 0.0, 1.0));
    }

    col *= uExposure;

    if (uBloom > 0.001){
        float l = dot(col, vec3(0.299, 0.587, 0.114));
        col += col * smoothstep(0.55, 1.30, l) * uBloom * 0.9;
    }

    // max() on the base: pow() with a negative base and a fractional exponent
    // is undefined in GLSL ES 1.00, and glslop names it as a silent-failure
    // cause. q is inside (0,1) so the product cannot actually go negative here,
    // but the guard is free and the rule is worth obeying literally.
    vec2 q = fragCoord / R;
    float vig = pow(max(16.0 * q.x * q.y * (1.0 - q.x) * (1.0 - q.y), 0.0), 0.25);
    col *= mix(1.0, vig, uVignette);

    col += (hash12(fragCoord + fract(TIME) * 311.0) - 0.5) * uGrain * 0.09;

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