Ray-Intersection Parameter Calculation

From "If" to "Where": Solving the Quadratic Equation

Let's recall the quadratic equation we derived:
$t^2(\mathbf{d}\cdot \mathbf{d})-t(2\mathbf{d}\cdot (\mathbf{C}-\mathbf{O}))+((\mathbf{C}-\mathbf{O})\cdot (\mathbf{C}-\mathbf{O}))-r^2=0$
This is a standard quadratic equation of the form $a{t}^2+bt+c=0$. Last time, we only checked the discriminant ($b^2-4ac$) to see if real solutions existed. Now, we need to actually find those solutions using the quadratic formula:

$t=\frac{-b\pm \sqrt{b^2-4ac}}{2a}$

The "plus-minus" (±) indicates that there can be two solutions for $t$, which makes sense geometrically: a ray can enter a sphere at one point and exit at another. Our task is to find these values and determine which one represents the intersection we care about.

To see the full mathematical derivation and how the quadratic formula is applied in this context, the following video provides an excellent and clear explanation.

Finding the Nearest Valid Hit

After solving the quadratic equation, we get two roots, let's call them $t_0$ and $t_1$. Now we face a new question: which one is the correct one to use?

In ray tracing, we are typically interested in the first surface that a ray hits. This corresponds to the smallest, positive t value.

Consider these scenarios:

1. Two positive roots: The ray enters and exits the sphere. We want the smaller t value (the entry point).
2. One positive and one negative root: The ray's origin is inside the sphere. The negative root represents a hit "behind" the camera, so we take the positive root (the exit point).
3. Two negative roots: Both intersection points are behind the ray's origin. We can ignore these hits.

Therefore, our logic must be to find the smallest root that is greater than zero. To handle floating point inaccuracies and prepare for more advanced techniques, we'll define a valid interval for t, such as [t_min, t_max]. For primary rays, this might be [0.001, infinity]. We look for the smallest root within this interval.

The implementation in Ray Tracing in One Weekend handles this perfectly. Let's see how they modify the sphere class to incorporate this logic.

Based on this logic, we will refactor our hit_sphere function. Instead of returning a bool, it will now return the t value of the nearest hit, or a negative number to indicate a miss.

A simplified version of the core logic looks like this:

// This function will eventually become part of a 'sphere' class
// It returns the 't' value of the hit, or -1.0 if there is no valid hit.
double hit_sphere(const point3& center, double radius, const ray& r) {
    vec3 oc = r.origin() - center;
    auto a = r.direction().length_squared();
    auto half_b = dot(oc, r.direction());
    auto c = oc.length_squared() - radius*radius;

    auto discriminant = half_b*half_b - a*c;
    if (discriminant < 0) {
        return -1.0;
    }

    auto sqrtd = sqrt(discriminant);

    // Find the nearest root that lies in the acceptable range.
    auto root = (-half_b - sqrtd) / a;
    // For now, let's consider any t > 0 as valid.
    if (root <= 0) {
        root = (-half_b + sqrtd) / a;
        if (root <= 0)
            return -1.0; // Both roots are non-positive
    }

    return root;
}

Note: This C++ code is adapted from the textbook's derivation. The book uses oc = center - r.origin(), while I've used oc = r.origin() - center. This just flips the sign of half_b, but the final root calculations are equivalent.

The Importance of "Closest" in a Full Scene

Why is finding the nearest t so important? Imagine your scene has more than one object. A single ray might pass through multiple objects. For the final image, you only want to see the one closest to the camera.

This is the core of how a ray tracer resolves visibility. You test a ray against every object in the scene, and for each intersection, you record the t value. The intersection that yields the smallest positive t is the winner—it's the surface that gets rendered for that pixel.

The following video explains this concept clearly. While we won't implement the full multi-object system until Module 5, understanding this principle now clarifies why we are so focused on finding the nearest t.

Conclusion

You've now taken a critical step from simple hit detection to quantitative intersection analysis. This is the foundation upon which shading, texturing, and complex scene rendering are built.

Key Takeaways:

• The quadratic formula provides two roots ($t_0,t_1$) corresponding to the two potential intersection points of a ray and a sphere.
• The "correct" intersection for a primary ray is the one with the smallest positive t value, as this is the first surface the ray encounters.
• We can implement this logic by checking both roots and selecting the smallest one that falls within a valid range (e.g., t > 0).
• This principle of finding the "nearest t" is how ray tracers solve visibility when multiple objects are present in a scene.

Next Steps

In the next lesson, we'll finally put our t value to work. Now that we know the distance to the intersection, we can calculate the actual 3D point of intersection using P = O + t*d. With the hit point, we can then compute the surface normal vector at that point. The surface normal is the key to implementing realistic lighting and shading.