Screen-Space Outline

// Shared by every pass, because the Common pass is prepended to each of them
// before compilation. The scene lives here rather than in a committed image: a
// post effect in a game runs on a frame the renderer just produced, and a
// rendered source also means the highlights are genuinely brighter than white,
// which is what a bright-pass needs in order to find anything at all.
//
// This file is identical across the post-processing seeds on purpose, so the
// effects are comparable: the only thing that differs between them is the
// processing, not the picture.
float hash11(float n) {
    return fract(sin(n * 91.7) * 43758.5453);
}

vec3 renderScene(vec2 uv, float time) {
    vec3 color = mix(vec3(0.04, 0.05, 0.10), vec3(0.30, 0.17, 0.26), uv.y + 0.5);

    // Sun: small, hard edged, and far above the displayable range so it blooms
    // hard. Deliberately no painted-on glow around it — every halo in the final
    // image has to come from the effect, or the effect demonstrates nothing.
    vec2 sunPos = vec2(0.44, 0.19);
    float sunDist = length(uv - sunPos);
    color += vec3(3.4, 2.5, 1.4) * (1.0 - smoothstep(0.052, 0.062, sunDist));

    // Distant ridge, a flat silhouette to separate sky from city.
    float ridge = -0.13 + 0.045 * sin(uv.x * 4.1 + 1.3) + 0.022 * sin(uv.x * 9.7);
    if (uv.y < ridge) {
        color = mix(color, vec3(0.09, 0.08, 0.15), 0.92);
    }

    // Near skyline with lit windows: hard edges and fine bright detail, which
    // is exactly what outline, pixelate and bloom effects need to chew on.
    float cell = 0.20;
    float column = floor((uv.x + 2.0) / cell);
    float height = -0.34 + 0.20 * hash11(column);
    if (uv.y < height) {
        color = vec3(0.045, 0.045, 0.075);
        float row = floor((uv.y + 0.5) * 26.0);
        vec2 local = fract(vec2((uv.x + 2.0) / cell * 3.0, (uv.y + 0.5) * 26.0));
        float lit = hash11(column * 13.7 + row * 7.13);
        float blink = 0.75 + 0.25 * sin(time * 1.7 + column);
        if (local.x > 0.28 && local.x < 0.72 && local.y > 0.30 && local.y < 0.72
                && lit > 0.42) {
            color = vec3(1.75, 1.35, 0.72) * blink;
        }
    }

    // A single beacon so the frame is never completely static.
    vec2 beacon = vec2(-0.62, -0.14);
    float pulse = 0.5 + 0.5 * sin(time * 2.4);
    color += vec3(2.2, 0.5, 0.4) * pulse
             * (1.0 - smoothstep(0.006, 0.016, length(uv - beacon)));
    return color;
}

vec2 sceneUv(vec2 fragCoord) {
    return (fragCoord - 0.5 * iResolution.xy) / iResolution.y;
}

void mainImage(out vec4 fragColor, in vec2 fragCoord) {
    fragColor = vec4(renderScene(sceneUv(fragCoord), iTime), 1.0);
}