Metal Surfaces and Reflection

Adding Shiny Surfaces to Your Ray Tracer

Join the 1M+ learners on CodeSignal

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

Understanding Reflection Vectors

The foundation of rendering metallic surfaces is understanding how light reflects off smooth surfaces. The behavior of reflection is governed by a fundamental principle in optics called the law of reflection, which states that when a light ray strikes a reflective surface, the angle at which it arrives (the angle of incidence) equals the angle at which it departs (the angle of reflection). Both of these angles are measured relative to the surface normal, which is the line perpendicular to the surface at the point where the ray hits.

To visualize this, imagine a ball bouncing off a flat floor. If you throw the ball straight down, it bounces straight back up. If you throw it at an angle, it bounces off at the same angle on the other side. The floor's normal is the vertical line pointing straight up from the floor, and the ball's incoming and outgoing paths make equal angles with this vertical line. Light behaves the same way when it reflects off a smooth surface. The incoming ray, the surface normal, and the reflected ray all lie in the same plane, and the angles on either side of the normal are equal.

Mathematically, we can calculate the reflected ray direction using a formula that takes the incoming ray direction and the surface normal as inputs. If we call the incoming ray direction vector v and the surface normal n, the reflected direction r is given by the formula r = v - 2(v · n)n. The dot product (v · n) measures how much the incoming ray is pointing toward or away from the normal. Multiplying this by the normal and then by two gives us a vector that, when subtracted from the original direction, produces the reflection.

To understand why this formula works, think about what we're trying to do geometrically. We want to flip the incoming ray direction across the normal, like folding a piece of paper along a crease. The component of the incoming ray that's parallel to the surface stays the same, but the component perpendicular to the surface (pointing into or out of the surface) needs to be reversed. The term 2(v · n)n represents twice the perpendicular component of the incoming ray. When we subtract this from the original ray direction, we're effectively removing the perpendicular component and adding it back in the opposite direction, which gives us the reflection.

It's important to note that this formula assumes both the incoming ray direction and the normal are unit vectors (vectors with length one). In practice, we'll always work with unit vectors when calculating reflections because the direction is what matters, not the magnitude. If your vectors aren't normalized, the formula will still give you a vector pointing in roughly the right direction, but its length will be wrong, which can cause problems in later calculations. This is why you'll see us use the unit_vector() function before applying the reflection formula.

The reflection formula differs fundamentally from the random scattering we used for diffuse materials. For diffuse surfaces, we generated a random direction in the hemisphere around the normal, with no consideration of where the incoming ray came from. For metallic surfaces, the outgoing direction is completely determined by the incoming direction and the surface geometry. There's no randomness involved in perfect reflection. This deterministic behavior is what allows metals to act as mirrors, reflecting clear images of their surroundings rather than scattering light in all directions.

Building the Metal Material Class

With our reflection function implemented, we're ready to create a new material type for metallic surfaces. As you'll recall from Lesson 2, we have a material system based on an abstract material class with a virtual scatter function. The lambertian class implements diffuse scattering by generating random directions. Now we'll add a metal class that implements specular reflection using our new reflect function.

Open src/material.h and add the new metal class after the lambertian class. First, make sure to include our new math utilities header at the top of the file:

C++

#include "math_utils.h"

#include "math_utils.h"

Now add the metal class definition:

C++

class metal : public material {
public:
    metal(const color& a, double f) : albedo(a), fuzz(f < 1 ? f : 1) {}
    bool scatter(const ray& r_in, const hit_record& rec, color& attenuation, ray& scattered) const override {
        vec3 reflected = reflect(unit_vector(r_in.direction()), rec.normal);
        scattered = ray(rec.p, reflected);
        attenuation = albedo;
        return (dot(scattered.direction(), rec.normal) > 0);
    }
private:
    color albedo;
    double fuzz;
};

class metal : public material {
public:
    metal(const color& a, double f) : albedo(a), fuzz(f < 1 ? f : 1) {}
    bool scatter(const ray& r_in, const hit_record& rec, color& attenuation, ray& scattered) const override {
        vec3 reflected = reflect(unit_vector(r_in.direction()), rec.normal);
        scattered = ray(rec.p, reflected);
        attenuation = albedo;
        return (dot(scattered.direction(), rec.normal) > 0);
    }
private:
    color albedo;
    double fuzz;
};

Let's start by understanding the simpler case of perfect reflection before we discuss the fuzz parameter. The constructor takes an albedo color and a fuzz value. The albedo represents the color tint of the metal. Real metals aren't perfectly white reflectors. Gold has a yellowish tint, copper is reddish, and even silver has a slight bluish tint. The albedo lets us simulate these colored metals by tinting the reflected light. We store the albedo as a member variable so we can use it in the scatter function.

The scatter function is where the reflection happens. When a ray hits a metal surface, we need to calculate the reflected ray direction and determine how much light is reflected. The first line calculates the perfect reflection direction using our reflect function. Notice that we normalize the incoming ray direction with unit_vector() before passing it to reflect. This is crucial because the reflection formula assumes unit vectors. The incoming ray's direction might not be normalized (though in our current implementation it usually is), so we normalize it to be safe.

After calculating the reflected direction, we create the scattered ray starting from the hit point and traveling in the reflected direction. For now, ignore the fuzz_dir term and imagine we're just using scattered = ray(rec.p, reflected). This would give us perfect mirror-like reflection. The scattered ray bounces off the surface at the same angle it arrived, just like a ball bouncing off a floor or light reflecting off a mirror.

The attenuation is set to the albedo color. Remember from Lesson 2 that attenuation represents how much the material absorbs or reflects each color channel. For a metal, the attenuation is simply the metal's color. If we have a gold-colored metal with albedo (1.0, 0.8, 0.4), it reflects all the red light, eighty percent of the green light, and forty percent of the blue light, giving the reflected light a golden tint.

The final line of the scatter function is important: we return true only if the scattered ray is pointing away from the surface (into the hemisphere above the surface). We check this by computing the dot product of the scattered ray direction and the surface normal. If this dot product is positive, the scattered ray is pointing away from the surface, which is physically correct. If it's negative or zero, the scattered ray is pointing into or along the surface, which shouldn't happen for a valid reflection. This check prevents a subtle bug where rays might scatter in invalid directions due to numerical errors or edge cases.

Why might a reflected ray point below the surface? In perfect reflection, this shouldn't happen if everything is calculated correctly. However, when we add surface roughness (which we'll discuss next), the reflected direction gets perturbed randomly, and this perturbation might push the ray below the surface. By checking the dot product and returning false for invalid rays, we tell the ray tracer to treat this as absorption rather than reflection. The ray stops here and contributes no further light, which is the correct behavior for a ray that would have gone into the surface.

From Perfect to Fuzzy: Modeling Surface Roughness

Perfect mirror-like reflection looks great for highly polished metals like chrome or a freshly polished silver mirror. However, most real-world metals aren't perfect mirrors. If you look at a stainless steel refrigerator, brushed aluminum laptop case, or a slightly worn brass doorknob, you'll notice that while they're still shiny and reflective, the reflections are somewhat blurred or fuzzy. You can see the general shapes and colors of reflected objects, but the details aren't as sharp as in a perfect mirror. This happens because real metal surfaces have microscopic imperfections and roughness that scatter the reflected light slightly.

At a microscopic level, even a seemingly smooth metal surface has tiny bumps, scratches, and irregularities. Each of these microscopic features acts like a tiny mirror with its own normal direction. When light hits the surface, different parts of the incoming beam reflect off these tiny facets in slightly different directions. The overall effect is that the reflected light spreads out into a small cone around the perfect reflection direction rather than reflecting in a single precise direction. The rougher the surface, the wider this cone of reflected light becomes.

We can simulate this effect in our ray tracer by adding a small random perturbation to the perfect reflection direction. Instead of scattering the ray exactly along the calculated reflection vector, we add a random offset that pushes the ray slightly away from the perfect reflection. The amount of this offset is controlled by a parameter we call the fuzz factor. A fuzz of zero means no perturbation, giving us perfect mirror-like reflection. A larger fuzz value means more perturbation, creating a rougher, more diffuse reflection that looks like brushed or worn metal.

The fuzz parameter typically ranges from zero to one. At fuzz equals zero, we get perfect specular reflection like a polished mirror. As fuzz increases toward one, the reflection becomes increasingly scattered and blurry. At fuzz equals one, the reflection is so scattered that the material starts to look almost diffuse, though it's still fundamentally different from a Lambertian material because the scattering is centered around the reflection direction rather than the surface normal. Values greater than one would create unrealistic behavior where the scattered rays spread too widely, so we clamp the fuzz parameter to a maximum of one.

Think of fuzz as representing the microscopic roughness of the surface. A highly polished chrome bumper might have a fuzz of 0.0 or 0.05, giving nearly perfect reflections. Brushed stainless steel might have a fuzz of 0.3, creating noticeably softer reflections. A very rough, oxidized metal surface might have a fuzz of 0.7 or higher, where reflections are quite blurred and the surface looks less mirror-like. This single parameter gives us a wide range of metallic appearances, from perfect mirrors to rough, worn metals.

The mathematical implementation of fuzz is straightforward. We calculate the perfect reflection direction as before, then add a random vector scaled by the fuzz factor. The random vector is generated using the same random_unit_vector() function we used for diffuse scattering, which gives us a random direction uniformly distributed on the unit sphere. Multiplying this random unit vector by the fuzz factor scales it down, so a small fuzz value creates a small perturbation and a large fuzz value creates a large perturbation. Adding this scaled random vector to the perfect reflection direction gives us the final scattered ray direction.

Implementing Fuzzy Reflection

Looking back at the metal class code we showed earlier, you can now understand the complete implementation including the fuzz parameter. The constructor takes both an albedo color and a fuzz value. We clamp the fuzz value to a maximum of one using a conditional expression: fuzz(f < 1 ? f : 1). This ensures that even if someone passes a fuzz value greater than one, we'll use one instead, preventing unrealistic behavior.

In the scatter function, after calculating the perfect reflection direction, we generate the fuzz perturbation:

C++

vec3 fuzz_dir = fuzz * random_unit_vector();
scattered = ray(rec.p, reflected + fuzz_dir);

vec3 fuzz_dir = fuzz * random_unit_vector();
scattered = ray(rec.p, reflected + fuzz_dir);

The random_unit_vector() function returns a random direction on the unit sphere, just as we used for diffuse materials. Multiplying by the fuzz factor scales this random vector. If fuzz is zero, fuzz_dir becomes the zero vector and we get perfect reflection. If fuzz is 0.3, the random vector is scaled to thirty percent of its original length, creating a small perturbation. If fuzz is one, we use the full random vector, creating maximum scattering while still being centered around the reflection direction.

Adding this fuzz direction to the perfect reflection direction gives us the final scattered ray direction. This is vector addition, so we're offsetting the reflection direction by a random amount. The scattered ray still generally points in the reflection direction, but it's been nudged randomly. The larger the fuzz, the larger the possible nudge, and the more scattered the reflections become.

The final check return (dot(scattered.direction(), rec.normal) > 0) becomes especially important with fuzzy reflection. When we add a random perturbation to the reflection direction, there's a chance the perturbed direction might point below the surface, especially for large fuzz values or for rays hitting the surface at grazing angles. If the dot product of the scattered direction and the normal is negative or zero, the scattered ray would be going into or along the surface, which is physically impossible. In this case, we return false, telling the ray tracer to absorb the ray rather than scatter it. This absorption is the correct physical behavior and prevents artifacts from invalid ray directions.

Let's consider what happens with different fuzz values. Imagine a ray hitting a metal sphere. With fuzz equals zero, every ray reflects perfectly according to the law of reflection. The sphere acts as a perfect mirror, reflecting a sharp, clear image of its surroundings. With fuzz equals 0.3, each ray still reflects primarily in the mirror direction, but with a small random offset. The sphere still looks metallic and reflective, but the reflected image is slightly blurred, like looking at a reflection in brushed stainless steel. With fuzz equals 0.7, the random perturbations are quite large, and the reflected image becomes very blurred. The sphere still looks shiny and metallic, but you can barely make out details in the reflections. The surface looks rough and worn rather than polished.

The beauty of this approach is its simplicity and flexibility. With just one additional parameter, we can simulate a wide range of metallic appearances. The same metal class can represent everything from perfect mirrors to rough, oxidized metals. In practice, you'll experiment with different fuzz values to achieve the look you want. Most realistic metals fall somewhere in the middle range, with fuzz values between 0.1 and 0.5, giving them a shiny but not perfectly mirror-like appearance.