Configurable Metal Specular Reflection

1. Implementing Perfect Specular Reflection

First, we'll implement a perfectly smooth metal material. This involves creating a C++ function for the reflection formula we derived and then building a new metal material class that uses it.

The reflect Function

Let's translate our formula, r = v - 2(v · n)n, into a C++ helper function. Remember our convention:

• v is the incoming ray's direction (pointing towards the surface).
• n is the surface normal (pointing out from the surface), which we assume is a unit vector.

The C++ implementation is a direct translation of this vector math. It will take the incoming vector v and the normal n and return the reflected vector.

The metal Material Class

Just like our lambertian class, the new metal class will inherit from our abstract material base class and override the scatter method. The logic inside scatter will be:

1. Calculate the reflected direction by calling our new reflect function.
2. Create a new scattered ray originating from the hit point (rec.p) with this reflected direction.
3. Set the attenuation color. For a metal material, the reflected light's color is modulated by the metal's surface color, which we call its albedo. So, attenuation is simply the albedo of our metal.
4. Return true to signify that the ray was successfully scattered.

After implementing the code from the resource, you'll have a metal class that looks something like this:

class metal : public material {
    public:
        metal(const color& a) : albedo(a) {}

        virtual 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 true;
        }

    public:
        color albedo;
};

(Note: I've adapted the code to our existing class structure. Your implementation should follow this pattern.)

At this point, you can add some metal spheres to your scene and see perfect, mirror-like reflections!

2. Simulating Roughness with Fuzziness

Perfect mirrors are rare. Most metallic surfaces have microscopic imperfections that cause light to scatter slightly, blurring the reflection. In PBR terminology, this is controlled by the Roughness parameter. We'll call it fuzziness.

So, how do we simulate this? Instead of reflecting the ray in a single, perfect direction, we'll slightly randomize it. The idea is to pick a random point in a small sphere around the tip of the "perfect" reflection vector and use that as our new direction. The fuzz parameter will control the radius of this sphere: a larger radius means more scattering and a blurrier reflection.

To implement this, we'll modify our metal class:

1. Add a fuzz member variable (a double or float).
2. Update the constructor to accept a fuzziness value. It's good practice to clamp this value between 0 and 1.
3. In the scatter method, after calculating the reflected vector, add a random vector to it. A good way to get this random vector is by using the random_in_unit_sphere() function (which you should already have from implementing the Lambertian material) and scaling it by the fuzz value.
   new_direction = reflected + fuzz * random_in_unit_sphere()
4. Create the scattered ray with this new, fuzzed direction.

Handling an Edge Case

There's one final detail. If the surface is very rough (fuzz is large) and the ray hits the surface at a grazing angle, the randomized reflected ray might scatter below the surface. This is physically incorrect and can cause visual artifacts.

We can detect and prevent this by checking if the new scattered direction is pointing away from the surface. A simple way to do this is with a dot product: if dot(scattered.direction(), rec.normal) is positive, the ray is pointing away from the surface. If it's zero or negative, we should discard the ray (by returning false from scatter), effectively having the surface absorb it.

The final scatter method will look something like this:

virtual 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 + fuzz * random_in_unit_sphere());
    attenuation = albedo;
    return (dot(scattered.direction(), rec.normal) > 0);
}

Now you have a fully functional metal material with adjustable roughness! You can create objects in your scene like this:

// A polished gold sphere
auto material_gold = make_shared<metal>(color(0.8, 0.6, 0.2), 0.0);
world.add(make_shared<sphere>(point3(-1, 0, -1), 0.5, material_gold));

// A rough, brushed aluminum sphere
auto material_aluminum = make_shared<metal>(color(0.8, 0.8, 0.8), 0.3);
world.add(make_shared<sphere>(point3(1, 0, -1), 0.5, material_aluminum));

Conclusion

Fantastic work! You've just implemented one of the most fundamental material types in computer graphics. By building on the mathematical foundation from the last lesson, you've created a versatile metal material that can simulate surfaces from polished mirrors to brushed aluminum.

Key Takeaways:

• The reflection formula r = v - 2(v · n)n translates directly into a C++ helper function.
• A metal material class can be created by implementing a scatter method that returns a reflected ray. The material's albedo determines the attenuation color.
• Fuzziness or roughness is simulated by perturbing the perfect reflection vector with a random vector scaled by a fuzz parameter.
• An edge case check using dot(scattered_direction, normal) > 0 ensures that fuzzed rays don't scatter below the surface.

Next Steps

Our rendered images are starting to look quite good, but there's a subtle issue with how they appear on a monitor. Our calculations of light are all linear, but our eyes and screens don't perceive brightness linearly. In the next lesson, we will apply gamma correction to our final pixel colors. This is a crucial step that will make the lighting and shadows in our scenes look much more natural and pleasing to the eye.