4. Meeting a Sphere

We are ready to produce the first recognisable object, but we shall not draw it. The distinction is the whole exercise. A drawing API would project a circle and fill the pixels inside it. Our program will send one ray per sample, substitute that ray into a three-dimensional sphere equation and colour the pixel only when the resulting equation has an acceptable solution.

A sphere is a particularly useful first primitive because its definition is compact and its intersection exposes several ideas that return throughout ray tracing: substitution, multiple mathematical solutions, a validity interval and the need to retain the nearest acceptable result.

Describe the surface before testing it

A sphere has centre C and radius r. A point P lies on its surface when its displacement from the centre has length r. Squaring both sides avoids an unnecessary square root:

(P − C) · (P − C) = r²

The ray supplies possible points P(t) = O + tD. Substitute that expression for P:

(O + tD − C) · (O + tD − C) = r²

Expand and collect terms in t. Let oc = O − C:

(D · D)t² + 2(oc · D)t + (oc · oc − r²) = 0

This has the standard quadratic form at² + bt + c = 0. If the direction is normalised, D · D is one, but keeping a in the implementation makes the function correct for any non-zero direction and makes the derivation easier to compare with the code.

The discriminant classifies the question

The discriminant b² − 4ac determines the number of real roots. A negative value means the infinite line misses the sphere. Zero means it touches at one tangent point. A positive value produces two roots, normally the entry and exit positions along the line.

We can use halfB = oc · D to remove repeated factors of two. The discriminant becomes halfB² − ac, and the roots become:

t = (−halfB ± √(halfB² − ac)) / a

function hitSphere(ray, sphere, tMin, tMax) {
    const oc = subtract(ray.origin, sphere.centre);
    const a = dot(ray.direction, ray.direction);
    const halfB = dot(oc, ray.direction);
    const c = dot(oc, oc) - sphere.radius * sphere.radius;
    const discriminant = halfB * halfB - a * c;

    if (discriminant < 0) {
        return null;
    }

    const rootTerm = Math.sqrt(discriminant);
    let root = (-halfB - rootTerm) / a;
    if (root < tMin || root > tMax) {
        root = (-halfB + rootTerm) / a;
        if (root < tMin || root > tMax) {
            return null;
        }
    }

    return root;
}

The smaller root is tested first because the ray should normally report the first surface it encounters. The interval is part of the query. A root behind the camera is mathematically real but irrelevant to camera visibility. A root beyond a nearer object may also be irrelevant once several objects are present. Geometry answers within the interval it is given; the caller decides why that interval matters.

Produce the silhouette

For every pixel centre, construct the primary ray from Lesson 3 and call hitSphere. A valid root receives the sphere colour. A miss receives a sky colour derived from the vertical ray direction. The boundary of the resulting shape is not supplied to Canvas. It emerges where neighbouring camera rays change from negative to non-negative discriminants.

const t = hitSphere(ray, sphere, 0.001, Number.POSITIVE_INFINITY);

if (t !== null) {
    writeLinearColour(pixel, [0.94, 0.68, 0.20]);
} else {
    writeLinearColour(pixel, sky(ray.direction));
}

The image resembles a circle because a sphere viewed by a pinhole camera has a circular silhouette. It is not yet shaded, so it contains no evidence of curvature inside the boundary. Move the sphere horizontally. Its three-dimensional centre changes, the quadratic coefficients change for every ray and a different set of pixels obtains roots. That causal chain is the explanation of the movement.

Do not confuse the line with the ray

The quadratic describes intersections along the infinite line parameterised by t. Our visibility ray is one directed part of that line. Suppose the sphere is centred at positive Z while the camera looks down negative Z. The quadratic may still produce real roots, but both are negative. Accepting either would show an object behind the camera as if it were in front.

This is why testing only discriminant >= 0 is insufficient. It answers whether the line meets the sphere, not whether the requested ray interval meets it. A result can be mathematically correct and operationally unusable because it answered an easier question than the renderer asked.

We can intersect one sphere and obtain its first valid distance. A scene contains several possible answers. Lesson 5 makes visibility explicit by retaining the smallest acceptable distance across all tested objects.