Progressive Path Tracer

struct Ray { vec3 ro; vec3 rd; };

struct Sphere { vec3 c; float r; vec3 col; };

float hitSphere(Ray ray, Sphere s) {
    vec3 oc = ray.ro - s.c;
    float b = dot(oc, ray.rd);
    float d = b * b - (dot(oc, oc) - s.r * s.r);
    if (d < 0.0) return -1.0;
    d = sqrt(d);
    float t = -b - d;
    return t > 0.001 ? t : -b + d;
}

vec3 sceneNormal(vec3 p, Sphere s) {
    return normalize(p - s.c);
}

Ray cameraRay(vec2 uv) {
    vec3 ro = vec3(0.0, 1.1, 3.5);
    vec3 look = vec3(0.0, 0.0, 0.0);
    vec3 cw = normalize(look - ro);
    vec3 cu = normalize(cross(vec3(0.0, 1.0, 0.0), cw));
    vec3 cv = cross(cw, cu);
    return Ray(ro, normalize(cw + uv.x * cu + uv.y * cv));
}

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

vec3 trace(Ray ray, Sphere spheres[3], out float tOut, out int idxOut) {
    tOut = 1e9;
    idxOut = -1;
    for (int i = 0; i < 3; i++) {
        float t = hitSphere(ray, spheres[i]);
        if (t > 0.001 && t < tOut) {
            tOut = t;
            idxOut = i;
        }
    }
    return idxOut < 0 ? vec3(0.0) : sceneNormal(ray.ro + ray.rd * tOut, spheres[idxOut]);
}

vec3 radiance(Ray ray, inout vec2 seed) {
    Sphere spheres[3];
    spheres[0] = Sphere(vec3(-0.6, 0.4, -0.2), 0.4, vec3(0.85, 0.25, 0.25));
    spheres[1] = Sphere(vec3(0.4, 0.55, 0.1), 0.55, vec3(0.25, 0.55, 0.85));
    spheres[2] = Sphere(vec3(0.0, -100.0, 0.0), 100.0, vec3(0.8));

    vec3 sun = normalize(vec3(0.4, 0.7, 0.25));
    vec3 col = vec3(0.0);
    vec3 throughput = vec3(1.0);

    for (int bounce = 0; bounce < 3; bounce++) {
        float t;
        int idx;
        vec3 n = trace(ray, spheres, t, idx);
        if (idx < 0) {
            col += throughput * vec3(0.35, 0.55, 0.75);
            break;
        }
        vec3 p = ray.ro + ray.rd * t;

        // Sun is a hard directional light; not path tracing, but a cheap
        // direct-light sample that still accumulates over frames.
        Ray shadow;
        shadow.ro = p + n * 0.001;
        shadow.rd = sun;
        float tShadow;
        int idxShadow;
        trace(shadow, spheres, tShadow, idxShadow);
        float lit = idxShadow < 0 ? 1.0 : 0.0;

        float diff = max(dot(n, sun), 0.0);
        col += throughput * spheres[idx].col * (0.04 + 0.6 * diff * lit);

        // Lambertian bounce for the next ray.
        seed += vec2(0.7, 0.3);
        float u = hash(seed + vec2(float(bounce)));
        float v = hash(seed + vec2(float(bounce) + 1.0));
        float theta = 6.283185 * u;
        float phi = acos(2.0 * v - 1.0);
        vec3 h;
        h.x = sin(phi) * cos(theta);
        h.y = sin(phi) * sin(theta);
        h.z = cos(phi);
        if (dot(h, n) < 0.0) h = -h;
        ray = Ray(p + n * 0.001, h);
        throughput *= spheres[idx].col;
    }
    return col;
}