/*{
  "DESCRIPTION": " a central third eye with a living Kali-fractal iris and hypnotic vortex pupil, a halo of twelve blinking eyes with energy-veined sclerae, spectral flame aura, log-polar mind-lattice tunnel, raymarched 3D fractal architecture drifting through the void, a parallax fractal medallion, crepuscular beams, dash-darts, gold light-spears and comet sparks all radiating from the center. Every layer on a slider, plus hue rotate/cycle.",
  "CREDIT": "KSIN",
  "CATEGORIES": ["generator", "psychedelic", "mandala", "eyes"],
  "INPUTS": [
    { "NAME": "uTempo",    "TYPE": "float", "DEFAULT": 1.40, "MIN": 0.0, "MAX": 3.0 },
    { "NAME": "uAura",     "TYPE": "float", "DEFAULT": 1.00, "MIN": 0.0, "MAX": 2.5 },
    { "NAME": "uFractal",  "TYPE": "float", "DEFAULT": 1.00, "MIN": 0.0, "MAX": 2.5 },
    { "NAME": "uLattice",  "TYPE": "float", "DEFAULT": 1.00, "MIN": 0.0, "MAX": 2.5 },
    { "NAME": "uBeams",    "TYPE": "float", "DEFAULT": 1.00, "MIN": 0.0, "MAX": 2.5 },
    { "NAME": "uDarts",    "TYPE": "float", "DEFAULT": 1.00, "MIN": 0.0, "MAX": 2.5 },
    { "NAME": "uSpears",   "TYPE": "float", "DEFAULT": 1.00, "MIN": 0.0, "MAX": 2.5 },
    { "NAME": "uSparks",   "TYPE": "float", "DEFAULT": 1.00, "MIN": 0.0, "MAX": 2.5 },
    { "NAME": "uLace",     "TYPE": "float", "DEFAULT": 1.00, "MIN": 0.0, "MAX": 2.5 },
    { "NAME": "uSat",      "TYPE": "float", "DEFAULT": 1.45, "MIN": 0.0, "MAX": 2.5 },
    { "NAME": "uContrast", "TYPE": "float", "DEFAULT": 0.62, "MIN": 0.0, "MAX": 1.0 },
    { "NAME": "uHue",      "TYPE": "float", "DEFAULT": 0.00, "MIN": 0.0, "MAX": 1.0 },
    { "NAME": "uHueSpeed", "TYPE": "float", "DEFAULT": 0.05, "MIN": 0.0, "MAX": 0.5 },
    { "NAME": "uCenter",   "TYPE": "float", "DEFAULT": 1.00, "MIN": 0.0, "MAX": 2.5 }
  ]
}*/

// SACRED MIRROR — homage to the style of Alex Grey
// ISF port of the Shadertoy/WebGL2 version (GLSL ES 1.00: fixed loop
// bounds, gl_FragColor, TIME/RENDERSIZE).

#define TAU 6.28318530718

// rotate color around the luminance axis; a in turns (0..1 = full cycle)
vec3 hueShift(vec3 c, float a){
    vec3 k = vec3(0.57735);
    float ca = cos(a * TAU);
    float sa = sin(a * TAU);
    return c * ca + cross(k, c) * sa + k * dot(k, c) * (1.0 - ca);
}

float hash21(vec2 p){
    p = fract(p * vec2(234.34, 435.345));
    p += dot(p, p + 34.23);
    return fract(p.x * p.y);
}

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

float fbm(vec2 p){
    float a = 0.5, s = 0.0;
    for (int i = 0; i < 5; i++){
        s += a * noise2(p);
        p = p * 2.03 + vec2(1.7, 9.2);
        a *= 0.5;
    }
    return s;
}

// full rainbow, biased electric — the spectral bands of the aura
vec3 spectrum(float t){
    vec3 c = 0.5 + 0.5 * cos(TAU * (t + vec3(0.0, 0.33, 0.67)));
    return c * c * (3.0 - 2.0 * c);   // steepen so bands separate
}

float glowline(float d, float w){
    return w / (abs(d) + w);
}

vec2 rot2(vec2 v, float a){
    float c = cos(a), s = sin(a);
    return vec2(v.x * c - v.y * s, v.x * s + v.y * c);
}

// 3D kaleidoscopic IFS: folded fractal architecture, sampled
// as volumetric glow by a short raymarch.
float kifsDE(vec3 p){
    float s = 1.0;
    for (int i = 0; i < 8; i++){
        p = abs(p);
        if (p.x < p.y) p.xy = p.yx;
        if (p.y < p.z) p.yz = p.zy;
        if (p.x < p.y) p.xy = p.yx;
        p = p * 1.9 - vec3(1.35, 1.05, 0.55);
        p.z = abs(p.z + 0.30) - 0.30;
        s *= 1.9;
    }
    return length(p) / s;
}

vec3 kifsGlow(vec2 uv, float r, float t){
    vec3 ro = vec3(0.0, 0.0, -3.2);
    vec3 rd = normalize(vec3(uv, 1.6));
    float ca = t * 0.045, cb = t * 0.034;
    ro.xz = rot2(ro.xz, ca);  rd.xz = rot2(rd.xz, ca);
    ro.yz = rot2(ro.yz, cb);  rd.yz = rot2(rd.yz, cb);
    float tt = 0.0, fog = 0.0;
    for (int i = 0; i < 36; i++){
        float d = kifsDE(ro + rd * tt);
        fog += exp(-abs(d) * 22.0);
        tt += max(abs(d) * 0.85, 0.03);
        if (tt > 9.0) break;
    }
    fog = min(fog, 16.0);   // never let the fog white out the frame
    vec3 kcol = mix(vec3(0.35, 0.55, 1.0), spectrum(fog * 0.03 + t * 0.02), 0.5);
    return kcol * fog * fog * 0.0011 * smoothstep(0.12, 0.60, r);
}

// ------------------------------------------------------------
// Kali-style fractal, folded into 12-fold mandala symmetry.
// ------------------------------------------------------------
vec3 fractalMandala(vec2 p, float t){
    float r = length(p);
    float seg = TAU / 12.0;
    float a = abs(mod(atan(p.y, p.x) + t * 0.06, seg) - seg * 0.5);
    p = vec2(cos(a), sin(a)) * r * 1.35;

    vec2 c = vec2(-0.735 + 0.055 * sin(t * 0.21),
                  -0.290 + 0.048 * cos(t * 0.16));
    float acc = 0.0, trap = 1000.0, trap2 = 1000.0;
    for (int i = 0; i < 9; i++){
        p = abs(p) / max(dot(p, p), 1e-6) + c;
        float d = abs(p.y - 0.15 * sin(p.x * 3.0 + t * 0.4));
        trap = min(trap, d);
        trap2 = min(trap2, abs(p.x));
        acc += exp(-7.0 * d);
    }
    vec3 col = spectrum(acc * 0.06 + r * 0.15 - t * 0.03) * acc * acc * 0.006;
    col += vec3(0.55, 0.70, 1.0) * glowline(trap, 0.010) * 0.34;
    col += vec3(1.0, 0.35, 0.85) * glowline(trap2, 0.008) * 0.20;
    return col * (0.5 + 0.5 / (1.0 + r * r));
}

// ------------------------------------------------------------
// 24 comet-streak sparks on looping radial trajectories.
// ------------------------------------------------------------
vec3 sparks(vec2 uv, float t){
    vec3 acc = vec3(0.0);
    for (int i = 0; i < 24; i++){
        float fi = float(i);
        float h1 = hash21(vec2(fi, 1.3));
        float h2 = hash21(vec2(fi, 7.7));
        float h3 = hash21(vec2(fi, 3.1));
        float life = fract(t * (0.10 + 0.14 * h2) + h3);
        float ang = h1 * TAU + t * 0.04 + 0.25 * sin(t * 0.3 + fi);
        float rad = 0.16 + life * 1.75;
        vec2 dir = vec2(cos(ang), sin(ang));
        vec2 q = uv - dir * rad;
        float d = length(vec2(dot(q, dir) * 0.30, dot(q, vec2(-dir.y, dir.x))));
        float fade = smoothstep(0.0, 0.12, life) * (1.0 - life);
        acc += (spectrum(h1 + life * 0.35) * 0.7 + 0.5)
             * (0.00045 / (d * d + 0.00008)) * fade;
    }
    return acc * 0.35;
}

// ------------------------------------------------------------
// An eye. p local, w = half-width. Returns rgb + alpha.
// ------------------------------------------------------------
vec4 eyeball(vec2 p, float w, float seed, float t){
    p /= w;

    float bt = fract(t * 0.09 + seed);
    float closeAmt = exp(-pow((bt - 0.5) / 0.030, 2.0));
    float open = clamp(1.0 - closeAmt, 0.03, 1.0);

    float lid = (1.0 - p.x * p.x) * 0.58 * open;
    float ap = lid - abs(p.y);
    float apMask = smoothstep(0.0, 0.05, ap) * step(abs(p.x), 1.0);

    vec2 q = p - vec2(0.10 * sin(t * 0.61 + seed * 37.0),
                      0.06 * cos(t * 0.83 + seed * 17.0));

    float ir  = length(q) / 0.46;
    float ang = atan(q.y, q.x);
    float fib = 0.5 + 0.5 * sin(ang * 40.0 + ir * 16.0 - t * 2.4
                                + seed * 61.0 + fbm(q * 5.0 + seed * 9.0) * 7.0);
    float irings = 0.5 + 0.5 * sin(ir * 26.0 + t * 3.2 + seed * 9.0);
    vec3 iris = mix(vec3(0.01, 0.06, 0.22), vec3(0.15, 0.70, 1.0), fib);
    iris = mix(iris, spectrum(ir * 0.30 + seed + t * 0.06), 0.55);
    iris *= 0.70 + 0.55 * irings;
    iris *= (0.30 + 1.15 * smoothstep(1.05, 0.30, ir)) * 1.40;

    // living fractal filigree woven through the iris (6-fold Kali fold)
    float fseg = TAU / 6.0;
    float fang = abs(mod(ang + t * 0.70 + seed * TAU, fseg) - fseg * 0.5);
    vec2 kp = vec2(cos(fang), sin(fang)) * ir * 1.3;
    vec2 fc = vec2(-0.78 + 0.11 * sin(t * 0.90 + seed * TAU),
                   -0.24 + 0.10 * cos(t * 0.70 + seed * 9.0));
    float fac = 0.0, ftrap = 1e3, ftrap2 = 1e3;
    for (int i = 0; i < 8; i++){
        kp = abs(kp) / max(dot(kp, kp), 1e-6) + fc;
        ftrap = min(ftrap, abs(kp.y));
        ftrap2 = min(ftrap2, abs(kp.x - 0.3));
        fac += exp(-6.0 * abs(kp.y));
    }
    iris *= 0.62;
    float lace1 = glowline(ftrap, 0.024);  lace1 *= lace1;
    float lace2 = glowline(ftrap2, 0.016); lace2 *= lace2;
    vec3 fcol = spectrum(fac * 0.10 + seed + t * 0.12) * fac * fac * 0.030;
    fcol += vec3(0.55, 0.85, 1.0) * lace1 * 1.7;
    fcol += vec3(1.0, 0.35, 0.90) * lace2 * 1.1;
    iris += fcol * smoothstep(1.02, 0.80, ir) * uLace;

    float pr = 0.38 + 0.055 * sin(t * 1.1 + seed * TAU);
    float pupil = smoothstep(pr + 0.04, pr - 0.04, ir);

    // sclera: dim bed + radiating energy veins + emission ripples + iridescent sheen
    vec3 col = vec3(0.45, 0.60, 0.85) * (0.10 + 0.07 * fbm(p * 3.0));
    float vn = pow(abs(sin(ang * 11.0 + fbm(q * 6.0 + seed * 4.0) * 4.0 + seed * TAU)), 10.0);
    col += mix(vec3(0.55, 0.10, 0.22), vec3(0.25, 0.40, 0.95),
               0.5 + 0.5 * sin(seed * 9.0 + ang * 2.0)) * vn * smoothstep(0.95, 1.20, ir) * 0.60;
    float er = 0.5 + 0.5 * sin(ir * 16.0 - t * 2.8 + seed * 5.0);
    col += vec3(0.30, 0.45, 0.95) * er * er * smoothstep(0.90, 1.30, ir) * 0.16;
    col += spectrum(ang / TAU + seed + t * 0.03) * smoothstep(1.10, 1.60, ir) * 0.08;

    col = mix(col, iris, smoothstep(1.06, 0.94, ir));

    // hypnotic vortex pupil: log-spiral winding inward + pulsing violet core
    float sw = 0.5 + 0.5 * sin(ang * 3.0 + log(max(ir, 1e-3)) * 10.0 - t * 3.5 + seed * TAU);
    vec3 pcol = vec3(0.45, 0.10, 0.75) * pow(sw, 6.0) * 0.85;
    pcol += vec3(0.90, 0.55, 1.0) * exp(-ir * 12.0) * (0.55 + 0.45 * sin(t * 5.0 + seed * 7.0));
    col = mix(col, pcol, pupil);
    col += vec3(1.0, 0.98, 0.9) * smoothstep(0.14, 0.0, length(q - vec2(0.14, 0.16))) * 0.9;
    col *= apMask;

    float rim = glowline(ap, 0.025) * smoothstep(1.25, 0.95, abs(p.x));
    col += vec3(0.55, 0.75, 1.0) * rim * 0.55;

    float alpha = max(apMask, rim * 0.75) * smoothstep(1.35, 1.05, length(p * vec2(1.0, 1.5)));
    return vec4(col, clamp(alpha, 0.0, 1.0));
}

vec3 renderScene(vec2 uv, float t){
    float r = length(uv);
    float a = atan(uv.y, uv.x);
    float breathe = 0.5 + 0.5 * sin(t * 0.45);

    // glassy relief: background layers refract through it
    float g1 = fbm(uv * 2.6 + vec2(t * 0.10, -t * 0.07));
    float g2 = fbm(uv * 2.6 + vec2(4.7, 9.1) + vec2(-t * 0.08, t * 0.11));
    vec2 guv = uv + vec2(g1 - 0.5, g2 - 0.5) * 0.11;
    float gr = length(guv);
    float ga = atan(guv.y, guv.x);

    // deep indigo void with faint nebula
    vec3 col = vec3(0.004, 0.001, 0.020);
    float neb = fbm(guv * 1.6 + vec2(0.0, t * 0.06));
    col += vec3(0.035, 0.010, 0.10) * neb * smoothstep(0.3, 1.5, r);

    // fractal mandala filigree behind everything
    col += fractalMandala(guv, t) * smoothstep(0.38, 0.75, r) * 0.85 * uFractal;

    // universal mind lattice (log-polar tunnel)
    float la = ga + t * 0.07;
    float lr = log(max(gr, 1e-4));
    vec2 gv = vec2(la / TAU * 36.0, lr * 5.0 - t * 0.55);
    float gd = min(abs(fract(gv.x) - 0.5), abs(fract(gv.y) - 0.5));
    float lattice = glowline(gd, 0.020);
    float latFade = smoothstep(0.42, 0.95, r) / (1.0 + r * r * 0.8);
    vec3 latCol = mix(vec3(0.35, 0.55, 1.0), spectrum(lr * 0.12 - t * 0.015), 0.35);
    col += latCol * lattice * lattice * latFade * 0.42 * uLattice;
    float nd = length(fract(gv) - 0.5);
    float node = glowline(nd, 0.06);
    float twinkle = 0.6 + 0.4 * sin(t * 5.0 + hash21(floor(gv)) * TAU);
    col += vec3(0.8, 0.9, 1.0) * pow(node, 6.0) * latFade * twinkle * 0.9 * uLattice;

    // glass glints sliding across the surface
    float spec = pow(clamp(fbm(guv * 3.2 + vec2(t * 0.18, -t * 0.13)) * 1.7 - 0.62, 0.0, 1.0), 4.0);
    col += vec3(0.75, 0.88, 1.0) * spec * 0.30 * smoothstep(0.45, 0.95, r);

    // 3D fractal architecture drifting through the void
    col += kifsGlow(uv, r, t);

    // expanding pulse rings
    float prw = fract(r * 1.4 - t * 0.45);
    float ring = exp(-pow((prw - 0.5) * 12.0, 2.0));
    col += spectrum(r * 0.7 - t * 0.10) * ring * smoothstep(0.30, 0.60, r) * 0.18 / (1.0 + r);

    // spectral flame aura (kaleidoscopic tongues)
    float k = 18.0;
    float fa = abs(fract(a * k / TAU + 0.5) - 0.5) * TAU / k;
    float fl = fbm(vec2(fa * 9.0, r * 2.4 - t * 1.5));
    float flame = smoothstep(0.95 + 0.45 * fl, 0.48, r) * smoothstep(0.40, 0.55, r);
    flame *= flame;
    flame *= 0.70 + 0.40 * sin(r * 38.0 - t * 3.2);
    col += spectrum(r * 1.7 - t * 0.12 + fl * 0.45) * flame * (0.9 + 0.5 * breathe) * uAura;

    // energy meridians (fine white filaments)
    float wob = fbm(vec2(a * 3.0, r * 2.0 - t * 0.9)) * 7.0;
    float fil = pow(abs(sin(a * 48.0 + wob - t * 0.5)), 24.0);
    col += vec3(0.85, 0.92, 1.0) * fil * smoothstep(0.30, 0.55, r) * smoothstep(1.35, 0.65, r) * 0.22;

    // crepuscular beams sweeping to the screen edge
    float bshim = fbm(vec2(a * 4.0 + t * 0.20, r * 0.6 - t * 0.15));
    float beams = pow(0.5 + 0.5 * sin(a * 24.0 + t * 0.35 + bshim * 2.5), 3.0);
    col += mix(vec3(0.55, 0.45, 1.0), spectrum(a / TAU + t * 0.02), 0.35)
         * beams * bshim * smoothstep(0.35, 0.9, r) * 0.28 * uBeams / (0.6 + r);

    // dash-darts racing outward along thin spokes
    float dartSpoke = pow(abs(sin(a * 36.0 + t * 0.25)), 40.0);
    float dartPulse = pow(0.5 + 0.5 * sin(r * 26.0 - t * 7.0 + sin(a * 7.0) * 2.0), 8.0);
    col += spectrum(r * 0.8 - t * 0.15) * dartSpoke * dartPulse
         * smoothstep(0.35, 0.6, r) * smoothstep(2.0, 0.9, r) * 1.1 * uDarts;

    // gold light-spears fanning out from behind the halo
    float sa = a - t * 0.06;
    float sfold = abs(fract(sa * 24.0 / TAU + 0.5) - 0.5) * TAU / 24.0;
    float staper = 0.055 * smoothstep(1.9, 0.62, r);
    float spear = smoothstep(staper, staper * 0.25, sfold)
                * smoothstep(0.60, 0.75, r) * smoothstep(1.9, 1.0, r);
    col += vec3(1.0, 0.82, 0.38) * spear * (0.30 + 0.22 * sin(t * 1.1 + floor(sa * 24.0 / TAU) * 2.7)) * uSpears;

    // sparks streaming out from the center
    col += sparks(uv, t) * uSparks;

    // lotus wave-rings around the third eye
    vec3 gold = vec3(1.0, 0.78, 0.30);
    for (int i = 0; i < 5; i++){
        float fi = float(i);
        float rdir = mix(1.0, -1.0, mod(fi, 2.0));
        float n = 6.0 + fi * 5.0;
        float wave = (0.020 - 0.0022 * fi) * cos(a * n + rdir * t * (0.7 + 0.30 * fi));
        wave += 0.007 * sin(a * n * 2.0 - rdir * t * 1.9);
        float rr = 0.295 + 0.047 * fi + wave + 0.006 * sin(t * 1.4 + fi * 2.1);
        vec3 rc = mix(gold, spectrum(fi * 0.17 + t * 0.05), 0.55);
        col += rc * glowline(abs(r - rr), 0.0030) * (0.8 - 0.09 * fi);
    }

    // visual frequency bands: circular oscilloscope traces
    for (int i = 0; i < 5; i++){
        float fi = float(i);
        float freq = 3.0 * pow(2.0, fi);
        float amp = 0.055 / (1.0 + fi * 0.55);
        float wdir = mix(1.0, -1.0, mod(fi, 2.0));
        float wave = sin(a * freq + wdir * t * (1.4 + 0.9 * fi));
        wave += 0.35 * sin(a * freq * 0.5 - wdir * t * 2.2);
        float dd = abs(r - (0.80 + 0.11 * fi + amp * wave));
        col += spectrum(0.02 + fi * 0.15 - t * 0.03) * glowline(dd, 0.0035)
             * 0.5 * smoothstep(0.70, 0.85, r) * smoothstep(1.9, 1.2, r);
    }

    // radiance behind the third eye
    col += vec3(0.45, 0.35, 0.95) * exp(-r * 4.0) * (1.0 + 0.5 * breathe + 0.18 * sin(t * 6.0));
    float rays = pow(0.5 + 0.5 * sin(a * 60.0 + t * 0.6), 10.0) * exp(-r * 2.2);
    rays += pow(0.5 + 0.5 * sin(a * 36.0 - t * 0.45), 12.0) * exp(-r * 1.8) * 0.7;
    col += vec3(0.9, 0.9, 1.0) * rays * 0.35;

    // fractal medallion behind the third eye:
    // two counter-rotating Kali layers at different scales -> parallax depth
    float mm = smoothstep(0.42, 0.30, r);
    for (int i = 0; i < 2; i++){
        float fi = float(i);
        float mdir = mix(1.0, -1.0, fi);
        float mseg = TAU / 8.0;
        float mang = abs(mod(a + mdir * t * (0.10 + 0.06 * fi), mseg) - mseg * 0.5);
        vec2 mp = vec2(cos(mang), sin(mang)) * r * (5.5 + fi * 3.5);
        vec2 mc = vec2(-0.72 - 0.05 * fi + 0.06 * sin(t * 0.40 + fi * 2.0),
                       -0.26 + 0.05 * cos(t * 0.31 + fi * 3.0));
        float macc = 0.0, mtrap = 1e3;
        for (int j = 0; j < 7; j++){
            mp = abs(mp) / max(dot(mp, mp), 1e-6) + mc;
            mtrap = min(mtrap, abs(mp.y));
            macc += exp(-6.0 * abs(mp.y));
        }
        float ml = glowline(mtrap, 0.018); ml *= ml;
        vec3 mcol = spectrum(macc * 0.08 + fi * 0.4 + t * 0.04) * macc * macc * 0.010 * (1.0 - 0.4 * fi);
        mcol += mix(vec3(0.70, 0.60, 1.0), vec3(1.0, 0.80, 0.40), fi) * ml * (0.8 - 0.3 * fi);
        col += mcol * mm * uCenter;
    }

    // halo of twelve eyes (orbiting, ring radius breathing)
    float rh = 0.62 + 0.015 * sin(t * 0.8);
    float ha = a + t * 0.12;
    float sector = mod(floor(ha / TAU * 12.0 + 0.5), 12.0);
    float ca = floor(ha / TAU * 12.0 + 0.5) * TAU / 12.0;
    float da = ha - ca;
    vec2 ep = vec2(da * rh, r - rh);
    float seed = hash21(vec2(sector, 3.7));
    col += vec3(0.25, 0.35, 0.9) * exp(-pow((r - rh) * 8.0, 2.0)) * (0.30 + 0.15 * breathe);
    vec4 he = eyeball(ep, 0.115, seed, t);
    col = mix(col, he.rgb, he.a);

    // the central third eye (softly swelling)
    vec4 ce = eyeball(uv, 0.24 + 0.012 * sin(t * 1.2), 0.618, t * 0.55);
    col = mix(col, ce.rgb, ce.a);

    return col;
}

void main(){
    vec2 uv = (2.0 * gl_FragCoord.xy - RENDERSIZE) / RENDERSIZE.y;
    float t = TIME * uTempo;

    vec3 col = renderScene(uv, t);

    // finish: hue, saturate, tone map, gamma, vignette
    col = max(hueShift(col, uHue + t * uHueSpeed), 0.0);
    float lum = dot(col, vec3(0.299, 0.587, 0.114));
    col = max(mix(vec3(lum), col, uSat), 0.0);
    col *= 1.1;
    col = col / (1.0 + col);
    col = pow(col, vec3(0.4545));
    col = mix(col, col * col * (3.0 - 2.0 * col), uContrast);
    col = pow(col, vec3(1.06));
    vec2 vuv = gl_FragCoord.xy / RENDERSIZE;
    col *= 0.30 + 0.70 * pow(16.0 * vuv.x * vuv.y * (1.0 - vuv.x) * (1.0 - vuv.y), 0.22);

    gl_FragColor = vec4(col, 1.0);
}