Screen-Space Reflection

const float SCENE_FAR = 14.0;
const float CAMERA_FOCAL = 1.7;

float sphereHit(vec3 rayOrigin, vec3 rayDirection, vec3 center, float radius) {
    vec3 offset = rayOrigin - center;
    float b = dot(offset, rayDirection);
    float c = dot(offset, offset) - radius * radius;
    float h = b * b - c;
    if (h < 0.0) return SCENE_FAR;
    float root = sqrt(h);
    float nearHit = -b - root;
    float farHit = -b + root;
    return nearHit > 0.0 ? nearHit : (farHit > 0.0 ? farHit : SCENE_FAR);
}

void traceScene(vec3 rayDirection, out float depth, out vec3 normal) {
    float nearest = SCENE_FAR;
    normal = vec3(0.0, 0.0, 1.0);
    if (rayDirection.y < -0.001) {
        float floorHit = -1.05 / rayDirection.y;
        if (floorHit > 0.0 && floorHit < nearest) {
            nearest = floorHit;
            normal = vec3(0.0, 1.0, 0.0);
        }
    }
    vec3 centers[3] = vec3[3](
        vec3(-1.15, -0.25, -4.1),
        vec3(0.72, -0.47, -3.25),
        vec3(0.35, 0.25, -5.6)
    );
    float radii[3] = float[3](0.80, 0.58, 0.72);
    for (int i = 0; i < 3; ++i) {
        float hit = sphereHit(vec3(0.0), rayDirection, centers[i], radii[i]);
        if (hit < nearest) {
            nearest = hit;
            normal = normalize(rayDirection * hit - centers[i]);
        }
    }
    depth = nearest >= SCENE_FAR ? SCENE_FAR : -(rayDirection * nearest).z;
}

vec3 cameraRay(vec2 fragCoord) {
    vec2 screen = (2.0 * fragCoord - iResolution.xy) / iResolution.y;
    return normalize(vec3(screen, -CAMERA_FOCAL));
}

vec3 reconstructViewPosition(vec2 uv, float depth) {
    vec2 screen = (2.0 * uv - 1.0) * vec2(iResolution.x / iResolution.y, 1.0);
    return vec3(screen * depth / CAMERA_FOCAL, -depth);
}

vec2 projectViewPosition(vec3 position) {
    vec2 screen = position.xy * CAMERA_FOCAL / max(-position.z, 0.001);
    return 0.5 + 0.5 * screen / vec2(iResolution.x / iResolution.y, 1.0);
}

vec3 skyColor(vec3 direction) {
    float horizon = smoothstep(-0.25, 0.65, direction.y);
    return mix(vec3(0.07, 0.09, 0.14), vec3(0.36, 0.58, 0.82), horizon);
}

void mainImage(out vec4 fragColor, in vec2 fragCoord) {
    vec3 rayDirection = cameraRay(fragCoord);
    float depth;
    vec3 normal;
    traceScene(rayDirection, depth, normal);
    if (depth >= SCENE_FAR - 0.01) {
        fragColor = vec4(skyColor(rayDirection), 1.0);
        return;
    }
    vec3 position = rayDirection * depth / -rayDirection.z;
    vec3 lightDirection = normalize(vec3(-0.5, 0.8, 0.35));
    float diffuse = max(dot(normal, lightDirection), 0.0);
    float checker = mod(floor(position.x * 1.4) + floor(position.z * 1.4), 2.0);
    vec3 floorColor = mix(vec3(0.08, 0.11, 0.15), vec3(0.24, 0.29, 0.34), checker);
    vec3 objectColor = mix(vec3(0.18, 0.42, 0.68), vec3(0.82, 0.31, 0.16), normal.y * 0.5 + 0.5);
    float floorMask = 1.0 - step(0.02, abs(position.y + 1.05));
    vec3 base = mix(objectColor, floorColor, floorMask);
    vec3 color = base * (0.18 + 0.82 * diffuse) + skyColor(normal) * 0.12;
    fragColor = vec4(pow(color, vec3(0.4545)), 1.0);
}