Scenes and Closest Hits

Introduction: Scenes as Collections of Objects

The Multiple Intersection Problem

Join the 1M+ learners on CodeSignal

Be a part of our community of 1M+ users who develop and demonstrate their skills on CodeSignal

Capturing Intersection Data with hit_record

In the previous lesson, you modified hit_sphere() to return a boolean indicating whether a hit occurred and to pass back the t value through a reference parameter. This worked well for a single sphere, but now that we're dealing with multiple objects and need to track the closest hit, we need to capture more information about each intersection.

Think about what data we need when a ray hits a surface. We need the t value (the distance along the ray), certainly. We also need the actual 3D point where the intersection occurred, because we'll use that to compute lighting in future lessons. We need the surface normal at that point, which we're already using for our color-coded visualization. And there's one more piece of information that will become important: whether the ray hit the front face or the back face of the surface.

The concept of front-facing versus back-facing surfaces might seem subtle, but it's important for correct rendering. A surface is front-facing if the ray hits it from outside the object, and back-facing if the ray hits it from inside. For a sphere, the front face is the outer surface and the back face is the inner surface. Why does this matter? Because the surface normal should always point toward the side the ray came from. If we hit the front face, the normal should point outward. If we hit the back face (imagine a ray starting inside a glass sphere), the normal should point inward. This ensures that lighting calculations work correctly regardless of which side of a surface we're viewing.

To organize all this intersection data cleanly, we'll create a structure called hit_record. In C++, a struct is a way to group related data together. Here's our hit_record definition:

C++

struct hit_record {
    point3 p;
    vec3 normal;
    double t;
    bool front_face;
};

struct hit_record {
    point3 p;
    vec3 normal;
    double t;
    bool front_face;
};

This struct bundles together everything we need to know about a ray-surface intersection. The p field stores the 3D hit point. The normal field stores the surface normal at that point. The t field stores the ray parameter (distance) to the hit point. And the front_face field is a boolean that tells us whether we hit the front or back of the surface.

To help us set the normal correctly based on which face we hit, we'll create a helper function called set_face_normal(). This function takes a hit record, the ray, and the outward-pointing normal (the normal that always points out of the surface), and it determines whether we hit the front or back face:

C++

void set_face_normal(hit_record& rec, const ray& r, const vec3& outward_normal) {
    rec.front_face = dot(r.direction(), outward_normal) < 0;
    rec.normal = rec.front_face ? outward_normal : -outward_normal;
}

void set_face_normal(hit_record& rec, const ray& r, const vec3& outward_normal) {
    rec.front_face = dot(r.direction(), outward_normal) < 0;
    rec.normal = rec.front_face ? outward_normal : -outward_normal;
}

The key insight here is the dot product between the ray direction and the outward normal. If this dot product is negative, it means the ray and the normal point in generally opposite directions, which happens when the ray hits the front face from outside. If the dot product is positive, the ray and normal point in the same general direction, meaning the ray hit the back face from inside. Based on this test, we set front_face appropriately and then set the normal to either point outward (for front faces) or inward (for back faces, by negating the outward normal).

This hit_record structure and the set_face_normal() helper function will be used throughout the rest of your ray tracer. They provide a clean, organized way to pass intersection information around your code, and they ensure that surface normals are always oriented correctly relative to the viewing ray.

The Closest Hit Algorithm

Now that we have a way to store intersection data in a hit_record, we can implement the algorithm for finding the closest hit among multiple objects. The strategy is straightforward but important to understand thoroughly, as you'll use variations of this pattern throughout your ray tracing work.

The algorithm works like this: we maintain a variable that tracks the closest intersection distance we've found so far. We initialize this to infinity, meaning we haven't found any intersection yet. Then, we loop through all objects in the scene, testing each one for intersection. Whenever we find an intersection that's closer than our current closest distance, we update both the closest distance and save that intersection's complete information in our hit_record.

There's a crucial detail in how we test for intersections: we don't just ask, "Does this ray hit this object?" Instead, we ask, "Does this ray hit this object within a certain range of t values?" This range is defined by two parameters: t_min and t_max. The t_min parameter (which we'll set to a small positive value like 0.001) prevents us from accepting intersections that are too close to the ray origin. This avoids a problem called "shadow acne," where floating-point precision errors can cause a surface to incorrectly shadow itself. The t_max parameter ensures we only consider intersections that are closer than the closest hit we've found so far.

Here's how this looks in code within our ray_color() function:

C++

color ray_color(const ray& r) {
    hit_record rec;
    bool hit_anything = false;
    double closest = std::numeric_limits<double>::infinity();

    // Scene: small sphere + big ground sphere
    point3 centers[] = { point3(0,0,-1), point3(0,-100.5,-1) };
    double radii[]   = { 0.5,            100.0               };

    for (int s = 0; s < 2; ++s) {
        hit_record temp;
        if (hit_sphere(centers[s], radii[s], r, 0.001, closest, temp)) {
            hit_anything = true;
            closest = temp.t;
            rec = temp;
        }
    }

    if (hit_anything) {
        return 0.5 * (rec.normal + color(1,1,1));
    }

    vec3 unit_dir = unit_vector(r.direction());
    double t = 0.5 * (unit_dir.y() + 1.0);
    return (1.0 - t)*color(1,1,1) + t*color(0.5,0.7,1.0);
}

color ray_color(const ray& r) {
    hit_record rec;
    bool hit_anything = false;
    double closest = std::numeric_limits<double>::infinity();

    // Scene: small sphere + big ground sphere
    point3 centers[] = { point3(0,0,-1), point3(0,-100.5,-1) };
    double radii[]   = { 0.5,            100.0               };

    for (int s = 0; s < 2; ++s) {
        hit_record temp;
        if (hit_sphere(centers[s], radii[s], r, 0.001, closest, temp)) {
            hit_anything = true;
            closest = temp.t;
            rec = temp;
        }
    }

    if (hit_anything) {
        return 0.5 * (rec.normal + color(1,1,1));
    }

    vec3 unit_dir = unit_vector(r.direction());
    double t = 0.5 * (unit_dir.y() + 1.0);
    return (1.0 - t)*color(1,1,1) + t*color(0.5,0.7,1.0);
}

Let's walk through this code carefully. We start by declaring a hit_record called rec that will eventually hold information about the closest hit. We initialize hit_anything to false, which will track whether we found any intersection at all. We initialize closest to infinity using std::numeric_limits<double>::infinity(), which is C++'s way of representing a value larger than any actual distance.

We define our scene using two arrays: one for sphere centers and one for sphere radii. The first sphere is our familiar small sphere at (0, 0, -1) with a radius of 0.5. The second sphere is much larger, with a radius of 100, and is centered at (0, -100.5, -1). This positioning places the top of the large sphere at y = -0.5, just below the bottom of the small sphere at y = -0.5, creating the appearance of the small sphere sitting on a ground plane.

The loop iterates through both spheres. For each sphere, we create a temporary hit_record called temp and test whether the ray hits that sphere within the range from 0.001 to closest. Notice how closest serves double duty: it's both the upper limit for valid intersections and the value we update when we find a closer hit. If hit_sphere() returns true, we've found an intersection within the valid range. We set hit_anything to true, update closest to the new intersection distance, and copy the temporary hit record into our main rec. This copy operation saves all the intersection data — the hit point, normal, t value, and face orientation.

After checking all objects, if we hit anything, we use the normal from the closest hit to determine the pixel color, just as we did in the previous lesson. If we didn't hit anything, we fall back to the background gradient. The beauty of this algorithm is that it automatically handles occlusion: if the small sphere is in front of the ground sphere from the camera's perspective, the small sphere's intersection will have a smaller t value, so it will be the one that determines the pixel color.

Implementing the Multi-Object Scene

To make our closest-hit algorithm work, we need to update our hit_sphere() function to accept the range parameters and work with the hit_record structure. Here's the updated function:

C++

bool hit_sphere(const point3& center, double radius, const ray& r, double t_min, double t_max, hit_record& rec) {
    vec3 oc = r.origin() - center;
    auto a = dot(r.direction(), r.direction());
    auto half_b = dot(oc, r.direction());
    auto c = dot(oc, oc) - radius*radius;
    auto disc = half_b*half_b - a*c;
    if (disc < 0) return false;
    auto sqrtd = std::sqrt(disc);

    // Find nearest root in [t_min, t_max]
    auto root = (-half_b - sqrtd)/a;
    if (root < t_min || t_max < root) {
        root = (-half_b + sqrtd)/a;
        if (root < t_min || t_max < root) return false;
    }

    rec.t = root;
    rec.p = r.at(rec.t);
    vec3 outward_normal = (rec.p - center) / radius;
    set_face_normal(rec, r, outward_normal);
    return true;
}

bool hit_sphere(const point3& center, double radius, const ray& r, double t_min, double t_max, hit_record& rec) {
    vec3 oc = r.origin() - center;
    auto a = dot(r.direction(), r.direction());
    auto half_b = dot(oc, r.direction());
    auto c = dot(oc, oc) - radius*radius;
    auto disc = half_b*half_b - a*c;
    if (disc < 0) return false;
    auto sqrtd = std::sqrt(disc);

    // Find nearest root in [t_min, t_max]
    auto root = (-half_b - sqrtd)/a;
    if (root < t_min || t_max < root) {
        root = (-half_b + sqrtd)/a;
        if (root < t_min || t_max < root) return false;
    }

    rec.t = root;
    rec.p = r.at(rec.t);
    vec3 outward_normal = (rec.p - center) / radius;
    set_face_normal(rec, r, outward_normal);
    return true;
}

The mathematical core of the function remains the same — we still solve the quadratic equation to find where the ray intersects the sphere. However, the function now takes two additional parameters: t_min and t_max, which define the valid range of intersection distances. Instead of passing back just a t value, we now pass back a complete hit_record through a reference parameter.

The key change is in how we validate the intersection points. After computing the discriminant and confirming that intersections exist, we calculate the first root (the nearer intersection). We then check whether this root falls within the valid range [t_min, t_max]. If it doesn't, we try the second root (the farther intersection). If neither root is in the valid range, we return false to indicate no valid intersection was found.

When we do find a valid intersection, we fill in all the fields of the hit_record. We store the t value, compute the hit point using r.at(rec.t), calculate the outward normal by dividing the vector from center to hit point by the radius, and then call set_face_normal() to set both the normal and front_face fields correctly. Finally, we return true to indicate success.