/*{
  "DESCRIPTION": "Aurora curtains over a cobalt night ocean, with a distant gate, beacon light, stars and a shimmering reflection.",
  "CREDIT": "TaoBot",
  "CATEGORIES": ["Generator", "Backdrop"],
  "INPUTS": [
    {"NAME": "speed", "LABEL": "Speed", "TYPE": "float", "DEFAULT": 0.7, "MIN": 0.0, "MAX": 2.0},
    {"NAME": "glow", "LABEL": "Beacon glow", "TYPE": "float", "DEFAULT": 1.0, "MIN": 0.2, "MAX": 1.8},
    {"NAME": "aurora", "LABEL": "Aurora strength", "TYPE": "float", "DEFAULT": 1.0, "MIN": 0.0, "MAX": 1.6}
  ]
}*/

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 vnoise(vec2 p) {
    vec2 i = floor(p);
    vec2 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);
}

float fbm(vec2 p) {
    float v = 0.0;
    float a = 0.5;
    for (int i = 0; i < 4; i++) {
        v += a * vnoise(p);
        p = mat2(1.6, 1.2, -1.2, 1.6) * p;
        a *= 0.5;
    }
    return v;
}

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

float starLayer(vec2 p, float scale, float t) {
    vec2 grid = vec2(p.x * scale, p.y * scale * 1.35);
    vec2 id = floor(grid);
    vec2 f = fract(grid) - 0.5;
    float h = hash21(id);
    vec2 center = vec2(hash21(id + 7.1), hash21(id + 13.7)) - 0.5;
    center *= 0.62;
    float d = length(f - center);
    float core = smoothstep(0.075, 0.0, d);
    float halo = exp(-d * 18.0) * 0.16;
    float gate = step(0.82, h);
    float twinkle = 0.72 + 0.28 * sin(t * (0.7 + h) + h * 43.0);
    return (core + halo) * gate * twinkle;
}

void main() {
    vec2 uv = isf_FragNormCoord;
    float aspect = RENDERSIZE.x / max(RENDERSIZE.y, 1.0);
    vec2 p = vec2((uv.x - 0.5) * aspect, uv.y - 0.5);
    float t = TIME * speed;
    float horizon = 0.36;

    vec3 skyLow = vec3(0.018, 0.075, 0.19);
    vec3 skyMid = vec3(0.012, 0.16, 0.30);
    vec3 skyTop = vec3(0.004, 0.008, 0.055);
    float skyMix = smoothstep(horizon, 1.0, uv.y);
    vec3 col = mix(skyLow, mix(skyMid, skyTop, smoothstep(0.55, 1.0, uv.y)), skyMix);

    float highSky = smoothstep(horizon + 0.08, horizon + 0.30, uv.y);
    float stars = starLayer(p, 34.0, t) + 0.65 * starLayer(p + 3.7, 58.0, t * 0.8);
    col += vec3(0.75, 0.88, 1.0) * stars * highSky * 0.75;

    float warp = fbm(vec2(p.x * 1.35 + t * 0.025, 0.4 + t * 0.012)) - 0.5;
    float curtainBase = 0.66 + 0.055 * sin(p.x * 2.2 - t * 0.10) + warp * 0.19;
    float rays = 0.55 + 0.45 * vnoise(vec2(p.x * 17.0 - t * 0.22, p.x * 2.0 + t * 0.035));
    float curtain1 = exp(-abs(uv.y - curtainBase) * 7.5) * rays;
    float curtain2 = exp(-abs(uv.y - (curtainBase + 0.15 + 0.03 * sin(p.x * 3.1 + t * 0.07))) * 11.0);
    float curtain3 = exp(-abs(uv.y - (curtainBase - 0.17 + 0.04 * sin(p.x * 1.4 + t * 0.05))) * 13.0);
    float auroraFade = smoothstep(horizon + 0.03, horizon + 0.22, uv.y) * (1.0 - smoothstep(0.96, 1.05, uv.y));
    vec3 auroraCol = vec3(0.02, 0.95, 0.62) * curtain1 * 0.52
                   + vec3(0.10, 0.40, 1.00) * curtain2 * 0.28
                   + vec3(0.45, 0.20, 0.95) * curtain3 * 0.20;
    col += auroraCol * aurora * auroraFade;

    float ridgeNoise = fbm(vec2(p.x * 3.2 + 8.0, 0.7));
    float ridgeY = horizon + 0.018 + ridgeNoise * 0.052;
    float ridge = smoothstep(0.008, -0.008, uv.y - ridgeY) * step(horizon - 0.012, uv.y);
    col = mix(col, vec3(0.004, 0.012, 0.035), ridge * 0.88);

    float oceanMask = smoothstep(horizon + 0.003, horizon - 0.003, uv.y);
    float depth = clamp((horizon - uv.y) / horizon, 0.0, 1.0);
    vec3 ocean = mix(vec3(0.006, 0.075, 0.20), vec3(0.001, 0.012, 0.065), pow(depth, 0.65));
    float waterWarp = fbm(vec2(p.x * 3.0, depth * 7.0 - t * 0.10)) - 0.5;
    float tidePhase = p.x * (10.0 + depth * 30.0) + waterWarp * 3.4 + sin(depth * 22.0 - t * (0.7 + depth * 1.3)) * 0.65;
    float tide = pow(0.5 + 0.5 * sin(tidePhase), 10.0);
    ocean += vec3(0.02, 0.55, 0.58) * tide * (0.10 + depth * 0.30);
    ocean += vec3(0.03, 0.28, 0.75) * pow(0.5 + 0.5 * sin(p.x * 5.0 - t * 0.35 + depth * 13.0), 6.0) * 0.10;

    vec2 beaconPos = vec2(0.0, horizon + 0.315);
    float beaconDist = length(vec2(p.x, (uv.y - beaconPos.y) * 1.25));
    float pulse = 0.82 + 0.18 * sin(t * 1.15);
    float beaconHalo = exp(-beaconDist * 7.0) * 0.55 + exp(-beaconDist * 22.0) * 0.65;
    ocean += vec3(1.0, 0.62, 0.16) * beaconHalo * glow * pulse * 0.10;

    float reflectionWobble = (vnoise(vec2(floor(depth * 52.0), 4.0)) - 0.5) * 0.045;
    float streak = exp(-abs(p.x + reflectionWobble) * (26.0 + depth * 34.0));
    float broken = 0.35 + 0.65 * vnoise(vec2(depth * 46.0 - t * 0.7, p.x * 8.0));
    ocean += vec3(1.0, 0.58, 0.14) * streak * broken * (1.0 - depth * 0.55) * glow * pulse * 0.38;
    col = mix(col, ocean, oceanMask);

    vec2 gateP = p;
    float leftPost = sdBox(gateP - vec2(-0.145, horizon - 0.5 + 0.105), vec2(0.030, 0.105));
    float rightPost = sdBox(gateP - vec2(0.145, horizon - 0.5 + 0.105), vec2(0.030, 0.105));
    float lintel = sdBox(gateP - vec2(0.0, horizon - 0.5 + 0.235), vec2(0.190, 0.032));
    float crossbar = sdBox(gateP - vec2(0.0, horizon - 0.5 + 0.165), vec2(0.145, 0.014));
    float gateDist = min(min(leftPost, rightPost), min(lintel, crossbar));
    float gate = smoothstep(0.004, -0.004, gateDist);
    float rim = smoothstep(0.018, 0.0, abs(gateDist)) * (1.0 - gate);
    col = mix(col, vec3(0.002, 0.005, 0.018), gate * 0.96);
    col += vec3(0.10, 0.55, 0.58) * rim * 0.28;

    col += vec3(1.0, 0.66, 0.20) * beaconHalo * glow * pulse * (1.0 - oceanMask * 0.55);
    float beaconCore = smoothstep(0.026, 0.010, beaconDist);
    col += vec3(1.0, 0.72, 0.28) * beaconCore * glow * 1.35;

    float mist = exp(-abs(uv.y - horizon) * 34.0);
    col += vec3(0.05, 0.30, 0.38) * mist * 0.16;

    float vignette = smoothstep(1.18, 0.38, length(vec2(p.x * 0.72, p.y * 1.05)));
    col *= 0.68 + 0.32 * vignette;
    float grain = hash21(gl_FragCoord.xy + floor(t * 12.0)) - 0.5;
    col += grain * 0.018;

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