Direct Sampling of Emissive Objects

1. The Problem: Finding the Needle in a Haystack

Why does our current renderer struggle so much with a simple scene like this? It comes down to probability. Our material's scattering function generates rays in random directions over the hemisphere. If the light source is small, the probability of a random ray happening to hit it is extremely low.

When a ray does hit the light, it returns a very bright color. When it misses, it returns a dark color (or black, if there are no other light bounces). The average of a few very bright samples and many dark samples results in a high-variance, noisy estimate.

To build a strong intuition for this problem and its solution, let's watch a video segment that explains it clearly.

As the video explains, the solution is to change our strategy. Instead of hoping a scattered ray finds a light, we will explicitly try to connect our shaded point to the light at every bounce. This means we will be generating two types of rays:

1. A ray sampled from the material's BSDF (what we do now).
2. A "shadow ray" aimed directly at a light source.

This is a form of importance sampling because we are choosing to sample directions we know are "important"—those pointing to lights. But to do this without introducing bias and making the image incorrectly bright, we need to derive the correct PDF for this new strategy.

2. Deriving the PDF for Direct Light Sampling

To use our importance sampling estimator, $\frac{f(x)}{p(x)}$, we need to calculate $p(x)$—the probability density of generating a ray in a specific direction $\omega$ that points to a light.

Let's walk through the derivation, which you can also find in the Ray Tracing: The Rest of Your Life book.

Let's break down the logic:

1. Our strategy is to pick a random point, $q$, uniformly on the surface of the light. If the light has a surface area of $A$, the PDF of picking any specific point $q$ on that surface is constant: $p_{area}(q)=\frac{1}{A}$.

2. However, our rendering equation integrates over solid angle, not area. So, we need to find the PDF for sampling a direction, $\omega$, from our shading point, $p$, towards the light. Let's call this $p_{solid\_angle}(\omega )$.

3. There's a geometric relationship between a small patch of area $dA$ on the light and the solid angle $d\omega$ that it covers from point $p$:
   $d\omega =\frac{dA\cos \theta }{||q-p|{|}^2}$
   Here, $\theta$ is the angle between the light's surface normal at $q$ and the vector from $q$ to $p$. $||q-p|{|}^2$ is the squared distance.

4. The probability of choosing a direction within $d\omega$ must be the same as choosing a point within $dA$. Therefore:
   $p_{solid\_angle}(\omega )d\omega =p_{area}(q)dA$

5. Now we substitute and solve for our desired PDF, $p_{solid\_angle}(\omega )$:
   $p_{solid\_angle}(\omega )=p_{area}(q)\frac{dA}{d\omega }=\frac{1}{A}\frac{||q-p|{|}^2}{\cos \theta }$

This is our crucial formula. When we generate a ray by picking a point on a light, its probability density is the squared distance to that point, divided by the light's area and the cosine of the angle at the light's surface.

3. Combining Strategies with a Mixture PDF

We now have two distinct sampling strategies:

1. BSDF Sampling: Using the material's properties (e.g., cosine-weighted sampling for diffuse surfaces).
2. Light Sampling: Picking a point on a light source.

Which one is better? It depends!

• For a diffuse surface lit by a small, bright light, light sampling is far more effective.
• For a mirror reflecting a large area light (like a sky), BSDF sampling (which for a mirror is just a single reflection ray) is perfect, and light sampling would be wasteful.

Since no single strategy is always best, we'll combine them. We'll generate a new direction by randomly choosing between the two strategies. This is accomplished using a mixture PDF.

A mixture PDF is a weighted average of two or more PDFs. For our case, we'll use a 50/50 mix:
$p_{mixture}(\omega )=0.5\cdot p_{bsdf}(\omega )+0.5\cdot p_{light}(\omega )$

Here's how it works in practice:

• To generate a direction: We flip a coin (i.e., generate a random number). If it's less than 0.5, we generate a direction using BSDF sampling. Otherwise, we use light sampling.
• To evaluate the PDF value for a given direction: This is the subtle part. For any given direction, we must calculate the full mixture probability. We calculate the probability that either strategy could have produced that direction and add them up, weighted. So, pdf_value = 0.5 * p_bsdf(dir) + 0.5 * p_light(dir).

The implementation of this is very clean using a mixture_pdf class.

4. Implementation in the ray_color Loop

With the machinery of PDFs for lights and mixtures in place, we can finally update our main ray_color function. The logic will be more sophisticated, but the core idea is to replace our single scattered ray with one drawn from our new, powerful mixture distribution.

The implementation involves a few key changes, which are best understood by seeing them in context. I recommend reading through these sections from the book, which refactor the material class and the ray_color function to handle this new logic.

Let's summarize the new ray_color logic for a diffuse surface hit:

1. Check for Emission: First, check if the surface we hit is itself emissive. If so, add its emitted light. This accounts for paths that terminate on a light source.
2. Handle Speculars: If the material is purely specular (like a perfect mirror or glass), we skip all the PDF logic and just generate a single reflection/refraction ray. Importance sampling a delta function (like a perfect reflection) is easy—you just sample that one direction!
3. Create Mixture PDF: For non-specular materials, create the two component PDFs:
   • light_pdf: Points to the light sources in the scene. The hittable_list of lights now has methods to help with this.
   • bsdf_pdf: Represents the material's scattering (e.g., a cosine_pdf).
   • Combine them in a mixture_pdf.
4. Sample and Evaluate:
   • Generate a new scattered ray by calling mixture_pdf.generate().
   • Calculate the PDF value for this new ray's direction with pdf_value = mixture_pdf.value().
5. Calculate Contribution: Recursively call ray_color with the new ray. The contribution from this scattered ray is then calculated using our master formula:
   $\text{contribution}=\frac{\text{attenuation}\cdot \text{scattering\_pdf}\cdot \text{color\_from\_recursive\_call}}{\text{pdf\_value}}$
   • attenuation: The material's color (e.g., albedo).
   • scattering_pdf: The value of the BSDF itself, representing $f_r\cdot \cos {\theta }_i$ in the rendering equation.
   • pdf_value: The PDF of our mixture importance sampling strategy.

This final expression is the heart of a path tracer. The scattering_pdf / pdf_value term is the "MIS weight" that correctly balances the contribution of a sample based on how it was generated versus its physical properties.

When you run your code with these changes, the noisy image from the start of the lesson will be replaced by a much cleaner one, converging dramatically faster. This is the power of directing your samples to where the light is.

Conclusion

You have just implemented the core of a modern path tracing algorithm. By explicitly sampling light sources and robustly combining that strategy with BSDF sampling, you've taken a massive leap in rendering efficiency and quality.

Key Takeaways:

• Naive path tracing is noisy and inefficient for scenes with small lights because the probability of randomly hitting a light is very low.
• We solve this with Next Event Estimation (NEE), a form of importance sampling where we explicitly generate rays toward light sources.
• The PDF for sampling a light's surface is derived from solid angle-to-area conversion: $p(\omega )=\frac{{\text{distance}}^2}{A\cdot \cos \theta }$.
• A mixture PDF provides a robust way to combine light sampling and BSDF sampling, allowing the renderer to efficiently handle a wide variety of materials and lighting conditions.
• The final Monte Carlo estimator weights the contribution of each sample by the ratio of the physical scattering distribution (scattering_pdf) to the sampling distribution (pdf_value).

Next Steps

We are at the pinnacle of our ray tracer's development. We've implemented features that are conceptually identical to those in professional renderers. In our final lesson, we will step back and analyze what we've built. We'll compare our path tracer's architecture and techniques to those used in production renderers like Arnold and Karma, discussing what's needed to take a renderer like ours to the next level for feature film production.