/*{
  "DESCRIPTION": "Developer — six other glslop shaders, laid face-down on one sheet of fibre paper and dropped in a tray. Each poster is treated as a LIGHT SOURCE, not a picture: where it glows it burns silver into the paper, so the corpus's own house style (emissive light on black) comes back out of the tray as ink on white. What you are watching is the chemistry, not a slideshow — a front of fresh developer sweeps each sheet, densities rise brightest-first out of chemical fog, agitation lays drag streaks across everything, adjacency effects put Mackie lines along every hard border, the developer is finite so sheets coming up together starve each other, and each image bleaches back to paper while the next arrives through it. Photogram sources: Lissajous Ghost (zfmbougb), Dipole (q8vd7md0), Digigenesis (nvzlpn3y), Ebru (pgjpt0qh), Wagara Kamon (14iy1g86), Telemetry (ry70cv0q). Single pass, no feedback, GLSL ES 1.00, seamless at any period.",
  "CREDIT": "built out of the commons it is posted to",
  "CATEGORIES": ["darkroom","photogram","paper","ink","monochrome","commons","seamless-loop"],
  "INPUTS": [
    { "NAME": "src0", "TYPE": "image", "SOURCE": "zfmbougb" },
    { "NAME": "src1", "TYPE": "image", "SOURCE": "q8vd7md0" },
    { "NAME": "src2", "TYPE": "image", "SOURCE": "nvzlpn3y" },
    { "NAME": "src3", "TYPE": "image", "SOURCE": "pgjpt0qh" },
    { "NAME": "src4", "TYPE": "image", "SOURCE": "14iy1g86" },
    { "NAME": "src5", "TYPE": "image", "SOURCE": "ry70cv0q" },

    { "NAME": "expose",    "TYPE": "float", "DEFAULT": 1.2,  "MIN": 0.2,  "MAX": 3.0 },
    { "NAME": "grade",     "TYPE": "float", "DEFAULT": 3.0,  "MIN": 1.0,  "MAX": 6.0 },
    { "NAME": "develop",   "TYPE": "float", "DEFAULT": 1.0,  "MIN": 0.1,  "MAX": 2.2 },
    { "NAME": "agitation", "TYPE": "float", "DEFAULT": 1.0,  "MIN": 0.0,  "MAX": 2.5 },
    { "NAME": "acutance",  "TYPE": "float", "DEFAULT": 1.0,  "MIN": 0.0,  "MAX": 3.0 },
    { "NAME": "wash",      "TYPE": "float", "DEFAULT": 1.0,  "MIN": 0.0,  "MAX": 2.5 },
    { "NAME": "grain",     "TYPE": "float", "DEFAULT": 1.0,  "MIN": 0.0,  "MAX": 2.5 },
    { "NAME": "stain",     "TYPE": "float", "DEFAULT": 0.25, "MIN": 0.0,  "MAX": 1.0 },
    { "NAME": "toning",    "TYPE": "float", "DEFAULT": 0.35, "MIN": -1.0, "MAX": 1.0 },
    { "NAME": "period",    "TYPE": "float", "DEFAULT": 34.0, "MIN": 10.0, "MAX": 90.0 },
    { "NAME": "paper",     "TYPE": "color", "DEFAULT": [0.960, 0.942, 0.895, 1.0] }
  ]
}*/

#ifdef GL_FRAGMENT_PRECISION_HIGH
precision highp float;
#endif

#define TAU 6.2831853

// Where in the cycle TIME=0 sits. Tuned so a hover starts you mid-process and
// the default poster time lands on a fully worked sheet, not blank paper.
#define PHASE0 0.947

float lum3(vec3 c){ return dot(c, vec3(0.2126, 0.7152, 0.0722)); }

float hash21(vec2 p){
  p = fract(p * vec2(127.31, 311.7));
  p += dot(p, p + 41.53);
  return fract(p.x * p.y);
}

// Plain value noise. Static in p, so every time dependence is injected by the
// caller as an offset that orbits a circle -- which is what keeps this seamless.
float vnoise(vec2 p){
  vec2 i = floor(p), f = fract(p);
  f = f * f * (3.0 - 2.0 * f);
  float a = hash21(i);
  float b = hash21(i + vec2(1.0, 0.0));
  float c = hash21(i + vec2(0.0, 1.0));
  float d = hash21(i + vec2(1.0, 1.0));
  return mix(mix(a, b, f.x), mix(c, d, f.x), f.y);
}

// ---------------------------------------------------------------------------
// Developer activity across the tray: slow chemical mottle plus the rocking
// waves of agitation. Roughly 0..1.4, mean near 0.5.
// ---------------------------------------------------------------------------
float developerField(vec2 p, vec2 orb, float ph, float agit){
  float n = 0.62 * vnoise(p * 2.1 + orb)
          + 0.28 * vnoise(p * 5.3 - orb * 1.4);

  float w = 0.5 * sin(dot(p, vec2(3.1, 1.4)) - TAU * ph * 3.0)
          + 0.5 * sin(dot(p, vec2(-1.9, 3.6)) - TAU * ph * 5.0);

  return clamp(n + agit * 0.30 * w, 0.0, 1.4);
}

// ---------------------------------------------------------------------------
// How far development has got on one sheet, at this point, right now.
// Texture-free, so all six can be evaluated up front and made to compete for a
// finite amount of developer before any of them costs a fetch.
//
// Everything here is keyed to ph in [0, ~0.65] and is identically zero outside
// it, so the wrap at ph=1 -> 0 is silent and the whole piece loops exactly.
// ---------------------------------------------------------------------------
float levelOf(vec2 p, float ph, vec2 sweepDir, float chem){
  if (ph > 0.66) return 0.0;

  // A front of fresh developer crosses the sheet: nothing anywhere at ph=0,
  // everything by ph~0.30, with a broad partly-developed band in between.
  float front = dot(p, sweepDir);
  float rise  = smoothstep(-1.1, 0.7, front + 14.0 * ph - 2.4);

  // Clearing is mottled rather than a uniform fade, so it dissolves unevenly.
  float fade  = 1.0 - smoothstep(0.34, 0.56, ph + 0.16 * (chem - 0.5));

  return rise * fade;
}

// ---------------------------------------------------------------------------
// One sheet's silver.
//   returns rgb = chemical stain (chroma bleeding while wet), a = density
// ---------------------------------------------------------------------------
vec4 printOne(sampler2D tex, vec2 p, float lev, float want, float ang, vec2 offBase,
              float chem, float safeSc, float halfDiag, float edgeAmt, float devAmt,
              float gain){

  if (lev <= 0.002) return vec4(0.0);

  // Placement. safeSc is the largest scale that keeps every tap inside 0..1 of
  // the poster, and the offset only ever spends the margin that scale leaves
  // over -- so a clamped edge can never smear into frame at ANY aspect ratio.
  float sc  = safeSc * want;
  vec2  off = offBase * (0.5 - sc * halfDiag);

  float ca = cos(ang), sa = sin(ang);
  vec2 q = vec2(ca * p.x - sa * p.y, sa * p.x + ca * p.y) * sc + 0.5 + off;

  // PHOTOGRAM. The source shader is not a picture being copied, it is a light
  // laid on the paper. Where it glows, silver forms and the sheet goes black;
  // where it is dark the paper stays white. Exposure IS luminance, put through
  // the steep characteristic curve of a graded paper.
  vec3 src = IMG_NORM_PIXEL(tex, q).rgb;
  float e = pow(clamp(lum3(src) * expose * gain, 0.0, 1.0), grade);

  // Adjacency (Mackie / border) effect: developer exhausts locally, so a dense
  // area starves its neighbours. That is exactly unsharp masking against the
  // local mean. Four taps in a diamond.
  float r = 0.0045;
  float eb = lum3(IMG_NORM_PIXEL(tex, q + vec2( r, 0.0)).rgb)
           + lum3(IMG_NORM_PIXEL(tex, q + vec2(-r, 0.0)).rgb)
           + lum3(IMG_NORM_PIXEL(tex, q + vec2(0.0,  r)).rgb)
           + lum3(IMG_NORM_PIXEL(tex, q + vec2(0.0, -r)).rgb);
  eb = pow(clamp(eb * 0.25 * expose * gain, 0.0, 1.0), grade);
  float es = clamp(e + edgeAmt * 0.60 * (e - eb), 0.0, 1.0);

  // Density growth. The rate rises with exposure, so the strongest light comes
  // up first and the faint detail arrives last -- the thing you actually stand
  // there and watch happen.
  float prog = devAmt * lev * (0.32 + 0.95 * chem) * 7.0;
  float dens = es * (1.0 - exp(-prog * (0.24 + 2.7 * es)));

  // Bromide drag: a darker line trails the advancing front.
  float band = 4.0 * lev * (1.0 - lev);
  dens += 0.11 * es * band;

  // Chemical stain: the source's own colour bleeds through while the emulsion
  // is actively working, and washes out once the sheet settles.
  vec3 chroma = src - vec3(lum3(src));
  return vec4(chroma * band * dens, dens);
}

void main(){
  vec2 R = RENDERSIZE;
  float m = min(R.x, R.y);
  vec2 p = (gl_FragCoord.xy - 0.5 * R) / m;        // aspect-correct, +-0.5 short axis

  float halfDiag = length(0.5 * R) / m;
  float safeSc   = 0.44 / halfDiag;

  float ph  = fract(TIME / max(period, 4.0) + PHASE0);
  vec2  orb = 0.75 * vec2(cos(TAU * ph), sin(TAU * ph));

  // ---- tray liquid: surface height + analytic gradient --------------------
  vec2 k1 = vec2( 11.3,  5.1);
  vec2 k2 = vec2( -7.2, 13.4);
  vec2 k3 = vec2( 16.9, -9.7);
  float a1 = dot(p, k1) - TAU * ph *  5.0;
  float a2 = dot(p, k2) - TAU * ph *  7.0;
  float a3 = dot(p, k3) + TAU * ph * 11.0;
  float h  = 0.52 * sin(a1) + 0.36 * sin(a2) + 0.22 * sin(a3);
  vec2  gh = 0.52 * cos(a1) * k1 + 0.36 * cos(a2) * k2 + 0.22 * cos(a3) * k3;

  vec2 pw = p + gh * 0.0016 * wash;                // refraction through the liquid

  float chem = developerField(pw, orb, ph, agitation);

  // Uneven agitation leaves permanent density streaks: drag off the dense
  // areas, surge marks off the tray end.
  float streak = 0.62 * vnoise(vec2(pw.x *  8.0, pw.y *  0.9) + orb * 0.5)
               + 0.38 * vnoise(vec2(pw.x *  2.1, pw.y *  9.0) - orb * 0.4);

  // ---- six sheets, competing for a finite tray of developer ---------------
  vec2 d0 = vec2( 0.94,  0.34), d1 = vec2(-0.45,  0.89), d2 = vec2( 0.20, -0.98);
  vec2 d3 = vec2(-0.87, -0.49), d4 = vec2( 0.68,  0.73), d5 = vec2(-0.30, -0.95);

  float L0 = levelOf(pw, fract(ph + 0.0000), d0, chem);
  float L1 = levelOf(pw, fract(ph + 0.1667), d1, chem);
  float L2 = levelOf(pw, fract(ph + 0.3333), d2, chem);
  float L3 = levelOf(pw, fract(ph + 0.5000), d3, chem);
  float L4 = levelOf(pw, fract(ph + 0.6667), d4, chem);
  float L5 = levelOf(pw, fract(ph + 0.8333), d5, chem);

  // Finite developer. One sheet alone develops fully; sheets that come up
  // together starve each other, which is what stops an overlap turning to grey
  // soup and makes the sheet patchy the way a real one is.
  float k = min(1.4 / (0.4 + L0 + L1 + L2 + L3 + L4 + L5), 1.0);

  vec4 acc = vec4(0.0);
  acc += printOne(src0, pw, L0 * k, 0.95, -0.05, vec2( 0.10, -0.30), chem, safeSc, halfDiag, acutance, develop, 1.25);
  acc += printOne(src1, pw, L1 * k, 0.72,  0.09, vec2(-0.45,  0.20), chem, safeSc, halfDiag, acutance, develop, 1.00);
  acc += printOne(src2, pw, L2 * k, 0.88, -0.21, vec2( 0.30,  0.40), chem, safeSc, halfDiag, acutance, develop, 1.15);
  acc += printOne(src3, pw, L3 * k, 0.55,  0.15, vec2(-0.20, -0.35), chem, safeSc, halfDiag, acutance, develop, 0.85);
  acc += printOne(src4, pw, L4 * k, 0.80,  0.04, vec2( 0.42, -0.15), chem, safeSc, halfDiag, acutance, develop, 0.72);
  acc += printOne(src5, pw, L5 * k, 0.62, -0.11, vec2(-0.35,  0.38), chem, safeSc, halfDiag, acutance, develop, 1.30);

  // Silver is additive in density; a soft knee keeps a pile-up from collapsing
  // to a flat black rectangle.
  float dens = acc.a;
  dens = dens / (1.0 + 0.34 * dens);

  // Agitation mottle, then the chemical fog no working tray is ever without.
  dens *= clamp(1.0 + agitation * 0.30 * (streak - 0.5) * 2.0, 0.45, 1.55);
  dens += 0.040 * (0.30 + 0.85 * chem);

  // ---- paper --------------------------------------------------------------
  float fib = 0.5 * vnoise(vec2(p.x * 240.0, p.y * 37.0))
            + 0.5 * vnoise(vec2(p.x * 31.0, p.y * 205.0));
  vec3 base = paper.rgb * (1.0 + (fib - 0.5) * 0.055);

  // Split-toned absorption: warm sepia shadows at positive toning, cold
  // selenium-blue at negative.
  vec3 absorb = vec3(2.45) + toning * vec3(-0.45, 0.02, 0.60);

  vec3 col = base * exp(-dens * absorb);

  // Staining at the wet front, soft-kneed: small chemical accents come through
  // untouched, a whole saturated sheet does not swamp the ink.
  vec3 st = acc.rgb * stain * 0.85;
  col += st / (1.0 + 1.6 * length(st));

  // Silver grain, strongest in the midtones. Static, so it reads as emulsion
  // rather than video noise and stays loop-safe.
  float g  = hash21(floor(p * 940.0) + 17.0) - 0.5;
  float tv = clamp(lum3(col) / max(lum3(base), 0.001), 0.0, 1.0);
  col += g * grain * 0.10 * (4.0 * tv * (1.0 - tv));

  // ---- wet sheen ----------------------------------------------------------
  vec3 nrm = normalize(vec3(-gh * 0.020, 1.0));
  vec3 lgt = normalize(vec3(-0.34, 0.52, 0.78));
  col += vec3(0.90, 0.94, 1.0) * pow(max(dot(nrm, lgt), 0.0), 9.0) * 0.055 * wash;
  col *= 1.0 - 0.05 * wash * (0.5 - 0.5 * h);      // faint depth in the liquid

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