Diffuse Reflection and Lambertian Materials

1. The Physics of "Matte" Surfaces

From your experience in VFX, you know that a "diffuse" or "Lambertian" material represents a perfectly matte, non-reflective surface. But what does that mean physically?

On a microscopic level, these surfaces are very rough. When a light ray hits them, it doesn't bounce off cleanly in one direction. Instead, it scatters in one of many random directions.

To see this in action and connect it to the underlying math, let's watch a short, insightful video.

As the video explained, the apparent brightness of a diffuse surface follows Lambert's Cosine Law. It states that the intensity of reflected light is proportional to the cosine of the angle ($\theta$) between the surface normal vector ($\vec{N}$) and the light vector ($\vec{L}$). In vector math, this is conveniently calculated with the dot product: $I\propto \cos (\theta )=\vec{N}\cdot \vec{L}$.

In traditional real-time graphics (like an older game engine), you would calculate this dot product for each light source to determine the pixel's color. In a path tracer, we take a different, more elegant approach: we simulate the scattering.

2. Simulating Uniform Scattering

Instead of explicitly calculating a dot product with a light source, a path tracer simulates the physical reality: it sends the ray bouncing off in a new, random direction. By averaging the results of many such random paths for each pixel, the final image statistically converges to the correct brightness as described by Lambert's Law.

Our task, then, is to pick a random direction for the scattered ray. But which direction? The key is that for an ideal diffuse surface, the light scatters with equal probability in all directions within the hemisphere oriented around the surface normal.

A simple and effective way to generate such a random direction is:

1. Generate a random vector inside a unit sphere (a sphere with a radius of 1).
2. Add this vector to the surface normal at the hit point.
3. The resulting vector is our new, random scatter direction.

Let's read about this technique and see the code to implement it.

Based on the reading, you'll need a helper function to generate a random vector. The book uses a few variations, but the one we'll settle on for our Lambertian material generates a random point on the surface of a unit sphere. Let's call it random_unit_vector(). You can add this to your vec3.h or a utility header.

// A helper function to generate a random vector on the unit sphere's surface.
// This gives us a true Lambertian distribution.
vec3 random_unit_vector() {
    while (true) {
        auto p = vec3::random(-1, 1); // Assumes you have a function to get a random vec3 in a cube
        if (p.length_squared() >= 1) continue;
        return unit_vector(p);
    }
}

Note: This implementation picks a random point inside a unit sphere and then normalizes it to get a point on the surface. You'll need a way to generate random vectors and numbers, which you likely already have from the antialiasing and depth-of-field lessons.

The direction for our new scattered ray will then be:

This new direction vector originates from the hit point (hit_record.p) and points in a random direction within the correct hemisphere.

3. Implementing the lambertian Class

Now we can finally create our first concrete material. You'll create a new header file, lambertian.h (or add to material.h), and implement the class.

It must:

1. Inherit from the abstract material class.
2. Store its intrinsic color, which in PBR terms is called the albedo.
3. Implement the scatter pure virtual function.

This blog post, which follows the same book, provides a clean look at the final lambertian class implementation.

Here is the implementation of the lambertian class you should add to your project.

// In a new file lambertian.h or at the end of material.h

#include "material.h"
#include "hittable.h" // For hit_record

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

    bool scatter(
        const ray& r_in, const hit_record& rec, color& attenuation, ray& scattered
    ) const override {
        auto scatter_direction = rec.normal + random_unit_vector();

        // Catch degenerate scatter direction
        if (scatter_direction.near_zero()) {
            scatter_direction = rec.normal;
        }

        scattered = ray(rec.p, scatter_direction);
        attenuation = albedo;
        return true;
    }

  private:
    color albedo;
};

Let's break down the scatter method:

• auto scatter_direction = rec.normal + random_unit_vector();: This is the core logic we just discussed for finding a random bounce direction.
• if (scatter_direction.near_zero()): This is a crucial edge case. If the random vector we pick is exactly opposite the normal, their sum could be a zero vector. If that happens, we just use the normal as the scatter direction to avoid issues.
• scattered = ray(rec.p, scatter_direction);: We create the new scattered ray. It originates from the hit point (rec.p) and travels in our new random direction. This becomes an output of the function.
• attenuation = albedo;: The attenuation (how much the light is reduced) is simply the material's own color. For a red ball, the albedo is red, so it reflects red light and absorbs others. This is the other output of the function.
• return true;: We return true because this ideal diffuse material always scatters light; it never perfectly absorbs it.

Finally, to use your new material, you'll need to update your main scene setup to create shared pointers to lambertian materials and pass them to your sphere constructors.

Conclusion

Fantastic work! You have now moved from an abstract concept of materials to a concrete, physically-based implementation. You've built the logic for the most fundamental material type in computer graphics, one that serves as the base for countless real-world surfaces.

Key Takeaways:

• Diffuse surfaces are microscopically rough, causing them to scatter incoming light uniformly across their hemisphere.
• Lambert's Cosine Law mathematically describes this behavior, stating that reflected intensity is proportional to the dot product of the normal and light vectors.
• Path tracers simulate this law by scattering rays in random directions. A good method is to add a random unit vector to the surface normal.
• The lambertian material class implements the scatter method to generate this new random ray and sets the ray's color attenuation to the material's albedo.

Next Steps

Right now, your ray_color function probably just returns a color after the first hit. It doesn't yet know what to do with the scattered ray your new material produces. In our next lesson, we will fix that by implementing recursive ray tracing. We will modify ray_color to call itself with the new scattered ray, allowing us to simulate light bouncing multiple times through the scene and finally see our diffuse materials in action. This is the magic that unlocks global illumination effects like color bleeding.