/*{
  "DESCRIPTION": "Plate XXIV. An ammonite cut in copperplate and pulled in two inks on warm laid paper. The shell is a real height field - log-spiral whorls with a rounded section, bifurcating ribs and umbilical tubercles - marched under a raking light that sweeps across it. The hatching is laid out on the shell's own coil coordinates: the primary lay is locked to the rib phase, so every stroke runs across the whorl the way a burin follows the sculpture, and it converges into the umbilicus by itself. Line WEIGHT carries the whole value structure; crosshatch, the third diagonal and the lozenge dot enter only where the tone below them has run out of room, and the darks stay open so paper still flecks through. Second plate is a ruled tint screen at its own angle, drifting slowly in and out of registration. Plate mark, wiped plate tone, laid lines, tooth, border rules, caption and scale bar.",
  "CREDIT": "",
  "CATEGORIES": ["print", "engraving", "paper"],
  "INPUTS": [
    { "NAME": "inkKey",       "TYPE": "color", "DEFAULT": [0.118, 0.098, 0.092, 1.0] },
    { "NAME": "inkTint",      "TYPE": "color", "DEFAULT": [0.596, 0.330, 0.235, 1.0] },
    { "NAME": "paperCol",     "TYPE": "color", "DEFAULT": [0.938, 0.902, 0.826, 1.0] },
    { "NAME": "hatchDensity", "TYPE": "float", "DEFAULT": 1.0,  "MIN": 0.4,  "MAX": 2.2 },
    { "NAME": "lineWeight",   "TYPE": "float", "DEFAULT": 1.0,  "MIN": 0.4,  "MAX": 1.7 },
    { "NAME": "tintInk",      "TYPE": "float", "DEFAULT": 1.00, "MIN": 0.0,  "MAX": 1.6 },
    { "NAME": "registration", "TYPE": "float", "DEFAULT": 2.6,  "MIN": 0.0,  "MAX": 7.0 },
    { "NAME": "paperGrain",   "TYPE": "float", "DEFAULT": 1.0,  "MIN": 0.0,  "MAX": 2.0 },
    { "NAME": "plateTilt",    "TYPE": "float", "DEFAULT": 0.42, "MIN": 0.0,  "MAX": 0.85 },
    { "NAME": "ribDepth",     "TYPE": "float", "DEFAULT": 0.55, "MIN": 0.0,  "MAX": 1.6 }
  ]
}*/

#ifdef GL_FRAGMENT_PRECISION_HIGH
precision highp float;
#endif

#define PI  3.14159265
#define TAU 6.28318531

/* ---------------------------------------------------------------- shell */
/* log-spiral coil: r = exp(SB * theta), theta = atan + 2*PI*n, theta <= 0
   at the aperture. One whorl period in "S" space is exactly 1.0, so the
   across-whorl coordinate e = S - round(S) runs -0.5 .. 0.5 and the coil
   parameter is continuous everywhere (mod an integer). */
#define SB     0.163
#define THMAX  0.0
#define THMIN -24.0
#define HAMP   0.440
#define SUTFL  0.34
#define RIBN   30.0
#define HCEIL  0.62
#define COILC  0.5403   /* cos(1.0) : the coil is turned so the aperture faces lower-right */
#define COILS  0.8415

float h11(float n){ return fract(sin(n * 127.1) * 43758.5453); }
float h21(vec2 p){ return fract(sin(dot(p, vec2(127.1, 311.7))) * 43758.5453); }

float vnoise(vec2 p){
    vec2 i = floor(p), f = fract(p);
    f = f * f * (3.0 - 2.0 * f);
    return mix(mix(h21(i), h21(i + vec2(1.0, 0.0)), f.x),
               mix(h21(i + vec2(0.0, 1.0)), h21(i + vec2(1.0, 1.0)), f.x), f.y);
}

mat2 rot(float a){ float c = cos(a), s = sin(a); return mat2(c, -s, s, c); }

float sdBox(vec2 p, vec2 b){ vec2 d = abs(p) - b; return min(max(d.x, d.y), 0.0) + length(max(d, 0.0)); }

float sdSeg(vec2 p, vec2 a, vec2 b){
    vec2 pa = p - a, ba = b - a;
    float h = clamp(dot(pa, ba) / max(dot(ba, ba), 1e-9), 0.0, 1.0);
    return length(pa - ba * h);
}

/* returns (height, e, theta, rib) */
vec4 shellEval(vec2 qin){
    vec4 z = vec4(0.0);
    vec2 q = mat2(COILC, -COILS, COILS, COILC) * qin;
    float r = length(q);
    if (r < 0.016 || r > 1.03) return z;
    float a  = atan(q.y, q.x);
    float S  = (log(r) / SB - a) * (1.0 / TAU);
    float n  = floor(S + 0.5);
    float e  = S - n;
    float th = a + TAU * n;
    if (th > THMAX || th < THMIN) return z;

    float rc  = exp(SB * th);            /* whorl centreline radius */
    float amp = HAMP * rc;

    /* is there a whorl outside / inside this one? if not, round the flank off */
    float fo = mix(smoothstep(0.50, 0.30,  e), 1.0, step(th + TAU, THMAX));
    float fi = mix(smoothstep(0.50, 0.30, -e), 1.0, step(THMIN, th - TAU));
    float fl = min(fo, fi);

    /* the aperture is a rounded lip, not a cliff */
    float ga = smoothstep(THMAX + 0.01, THMAX - 0.10, th);

    float t  = max(0.0, 1.0 - 4.0 * e * e);
    float pr = sqrt(t); pr = pr * (1.36 - 0.36 * pr * pr);   /* rounded whorl, flat crest, steep flanks */
    float h  = amp * (SUTFL * fl + (1.0 - SUTFL) * pr) * ga;

    /* ribs: swept forward across the flank, bifurcating toward the venter,
       fading out at the umbilical suture. phase stays continuous across a
       suture because RIBN is an integer and the sweep is a whole TAU. */
    float rp2 = th * RIBN + TAU * e;
    float rib = mix(cos(rp2), 0.5 * cos(rp2) + 0.55 * cos(2.0 * rp2 + 0.7),
                    smoothstep(-0.12, 0.30, e));
    float ribM = (0.30 + 0.70 * smoothstep(-0.46, 0.22, e)) * smoothstep(0.50, 0.38, abs(e));
    h += amp * ribDepth * 0.11 * rib * ribM * pr * fl * ga;

    /* umbilical tubercles on the rib crests */
    float dn = (e + 0.28) * 6.0;
    float bn = max(0.0, 1.0 - dn * dn);
    float rp = max(cos(rp2), 0.0); rp *= rp;
    h += amp * 0.060 * bn * rp * fl * ga;

    return vec4(h, e, th, rib);
}

float softShadow(vec3 p, vec3 L, float dt){
    float s = 1.0;
    for (int i = 1; i <= 12; i++){
        float k = dt * float(i);
        vec3 q = p + L * (k + 0.010);
        if (q.z > HCEIL) break;
        float h = shellEval(q.xy).x;
        s = min(s, clamp((q.z - h) * 6.0 / k, 0.0, 1.0));
    }
    return clamp(s, 0.0, 1.0);
}

/* one filtered family of burin lines.
   phv  : phase (lines sit at integer phase)
   gpx  : |d(phase)/d(pixel)|
   wf   : ink fraction of the period                                        */
float hatch(float phv, float gpx, float wf, float jit){
    if (wf <= 0.0006) return 0.0;
    float li = floor(phv + 0.5);
    float o  = phv - li;
    o += (h11(li * 1.7) - 0.5) * jit;
    float w  = wf * (0.84 + 0.32 * h11(li * 5.3 + 11.0));
    float gp = max(gpx, 1e-5);
    float d  = abs(o) / gp;
    float hw = 0.5 * w / gp;
    float cov = clamp(min(d + 0.5, hw) - max(d - 0.5, -hw), 0.0, 1.0);
    float f = smoothstep(0.26, 0.62, gp);        /* too fine to resolve -> flat tone */
    return mix(cov, clamp(w, 0.0, 1.0), f);
}

void main(){
    float mn  = min(RENDERSIZE.x, RENDERSIZE.y);
    vec2  sp  = (gl_FragCoord.xy - 0.5 * RENDERSIZE) / mn;
    float pxs = 1.0 / mn;                         /* one pixel in sp units */

    /* ---------------------------------------------------------- motion */
    float ph = fract(TIME / 32.0);
    float w1 = TAU * ph;
    float spin    = 0.048 * sin(w1 + 2.4);
    float lightAz = 2.32 + 0.62 * sin(w1) - spin;
    float lightEl = 0.60 + 0.11 * sin(2.0 * w1);
    float tilt    = clamp(plateTilt + 0.045 * sin(w1 + 1.2), 0.0, 1.1);
    vec2  regOff  = registration * (mn / 512.0) * vec2(cos(w1), sin(w1));

    /* ---------------------------------------------------------- camera */
    const float VS = 3.15;                        /* object units across one sp unit */
    const float CY = 0.050;                       /* specimen sits a touch high */
    float ct = cos(tilt), st = sin(tilt);
    vec3 fwd = vec3(0.0, st, -ct);
    vec3 rgt = vec3(1.0, 0.0, 0.0);
    vec3 upv = vec3(0.0, ct, st);
    vec2 spr = rot(spin) * (sp - vec2(0.0, CY));
    /* the specimen is coiled with its aperture toward the lower right */
    vec3 ro = rgt * (spr.x * VS) + upv * (spr.y * VS) - fwd * 3.0;
    vec3 rd = fwd;

    float pxObj = VS / mn;

    /* ------------------------------------------------------ height march */
    float t1 = ro.z / ct;                         /* ray reaches z = 0 */
    float t0 = max((ro.z - HCEIL) / ct, 0.0);
    vec2  A  = (ro + rd * t0).xy;
    vec2  B  = (ro + rd * t1).xy;
    vec2  AB = B - A;
    float uu = clamp(dot(-A, AB) / max(dot(AB, AB), 1e-9), 0.0, 1.0);
    float dmin = length(A + AB * uu);
    float rseg = max(length(A), length(B));
    /* local ceiling: the coil is never taller than ~0.56 of its own radius */
    t0 = max(t0, (ro.z - min(HCEIL, 0.70 * rseg + 0.02)) / ct);

    float tHit = t1;
    if (dmin < 1.04){
        const int NS = 40;
        float dt = (t1 - t0) / float(NS);
        float pd = 1.0, pt = t0;
        for (int i = 1; i <= NS; i++){
            float t = t0 + dt * float(i);
            vec3  q = ro + rd * t;
            float d = q.z - shellEval(q.xy).x;
            if (d < 0.0){
                tHit = pt + (t - pt) * (pd / max(pd - d, 1e-6));
                break;
            }
            pd = d; pt = t;
        }
    }

    vec3  P  = ro + rd * tHit;
    vec4  si = shellEval(P.xy);
    bool  onShell = si.x > 0.0008;

    vec3 Lv = vec3(cos(lightAz) * cos(lightEl), sin(lightAz) * cos(lightEl), sin(lightEl));

    /* --------------------------------------------------- tone + line work */
    float D    = 0.0;        /* darkness 0..1 */
    float ink  = 0.0;        /* key-plate coverage */
    float tint = 0.0;        /* tint-plate tone */

    if (onShell){
        float ee = max(0.0020, pxObj * 0.75);
        float hx = shellEval(P.xy + vec2(ee, 0.0)).x - shellEval(P.xy - vec2(ee, 0.0)).x;
        float hy = shellEval(P.xy + vec2(0.0, ee)).x - shellEval(P.xy - vec2(0.0, ee)).x;
        vec3  N  = normalize(vec3(-hx, -hy, 2.0 * ee));
        float slope = length(vec2(hx, hy)) / (2.0 * ee);
        float r   = max(length(P.xy), 1e-4);

        /* An ammonite laid flat is nearly a disc: physically correct shading
           gives it no large-scale form at all. Draughtsmen never draw it that
           way - they read the whole specimen as one convex body and swing the
           tone right across it. Tilting the normal outward with radius is that
           reading, and it is what gives the plate a lit side and a dark side. */
        vec3 Nd = normalize(N + vec3(P.xy * 0.52, 0.0));

        float ndl = max(dot(Nd, Lv), 0.0);
        float sh  = softShadow(P + N * 0.004, Lv, 0.050);

        float ao = mix(0.26, 1.0, smoothstep(0.50, 0.19, abs(si.y)));
        ao *= mix(0.34, 1.0, smoothstep(0.035, 0.30, r));
        float fill = 0.5 + 0.5 * Nd.z;

        float lum = 0.038 * ao + 0.105 * fill * ao + 1.22 * ndl * mix(0.22, 1.0, sh) * ao;
        float tone = 1.0 - exp(-1.55 * lum);
        tone = mix(tone, tone * tone * (3.0 - 2.0 * tone), 0.65);  /* the plate contrast curve */
        D = clamp(1.0 - tone, 0.0, 1.0);
        /* burin contour: the umbilical walls take a heavier line */
        D = max(D, smoothstep(3.0, 7.5, slope) * 0.70);
        /* and the specimen is OUTLINED, the way a plate always is - a line
           that thickens where it runs into shadow. rimT is the height of the
           surface relative to the whorl it belongs to, so it falls to zero
           exactly at the silhouette and at each suture. */
        float rimT = si.x / (HAMP * max(r, 0.06));
        D = max(D, smoothstep(0.26, 0.05, rimT) * (0.62 + 0.34 * D));

        /* ---- coil-space hatch frames ----
           The PRIMARY lay is locked to the rib phase, so every stroke runs
           across the whorl the way a burin follows the sculpture: the tone
           changes ACROSS the strokes (rib to rib) and only slowly ALONG them,
           which is what makes each line swell and taper instead of breaking
           into dashes. Because the lay is angular, it converges into the
           umbilicus on its own. The secondary lay is a spiral sheared into a
           diagonal; C and D are the two diagonals of A x B, deepest darks only.
           All four phases jump by whole integers at a suture, so fract() stays
           continuous and there is no seam. */
        vec2 qr = mat2(COILC, -COILS, COILS, COILC) * P.xy;
        vec2 rh = qr / r;                         /* radial   unit */
        vec2 tg = vec2(-rh.y, rh.x);              /* tangent  unit */
        vec2 gS = (rh / SB - tg) * (1.0 / (TAU * r));   /* grad of coil coord S */
        vec2 gT = tg / r;                                /* grad of theta       */

        float NM  = 2.0 * max(1.0, floor(2.0 * hatchDensity + 0.5));   /* strokes per rib   */
        float NSp = 2.0 * max(2.0, floor(8.0 * hatchDensity + 0.5));   /* spiral lay        */
        float NK  = 2.0 * floor(26.0 * hatchDensity + 0.5);            /* its forward shear */

        vec2 gA = (gT * (RIBN / TAU) + gS) * NM;
        vec2 gB =  gS * NSp + gT * (NK / TAU);
        float fp = pxObj / max(dot(N, -rd), 0.22);       /* object units per pixel on surface */

        float pA = (si.z * (RIBN / TAU) + si.y) * NM;
        float pB =  si.y * NSp + si.z * (NK / TAU);
        float gpA = length(gA) * fp;
        float gpB = length(gB) * fp;
        float gpC = length(gA + gB) * 0.5 * fp;
        float gpD = length(gA - gB) * 0.5 * fp;

        /* the tonal ladder of a real plate: the primary lay carries everything
           up to a heavy midtone on its own (swelling from a hairline to half
           the pitch), and each further lay only enters once the tone below it
           has genuinely run out of room. */
        float lw = lineWeight;
        float wA = (smoothstep(0.035, 0.46, D) * 0.34 + smoothstep(0.40, 0.92, D) * 0.26) * lw;
        float wB =  smoothstep(0.64, 0.96, D) * 0.40 * lw;
        float wC =  smoothstep(0.80, 1.00, D) * 0.34 * lw;
        float wD =  smoothstep(0.93, 1.00, D) * 0.24 * lw;

        float cA = hatch(pA, gpA, wA, 0.10);
        float cB = hatch(pB, gpB, wB, 0.08);
        float cC = hatch((pA + pB) * 0.5, gpC, wC, 0.07);
        float cD = hatch((pA - pB) * 0.5, gpD, wD, 0.07);

        /* the lozenge dot that sits in the white diamond of the deepest crosshatch */
        float wDot = smoothstep(0.85, 1.00, D) * 0.36;
        float zA = (fract(pA) - 0.5) / max(gpA, 1e-5);
        float zB = (fract(pB) - 0.5) / max(gpB, 1e-5);
        float dd = length(vec2(zA, zB));
        float rr = wDot * 0.5 / max(max(gpA, gpB), 1e-5);
        float cE = clamp(min(dd + 0.5, rr) - max(dd - 0.5, -rr), 0.0, 1.0);
        cE *= 1.0 - smoothstep(0.30, 0.60, max(gpA, gpB));

        ink  = 1.0 - (1.0 - cA) * (1.0 - cB) * (1.0 - cC) * (1.0 - cD) * (1.0 - cE);
        /* the tint plate carries the mid-shadow, where the key plate is still
           open enough for the second ink to actually show through */
        tint = smoothstep(0.16, 0.56, D) * (1.0 - 0.42 * smoothstep(0.74, 1.0, D));
    } else {
        /* bare paper: nothing but a short contact shadow to seat the specimen.
           The umbilical perforation at the very centre of the coil is the one
           place paper shows THROUGH the specimen, and it has to be solid ink,
           not a white pinhole. */
        float cs  = 1.0 - softShadow(vec3(P.xy, 0.003), Lv, 0.017);
        float umb = smoothstep(0.055, 0.016, length(P.xy));
        D = max(cs * 0.22, umb * 0.94);
        float spc = mn / 150.0;
        float pP  = dot(gl_FragCoord.xy, vec2(0.8192, 0.5736)) / spc;
        ink  = hatch(pP, 1.0 / spc, smoothstep(0.02, 0.28, cs * 0.22) * 0.34 * lineWeight, 0.12);
        ink  = max(ink, umb * 0.90);
        tint = max(cs * 0.30, umb * 0.55);
    }

    /* registration: the tint plate is pulled a hair off the key plate */
    vec2 shiftObj = vec2(regOff.x * pxObj, regOff.y * pxObj / max(ct, 0.15));
    float mShift = step(0.0008, shellEval(P.xy + shiftObj).x);
    float tintTone = onShell ? tint * mShift : max(tint * 0.7, 0.44 * mShift);

    /* ------------------------------------------------------------- paper */
    vec2 gp = gl_FragCoord.xy;
    float tooth  = vnoise(gp * 0.95) * 0.60 + vnoise(gp * 0.22) * 0.40;
    float mottle = vnoise(gp * (5.0 / mn) * 12.0 + 17.0);
    float laid   = sin(gp.y * TAU * 46.0 / mn) * 0.5 + 0.5;
    float chain  = sin(gp.x * TAU * 6.0 / mn) * 0.5 + 0.5;

    vec3 col = paperCol.rgb;
    col *= 1.0 + ((mottle - 0.5) * 0.045 + (tooth - 0.5) * 0.038
                 + (laid - 0.5) * 0.016 + (chain - 0.5) * 0.014) * paperGrain;
    col += vec3(0.014, 0.004, -0.010) * (mottle - 0.5) * paperGrain;

    /* plate mark: the copper's bevelled edge pressed into the sheet */
    vec2  he = vec2(0.5 * RENDERSIZE.x, 0.5 * RENDERSIZE.y) / mn - 0.032;
    float dP = sdBox(sp, he);
    vec2  d2 = abs(sp) - he;
    vec2  nb = (d2.x > d2.y) ? vec2(sign(sp.x), 0.0) : vec2(0.0, sign(sp.y));
    float lit = dot(nb, normalize(vec2(-0.6, 0.8)));
    float bevel = (1.0 - smoothstep(0.0, 3.2 * pxs, abs(dP + 1.6 * pxs))) * (-0.42 * lit)
                + (1.0 - smoothstep(0.0, 2.6 * pxs, abs(dP - 1.1 * pxs))) * (0.20 * lit);
    col *= 1.0 + bevel * 0.55;

    /* wiped plate tone inside the mark */
    float inPlate = smoothstep(1.2 * pxs, -1.2 * pxs, dP);
    float wipe = vnoise(sp * vec2(7.0, 70.0) + 3.7) * 0.6 + vnoise(sp * vec2(3.0, 16.0)) * 0.4;
    col = mix(col, mix(col, inkKey.rgb, 0.028 + 0.034 * wipe), inPlate);

    /* --------------------------------------------------------- tint plate */
    /* A dot screen at this scale beats against the burin pitch and turns the
       whole midtone to speckle. A RULED tint screen at its own angle is both
       quieter and the more period-correct thing for a second plate. */
    float spcT = mn / 176.0;
    float pT   = dot(gl_FragCoord.xy + regOff, vec2(0.3420, -0.9397)) / spcT;
    float cT   = hatch(pT, 1.0 / spcT, clamp(tintTone, 0.0, 1.0) * 0.66, 0.06);
    cT *= 1.0 - 0.12 * tooth;
    col = mix(col, inkTint.rgb, clamp(cT * tintInk * 0.92, 0.0, 1.0) * inPlate);

    /* ---------------------------------------------------------- key plate */
    ink = min(ink, 0.90);   /* the darks stay open - paper still flecks through */
    ink *= 1.0 - 0.075 * tooth * paperGrain;
    col = mix(col, inkKey.rgb, clamp(ink, 0.0, 1.0) * 0.965 * inPlate);

    /* --------------------------------------------------------- furniture */
    vec2  be = he - 0.040;
    float f1 = 1.0 - smoothstep(0.5 * pxs, 1.7 * pxs, abs(sdBox(sp, be)));
    float f2 = 1.0 - smoothstep(1.4 * pxs, 3.0 * pxs, abs(sdBox(sp, be - 0.012)));
    float furn = max(f1 * 0.85, f2);

    /* scale bar with divisions */
    float by = -be.y + 0.030;
    float bar = 1.0 - smoothstep(0.5 * pxs, 1.6 * pxs, sdSeg(sp, vec2(-0.085, by), vec2(0.085, by)));
    for (int i = 0; i < 7; i++){
        float fi = float(i);
        float x  = mix(-0.085, 0.085, fi / 6.0);
        float hh = (mod(fi, 3.0) < 0.5) ? 0.016 : 0.009;
        bar = max(bar, 1.0 - smoothstep(0.5 * pxs, 1.6 * pxs, sdSeg(sp, vec2(x, by), vec2(x, by + hh))));
    }
    furn = max(furn, bar);

    /* caption: a line of small marks reading as a set species name */
    float cy = by + 0.050;
    float cw = 0.0042;
    float cx0 = -0.115;
    if (sp.x > cx0 && sp.x < -cx0 && abs(sp.y - cy) < 0.014){
        float xg = (sp.x - cx0) / cw;
        float gi = floor(xg);
        float gf = fract(xg);
        float sk = h11(gi * 3.1 + 4.0);
        float gap = step(0.87, h11(gi * 9.7 + 1.0));
        float hh = 0.0085 * (0.55 + 0.6 * sk);
        float asc = (sk > 0.72) ? 0.0055 : 0.0;
        float m = (1.0 - smoothstep(0.20, 0.30, abs(gf - 0.47)))
                * (1.0 - smoothstep(hh + asc, hh + asc + 1.2 * pxs, abs(sp.y - cy - asc * 0.5)))
                * (1.0 - gap);
        furn = max(furn, m * 0.9);
    }

    /* plate number, upper right inside the rule */
    float ny = be.y - 0.026;
    if (sp.x > be.x - 0.185 && sp.x < be.x - 0.030 && abs(sp.y - ny) < 0.012){
        float xg = (sp.x - (be.x - 0.185)) / 0.0050;
        float gi = floor(xg);
        float gf = fract(xg);
        float sk = h11(gi * 7.3 + 21.0);
        float gap = step(0.80, h11(gi * 2.9 + 6.0));
        float m = (1.0 - smoothstep(0.20, 0.32, abs(gf - 0.45)))
                * (1.0 - smoothstep(0.0085, 0.0085 + 1.2 * pxs, abs(sp.y - ny)))
                * (1.0 - gap) * (0.5 + 0.5 * step(0.3, sk));
        furn = max(furn, m * 0.85);
    }

    furn *= (1.0 - 0.22 * tooth) * inPlate;
    col = mix(col, inkKey.rgb, clamp(furn, 0.0, 1.0) * 0.90);

    /* outside the plate mark the sheet is clean and very slightly brighter */
    col *= mix(1.012, 1.0, inPlate);

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