Ray Sphere Intersection

Introduction: Rendering Your First 3D Object

Welcome to the first lesson in our ray tracing journey! In this lesson, you'll learn how to render your first actual 3D object: a simple sphere . By the end of this lesson, you'll have a working ray tracer that displays a red sphere floating in front of a blue-to-white gradient background. The key challenge we'll tackle is understanding ray-sphere intersection . When we shoot a ray from our camera through each pixel, we need to determine whether that ray hits our sphere, and if so, where. This is a fundamental problem in ray tracing, and solving it requires some geometry and algebra. Don't worry, though — we'll break down the mathematics step by step and show you exactly how it translates into working C++ code. Our approach will be mathematical but practical. We'll use the implicit equation of a sphere and combine it with our ray equation to create a quadratic equation we can solve. This might sound complex, but you'll see that the code is actually quite straightforward once you understand what each piece is doing.

The Implicit Equation of a Sphere

Before we can determine if a ray hits a sphere, we need a mathematical way to describe what a sphere actually is. In geometry, we use something called an implicit equation . An implicit equation defines a surface by specifying a condition that all points on that surface must satisfy. For a sphere, the condition is simple: every point on the sphere's surface is exactly the same distance (the radius) from the sphere's center. If we have a sphere centered at point c with radius r, and we want to know if some point p is on the sphere's surface, we check whether the distance from p to c equals r . In mathematical notation, we write this as: | p - c |² = r² The left side of this equation, | p - c |², represents the squared distance from point p to the center c . We use the squared distance because it's computationally cheaper to calculate (we avoid the square root operation), and it works just as well for our purposes. If this squared distance equals r², then point p is exactly on the sphere's surface. In our C++ code, we can express this using the dot product. Remember that the squared length of a vector v is the same as the dot product of v with itself: | v |² = v \cdot v . So our sphere equation becomes: (p - c) \cdot (p - c) = r² This formulation is perfect for ray tracing because we can easily compute dot products using our vec3 class. The equation tells us everything we need to know: given any point in 3D space, we can test whether it lies on our sphere's surface.

Join the 1M+ learners on CodeSignal

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

Implementing the hit_sphere() Function

Now let's translate this mathematics into C++ code. We'll create a function called hit_sphere() that takes a sphere's center, radius, and a ray, then returns the t value where the ray first hits the sphere (or -1.0 if there's no hit).

Here's the complete implementation:

C++

double hit_sphere(const point3& center, double radius, const ray& r) {
    // Solve |(r.orig + t*r.dir) - center|^2 = radius^2
    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 discriminant = half_b*half_b - a*c;
    if (discriminant < 0) return -1.0;
    return (-half_b - std::sqrt(discriminant)) / a; // nearest root
}

double hit_sphere(const point3& center, double radius, const ray& r) {
    // Solve |(r.orig + t*r.dir) - center|^2 = radius^2
    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 discriminant = half_b*half_b - a*c;
    if (discriminant < 0) return -1.0;
    return (-half_b - std::sqrt(discriminant)) / a; // nearest root
}

Let's walk through this code carefully. First, we calculate oc, which is the vector from the sphere's center to the ray's origin. This is our oc vector from the mathematical derivation.

Next, we compute the coefficients of our quadratic equation. The variable a is the dot product of the ray's direction with itself, which gives us the squared length of the direction vector. The variable c is the squared distance from the ray's origin to the sphere's center, minus the squared radius.

You might notice something interesting: we're using half_b instead of b. This is a common optimization in ray tracing. If you look at the quadratic formula, you'll see that b always appears with a factor of 2. By defining half_b = d · oc (without the factor of 2), we can simplify our discriminant calculation to half_b² - ac instead of (2·half_b)² - 4ac. Both give the same result, but our version requires fewer operations.

The discriminant tells us whether we have an intersection. If it's negative, we return -1.0 to signal that the ray missed the sphere. If it's non-negative, we calculate and return the nearest intersection point using the formula (-half_b - √discriminant) / a. We use the minus sign before the square root because we want the smaller (nearer) of the two possible t values.

Integrating Sphere Detection into Your Ray Tracer

With our hit_sphere() function ready, we can now integrate it into our ray tracer. We'll modify the ray_color() function to check whether each ray hits our sphere and color those pixels accordingly.

Here's the updated ray_color() function:

C++

color ray_color(const ray& r) {
    // Sphere at z=-1, radius 0.5
    double t = hit_sphere(point3(0,0,-1), 0.5, r);
    if (t > 0.0) {
        return color(1, 0, 0); // solid red sphere for first hit
    }
    // background gradient
    vec3 unit_dir = unit_vector(r.direction());
    t = 0.5 * (unit_dir.y() + 1.0);
    return (1.0 - t)*color(1.0,1.0,1.0) + t*color(0.5,0.7,1.0);
}

color ray_color(const ray& r) {
    // Sphere at z=-1, radius 0.5
    double t = hit_sphere(point3(0,0,-1), 0.5, r);
    if (t > 0.0) {
        return color(1, 0, 0); // solid red sphere for first hit
    }
    // background gradient
    vec3 unit_dir = unit_vector(r.direction());
    t = 0.5 * (unit_dir.y() + 1.0);
    return (1.0 - t)*color(1.0,1.0,1.0) + t*color(0.5,0.7,1.0);
}

This function first calls hit_sphere() with a sphere positioned at (0, 0, -1) with radius 0.5. The sphere is placed one unit in front of the camera (negative z direction) and is small enough to fit nicely in our viewport. If hit_sphere() returns a positive t value, we know the ray hit the sphere, so we return a solid red color.

If the ray doesn't hit the sphere (t is -1.0 or negative), we fall through to the background gradient code. This creates a nice blue-to-white gradient that makes our sphere stand out clearly.

The complete main function brings everything together:

C++

int main() {
    // Image
    const double aspect_ratio = 16.0/9.0;
    const int image_width = 400;
    const int image_height = static_cast<int>(image_width / aspect_ratio);

    std::ofstream out("ppm/image.ppm");
    if (!out) { std::cerr << "open image.ppm failed\n"; return 1; }
    out << "P3\n" << image_width << ' ' << image_height << "\n255\n";

    // Camera (simple, inline)
    auto viewport_height = 2.0;
    auto viewport_width  = aspect_ratio * viewport_height;
    auto focal_length    = 1.0;

    point3 origin(0,0,0);
    vec3 horizontal(viewport_width, 0, 0);
    vec3 vertical(0, viewport_height, 0);
    point3 lower_left = origin - horizontal/2 - vertical/2 - vec3(0,0,focal_length);

    // Render
    for (int j = image_height-1; j >= 0; --j) {
        std::cerr << "\rScanlines remaining: " << j << ' ' << std::flush;
        for (int i = 0; i < image_width; ++i) {
            double u = double(i) / (image_width-1);
            double v = double(j) / (image_height-1);
            ray r(origin, lower_left + u*horizontal + v*vertical - origin);
            write_color(out, ray_color(r));
        }
    }
    std::cerr << "\nDone.                 \n";
}

int main() {
    // Image
    const double aspect_ratio = 16.0/9.0;
    const int image_width = 400;
    const int image_height = static_cast<int>(image_width / aspect_ratio);

    std::ofstream out("ppm/image.ppm");
    if (!out) { std::cerr << "open image.ppm failed\n"; return 1; }
    out << "P3\n" << image_width << ' ' << image_height << "\n255\n";

    // Camera (simple, inline)
    auto viewport_height = 2.0;
    auto viewport_width  = aspect_ratio * viewport_height;
    auto focal_length    = 1.0;

    point3 origin(0,0,0);
    vec3 horizontal(viewport_width, 0, 0);
    vec3 vertical(0, viewport_height, 0);
    point3 lower_left = origin - horizontal/2 - vertical/2 - vec3(0,0,focal_length);

    // Render
    for (int j = image_height-1; j >= 0; --j) {
        std::cerr << "\rScanlines remaining: " << j << ' ' << std::flush;
        for (int i = 0; i < image_width; ++i) {
            double u = double(i) / (image_width-1);
            double v = double(j) / (image_height-1);
            ray r(origin, lower_left + u*horizontal + v*vertical - origin);
            write_color(out, ray_color(r));
        }
    }
    std::cerr << "\nDone.                 \n";
}

This code sets up a 400 × 225 pixel image with a 16:9 aspect ratio. It defines a simple camera at the origin looking down the negative z-axis. For each pixel, it calculates the corresponding ray direction, calls ray_color() to determine what color that ray sees, and writes the result to our PPM image file.

When you run this program, you'll see output like this in your terminal:

text

Scanlines remaining: 224 
Scanlines remaining: 223 
...
Scanlines remaining: 1 
Scanlines remaining: 0 
Done.

Scanlines remaining: 224 
Scanlines remaining: 223 
...
Scanlines remaining: 1 
Scanlines remaining: 0 
Done.

The resulting image will show a solid red circle (the sphere) centered in the frame against a blue-to-white gradient background. The sphere appears as a circle because we're viewing it head-on, and we haven't yet implemented shading or lighting — that will come in future lessons.

Introduction: Rendering Your First 3D Object

The Implicit Equation of a Sphere

Join the 1M+ learners on CodeSignal

The Ray-Sphere Intersection Problem

Implementing the hit_sphere() Function

Integrating Sphere Detection into Your Ray Tracer

Summary and What's Next