← Back to all projects

PHYSICALLY BASED RENDERING MASTERY

PBR is not just a style of rendering; it is a shift from looks right to is right. Before PBR, rendering was a collection of clever hacks (like Phong shading) that looked decent under specific conditions but broke when lighting changed.

Learn Physically Based Rendering (PBR): From Rays to Photorealism

Goal: Deeply understand the physics of light transport and surface interaction by building a path tracer from first principles. You will move from simple ray-sphere intersections to mastering the Rendering Equation, Monte Carlo integration, and microfacet BRDFs, ultimately creating a system capable of producing photorealistic images that are indistinguishable from reality because they obey the laws of physics.

Why Physically Based Rendering (PBR) Matters

PBR is not just a “style” of rendering; it is a shift from “looks right” to “is right.” Before PBR, rendering was a collection of clever hacks (like Phong shading) that looked decent under specific conditions but broke when lighting changed.

PBR changed everything in the mid-2010s for both film and games because:

  • Consistency: Materials look correct in any lighting environment (morning sun, neon night, dark cave).
  • Predictability: Artists use real-world physical values (reflectance, roughness) instead of arbitrary “shininess” numbers.
  • Energy Conservation: It ensures that a surface never reflects more light than it receives—a fundamental law of physics often ignored in older models.
  • The “Uncanny Valley”: Mastery of PBR is what allows modern CGI to bridge the gap between “computer-generated” and “filmed.”

Understanding PBR is understanding how we see the world. It requires a synthesis of physics (optics), mathematics (calculus and statistics), and high-performance engineering.

Core Concept Analysis

1. The Rendering Equation

The “One Equation to Rule Them All” in computer graphics. Proposed by James Kajiya in 1986, it describes the total amount of light leaving a point in a specific direction.

      L_o = L_e + ∫ [f_r * L_i * (n · ω_i)] dω_i
       ^     ^          ^     ^        ^
       |     |          |     |        +-- Geometric term (cosine)
       |     |          |     +----------- Incoming light from all directions
       |     |          +----------------- BRDF (Material property)
       |     +---------------------------- Emitted light (if it's a lamp)
       +---------------------------------- Outgoing light we want to calculate

2. The Path of a Ray

In a path tracer, we simulate light “backwards” from the eye into the scene.

      [ Light Source ]
             |
             v (Photon path)
      [ Surface A ] ----> [ Surface B ] ----> [ Eye/Camera ]
                                                |
                                                v (Ray path)
                                          [ Pixel Plane ]

3. BRDF: Bidirectional Reflectance Distribution Function

The BRDF defines how a material reflects light. It’s the “DNA” of a material.

       Incoming Light (ω_i)      Outgoing Light (ω_o)
               \                /
                \      Normal  /
                 \       |    /
                  \      |   /
            _______v_____|__/_ ________ Surface
                   \     |    /
                    \____|___/
                       BRDF (f_r)

4. Monte Carlo Integration

Since we cannot solve the integral in the Rendering Equation analytically for complex scenes, we use statistics. We “sample” random directions, average the results, and the law of large numbers guarantees we converge to the correct answer.

       Integral ≈ (1/N) * Σ [ f(x_i) / p(x_i) ]

Concept Summary Table

Concept Cluster What You Need to Internalize
Geometric Optics Light travels in straight lines (rays). Reflection and refraction follow Snell’s law and Fresnel equations.
The Rendering Equation Every point in the scene is a potential light source. Rendering is the process of solving a massive recursive integral.
Monte Carlo Integration We solve “impossible” math problems by rolling dice millions of times and averaging the outcomes.
Microfacet Theory Rough surfaces are actually thousands of tiny perfect mirrors. The “roughness” parameter is a statistical distribution of these mirror normals.
Radiometry The units of light: Flux, Irradiance, Radiance. You must think in energy, not just “color.”

Deep Dive Reading by Concept

This section maps concepts to the “Bible” of the field: “Physically Based Rendering: From Theory to Implementation” (PBRT).

Foundation & Math

Concept Book & Chapter
Radiometry PBRT v4 — Ch. 4: “Radiometry, Spectra, and Color”
Monte Carlo PBRT v4 — Ch. 2: “Monte Carlo Integration”
The Rendering Equation PBRT v4 — Ch. 1: “Introduction” (Section 1.3)

Surface Interaction

Concept Book & Chapter
Reflection Models (BRDF) PBRT v4 — Ch. 8: “Reflection Models”
Microfacet Theory PBRT v4 — Ch. 8 (Section 8.4): “Microfacet Models”
The Fresnel Effect PBRT v4 — Ch. 8 (Section 8.2): “Specular Reflection and Transmission”

Essential Reading Order

  1. The Vision (Week 1):
    • PBRT Ch. 1: Read the overview to understand the system architecture.
    • Ray Tracing in One Weekend (Online): Complete the entire book to get a working “naive” ray tracer.
  2. The Physics (Week 2):
    • PBRT Ch. 4: Learn the difference between Radiance and Irradiance.
    • PBRT Ch. 8: Understand why the Phong model is physically impossible.

Project 1: The Ray-Sphere Intersector (The Eye)

  • File: PHYSICALLY_BASED_RENDERING_MASTERY.md
  • Main Programming Language: C++
  • Alternative Programming Languages: Rust, C, Swift
  • Coolness Level: Level 2: Practical but Forgettable
  • Business Potential: 1. The “Resume Gold”
  • Difficulty: Level 1: Beginner
  • Knowledge Area: Geometric Optics / Linear Algebra
  • Software or Tool: A simple PPM image writer
  • Main Book: “Ray Tracing in One Weekend” by Peter Shirley

What you’ll build: A program that defines a ray structure, a sphere structure, and calculates if a ray hits a sphere, outputting a red/black image to a PPM file.

Why it teaches PBR: Every PBR system starts with a “query”: “What does this ray hit?” Without precise intersection math, physics cannot be applied. This project teaches you to think in vectors and quadratic equations.

Core challenges you’ll face:

  • Solving the Quadratic Equation → Finding the roots to determine the nearest intersection point.
  • Ray-Scene Abstraction → Designing a system where multiple objects can be tested.
  • PPM Image Format → Writing raw bytes to a file without a library.

Key Concepts:

  • Ray Equation: P(t) = A + tB
  • Sphere Equation: (P - C) ¡ (P - C) = r²
  • Quadratic Formula: Used to solve for t.

Difficulty: Beginner Time estimate: 4 hours Prerequisites: Basic C++, understanding of Dot Product.

Real World Outcome

You will generate your first rendered image—a simple red circle on a black background.

Example Output:

$ g++ main.cpp -o raytracer
$ ./raytracer > output.ppm
# Open output.ppm in an image viewer

The file will look like:

P3
200 100
255
0 0 0  0 0 0  0 0 0 ...
0 0 0  255 0 0  255 0 0 ...

The Core Question You’re Answering

“How do we map a 3D mathematical world onto a 2D grid of pixels?”

Before you write code, realize that a “camera” isn’t a physical box here; it’s a point in space shooting rays through a grid.

Concepts You Must Understand First

  1. Vectors
    • What is the difference between a point and a direction?
    • How do you normalize a vector, and why is it mandatory for ray directions?
  2. The Dot Product
    • How does A ¡ B relate to the angle between them?
    • Book Reference: “Fundamentals of Computer Graphics” Ch. 2 - Shirley

Questions to Guide Your Design

  1. The Ray
    • Should a Ray store its origin and direction as separate vectors?
    • How do you represent “infinity” for a ray that hits nothing?
  2. The Output
    • Why use .ppm? (Hint: It’s the simplest possible image header).

Thinking Exercise

Vector Geometry

Imagine a ray starting at (0,0,0) looking at (0,0,-1). A sphere is at (0,0,-5) with radius 1.

Questions:

  • Does the ray hit the sphere?
  • At what t value does it hit the “front” of the sphere?
  • At what t value does it hit the “back”?

The Interview Questions They’ll Ask

  1. “How do you solve for the intersection of a ray and a plane?”
  2. “What is the computational complexity of checking N rays against M spheres?”
  3. “Why might a ray have two t values for a single sphere intersection?”
  4. “How do you handle intersections when the ray origin is inside the sphere?”
  5. “What is ‘precision loss’ in ray-tracing math?”

Hints in Layers

Hint 1: The Ray A Ray is just origin + t * direction. Your goal is to find t.

Hint 2: The Sphere The sphere equation is |P - C|² = R². Substitute P with your ray equation.

Hint 3: Solving for t Expanding the equation gives you at² + bt + c = 0. Use the discriminant (b² - 4ac).

Hint 4: Finding the Closest Hit If the discriminant is positive, you have two roots. You want the smallest positive root.

Books That Will Help

Topic Book Chapter
Ray-Sphere Intersection “Real-Time Rendering” Ch. 22
Vector Math “Essential Mathematics for Games” Ch. 1-2

Project 2: Normals & Lambertian Shading (Surface Interaction)

  • File: PHYSICALLY_BASED_RENDERING_MASTERY.md
  • Main Programming Language: C++
  • Alternative Programming Languages: Rust, Zig
  • Coolness Level: Level 2: Practical but Forgettable
  • Business Potential: 1. The “Resume Gold”
  • Difficulty: Level 1: Beginner
  • Knowledge Area: Shading / Geometry
  • Software or Tool: C++17 or higher
  • Main Book: “Fundamentals of Computer Graphics” by Steve Marschner

What you’ll build: An update to your ray tracer that calculates the surface normal at the hit point and uses it to calculate “Lambertian” (matte) shading.

Why it teaches PBR: Shading is the interaction of light direction and surface direction (the normal). Lambertian shading is the simplest physically plausible diffuse model. It introduces the concept of the “Cosine Law.”

Core challenges you’ll face:

  • Calculating the Normal → (HitPoint - Center) / Radius.
  • Color Mapping → Mapping a normal vector (range -1 to 1) to a color (range 0 to 1) for debugging.
  • The Cosine Rule → Understanding that light intensity falls off as the angle increases.

Key Concepts:

  • Unit Normals: Normals must be normalized for shading math to work.
  • Diffuse Reflection: Light scatters equally in all directions.
  • Lambert’s Law: Intensity = LightDir ¡ Normal

Difficulty: Beginner Time estimate: 4 hours Prerequisites: Completion of Project 1.

Real World Outcome

You will see a 3D-looking sphere with “smooth” lighting. One side will be bright, the other dark. You can also “color” the sphere based on its normals (X=Red, Y=Green, Z=Blue).

The Core Question You’re Answering

“How does a surface ‘know’ how much light it’s receiving?”

Before you write code, look at a matte object (like a piece of paper) under a lamp. Why is it darker when you tilt it away?

Concepts You Must Understand First

  1. Surface Normals
    • Why does a sphere’s normal always point away from the center?
    • How do you handle normals for a plane?
  2. Linear Interpolation (Lerp)
    • How do you blend between two colors based on a value?

Questions to Guide Your Design

  1. Space
    • Is your light source at a fixed position, or is it “at infinity” (directional)?
  2. Clipping
    • What happens if the dot product is negative? (Hint: The light is behind the surface).

Thinking Exercise

The Shadow Side

If the light is at (10, 10, 10) and the surface normal is (0, -1, 0), what is the light intensity?

Answer: It’s 0. Why? Because the light is hitting the “inside” or “back” of the surface.

The Interview Questions They’ll Ask

  1. “What is Lambert’s Cosine Law?”
  2. “Why do we normalize normals before calculating shading?”
  3. “How do you calculate a normal for a triangle?”
  4. “What is the difference between flat shading and smooth shading?”
  5. “Can a Lambertian material reflect more light than it receives?”

Hints in Layers

Hint 1: The Hit Point The hit point is Ray.origin + smallest_t * Ray.direction.

Hint 2: Calculating the Normal For a sphere at C, the normal at P is unit_vector(P - C).

Hint 3: Shading The simplest diffuse color is 0.5 * (normal.x() + 1) mapped to RGB. For “real” shading, use max(0, dot(Normal, LightDir)).

Books That Will Help

Topic Book Chapter
Shading Models “PBRT v4” Ch. 8
Surface Geometry “Real-Time Rendering” Ch. 16

Project 3: Anti-Aliasing & Multisampling (Cleaning the Image)

  • File: PHYSICALLY_BASED_RENDERING_MASTERY.md
  • Main Programming Language: C++
  • Alternative Programming Languages: Rust, Go
  • Coolness Level: Level 2: Practical but Forgettable
  • Business Potential: 1. The “Resume Gold”
  • Difficulty: Level 1: Beginner
  • Knowledge Area: Signal Processing / Sampling
  • Software or Tool: library in C++
  • Main Book: “Ray Tracing in One Weekend”

What you’ll build: A system that shoots multiple rays per pixel with slight random offsets and averages the color.

Why it teaches PBR: In the real world, light isn’t a single point; it’s a continuum. Pixels are discrete bins. This project introduces Sampling, the core of Monte Carlo rendering. You are moving from a single deterministic ray to a stochastic (random) approach.

Core challenges you’ll face:

  • Random Number Generation → Getting a clean distribution of values between 0 and 1.
  • Performance Hit → Realizing that 100x samples means 100x slower rendering.
  • Floating Point Precision → Averaging colors without losing quality.

Key Concepts:

  • Aliasing: The “jaggies” on edges.
  • Stratified Sampling: Spacing samples out for better results.
  • Gamma Correction: Why average_color doesn’t look right on a screen without sqrt(color).

Difficulty: Beginner Time estimate: 6 hours Prerequisites: Completion of Project 2.

Real World Outcome

The jagged edges of your sphere will become perfectly smooth. The image will look “soft” and professional.

The Core Question You’re Answering

“How can we represent a smooth 3D edge using a grid of square blocks?”

The answer is “Integration.” A pixel’s color is the average of all light hitting that small square area.

Concepts You Must Understand First

  1. Probability Distributions
    • What is a uniform distribution?
  2. Gamma Space vs Linear Space
    • Why do computers need to “de-brighten” images for our eyes?
    • Reference: “Real-Time Rendering” Ch. 5 - Tone Mapping.

Questions to Guide Your Design

  1. Efficiency
    • Should you loop over samples inside the pixel loop or outside?
  2. Noise
    • How many samples are needed until the “fuzziness” disappears?

Thinking Exercise

The Average Pixel

If a pixel covers an edge where half is White (1,1,1) and half is Black (0,0,0), what should the pixel color be? What happens if you only take one sample exactly in the middle?

The Interview Questions They’ll Ask

  1. “What is the Nyquist-Shannon sampling theorem?”
  2. “Why does ray tracing naturally handle anti-aliasing better than rasterization?”
  3. “What is Gamma correction and why is it needed?”
  4. “What is the difference between jittered sampling and random sampling?”
  5. “How does increasing sample count affect the signal-to-noise ratio?”

Hints in Layers

Hint 1: The Loop Wrap your ray-generation logic in another loop: for (int s=0; s < samples_per_pixel; s++).

Hint 2: The Offset Instead of shooting through (u, v), shoot through (u + rand_double() / width, v + rand_double() / height).

Hint 3: Averaging Sum all colors, then divide by samples_per_pixel at the very end.

Hint 4: Gamma Before writing to the PPM, apply sqrt() to your RGB values. This is a crude but effective Gamma 2.0 approximation.

Books That Will Help

Topic Book Chapter
Sampling & Integration “PBRT v4” Ch. 2
Anti-Aliasing “Computer Graphics: Principles and Practice” Ch. 3

Project 4: Metal & Glass (The Fresnel Effect & Snell’s Law)

  • File: PHYSICALLY_BASED_RENDERING_MASTERY.md
  • Main Programming Language: C++
  • Alternative Programming Languages: Rust, C#
  • Coolness Level: Level 3: Genuinely Clever
  • Business Potential: 1. The “Resume Gold”
  • Difficulty: Level 2: Intermediate
  • Knowledge Area: Physics / Optics
  • Software or Tool: C++ Standard Library
  • Main Book: “Ray Tracing in One Weekend”

What you’ll build: You’ll implement two new material types: Metal (perfect reflection) and Dielectric (glass/water with refraction).

Why it teaches PBR: This project introduces the conservation of energy and the Fresnel effect. You’ll learn that glass isn’t just transparent; it reflects more light at “grazing angles.” This is a cornerstone of PBR—nothing in nature is 100% reflective or 100% transparent.

Core challenges you’ll face:

  • Refraction Math → Implementing Snell’s Law (n1 sin θ1 = n2 sin θ2).
  • Total Internal Reflection → Handling the case where light cannot escape a denser medium.
  • Schlick’s Approximation → A fast way to calculate how reflectivity changes with angle.

Key Concepts:

  • Reflection Vector: R = V - 2(V ¡ N)N
  • Index of Refraction (IOR): Why water is 1.33 and diamond is 2.4.
  • Ray Recursion: Rays now “bounce” and spawn new rays.

Difficulty: Intermediate Time estimate: 8 hours Prerequisites: Completion of Project 3.

Real World Outcome

You’ll render a scene with a gold sphere (shiny reflection) and a glass sphere (magnifying/distorting the background). It will start looking like a “real” render.

The Core Question You’re Answering

“Why does a window look like a mirror when you look at it from a sharp angle, but like glass when looking straight on?”

This is the Fresnel effect. In PBR, almost every material has a Fresnel term.

Concepts You Must Understand First

  1. Snell’s Law
    • How does light “bend” when entering a different medium?
  2. The Fresnel Equations
    • Why do we use approximations (like Schlick) instead of the full Maxwell equations?

Questions to Guide Your Design

  1. Recursion Depth
    • What happens if a ray bounces between two mirrors forever? How do you set a “max depth”?
  2. Attenuation
    • Does a glass sphere absorb some color, or is it perfectly clear?

Thinking Exercise

The Glass Ball

If you are inside a glass ball, looking out, what happens to your field of view? Trace a ray from your eye, through the glass, and out the other side.

The Interview Questions They’ll Ask

  1. “What is Schlick’s approximation and why is it used?”
  2. “How do you calculate the reflection vector?”
  3. “What is ‘Total Internal Reflection’ and when does it occur?”
  4. “Why does PBR emphasize ‘Everything has Fresnel’?”
  5. “How do you handle the ‘Shadow Acne’ problem (precision offsets)?”

Hints in Layers

Hint 1: Reflection The reflection vector is easy: v - 2*dot(v,n)*n.

Hint 2: Refraction Refraction is harder. You need to calculate the ratio of IORs (e.g., 1.0/1.5 for air to glass). Use the formula for Snell’s Law in vector form.

Hint 3: Schlick R(theta) = R0 + (1-R0)(1-cos(theta))^5. This determines if the ray reflects or refracts.

Hint 4: Self-Intersection When spawning a new ray, start it at hit_point + 0.001 * normal to avoid hitting the same surface twice due to float rounding.

Books That Will Help

Topic Book Chapter
Reflection & Refraction “PBRT v4” Ch. 8
Fresnel Equations “Real-Time Rendering” Ch. 9

Project 5: The Positionable Camera & DOF (Lenses)

  • File: PHYSICALLY_BASED_RENDERING_MASTERY.md
  • Main Programming Language: C++
  • Alternative Programming Languages: Rust, Python (with Taichi)
  • Coolness Level: Level 3: Genuinely Clever
  • Business Potential: 1. The “Resume Gold”
  • Difficulty: Level 2: Intermediate
  • Knowledge Area: Projective Geometry / Camera Models
  • Software or Tool: Linear Algebra basics
  • Main Book: “Ray Tracing in One Weekend”

What you’ll build: A robust Camera class that supports lookfrom, lookat, vup, field of view (FOV), and simulated Depth of Field (lens blur).

Why it teaches PBR: Real cameras don’t have a single “eye point”; they have physical lenses with apertures. This project teaches you how to map world space to camera space using orthonormal bases (UVW vectors) and how to simulate “Defocus Blur” using stochastic sampling on a disk.

Core challenges you’ll face:

  • Building an Orthonormal Basis → Using cross products to find the camera’s Right, Up, and Forward vectors.
  • Thin Lens Approximation → Shooting rays from a random point on a “lens disk” instead of a single point.
  • Trigonometry → Calculating the viewport size based on the vertical FOV.

Key Concepts:

  • FOV (Field of View): Wide angle vs. Telephoto.
  • Aperture: The size of the “hole” that lets in light (affects blur).
  • Focus Distance: Where the image is sharp.

Difficulty: Intermediate Time estimate: 6 hours Prerequisites: Completion of Project 4.

Real World Outcome

You’ll be able to “fly” your camera around the scene and create “bokeh” effects where the background is beautifully blurred while the subject is sharp.

The Core Question You’re Answering

“How do we simulate the ‘soul’ of a photograph (blur, perspective, focus) in a pure math environment?”

You’ll learn that blur isn’t a post-processing filter; it’s a physical consequence of light rays hitting a sensor from different parts of a lens.

Concepts You Must Understand First

  1. Cross Products
    • How do you find a vector perpendicular to two others?
  2. Disk Sampling
    • How do you pick a random point inside a circle uniformly?

Questions to Guide Your Design

  1. The Lens
    • As the aperture gets larger, why does the image get blurrier?
  2. The Viewport
    • How does the “Focus Distance” relate to where you place your virtual viewport?

Thinking Exercise

The Pinhole vs. The Lens

A pinhole camera (aperture 0) has infinite depth of field (everything is sharp). Why? Trace rays from a single point in the scene through a pinhole. Now trace them through a large glass lens.

The Interview Questions They’ll Ask

  1. “How do you construct an Orthonormal Basis (ONB) from a single vector?”
  2. “What is the difference between FOV and Focal Length?”
  3. “How do you simulate a Thin Lens model in a ray tracer?”
  4. “What is the relationship between aperture size and depth of field?”
  5. “How do you handle Aspect Ratio in your camera calculations?”

Hints in Layers

Hint 1: Camera Vectors w = unit_vector(lookfrom - lookat). u = unit_vector(cross(vup, w)). v = cross(w, u). This is your camera coordinate system.

Hint 2: FOV h = tan(theta/2). Viewport height is 2 * h * focus_dist.

Hint 3: Lens Blur Instead of origin = lookfrom, use origin = lookfrom + random_in_unit_disk(). You must then adjust the ray direction to still pass through the intended pixel on the focus plane.

Books That Will Help

Topic Book Chapter
Camera Models “PBRT v4” Ch. 5
View Transformations “Fundamentals of Computer Graphics” Ch. 7

Project 6: Monte Carlo 101: Estimating Pi

  • File: PHYSICALLY_BASED_RENDERING_MASTERY.md
  • Main Programming Language: C++
  • Alternative Programming Languages: Python, Rust, JavaScript
  • Coolness Level: Level 2: Practical but Forgettable
  • Business Potential: 1. The “Resume Gold”
  • Difficulty: Level 1: Beginner
  • Knowledge Area: Statistics / Probability
  • Software or Tool: Random number generator
  • Main Book: “Ray Tracing: The Next Week” by Peter Shirley

What you’ll build: A simple command-line tool that estimates the value of π (Pi) by throwing “darts” at a square and counting how many land inside an inscribed circle.

Why it teaches PBR: This is the fundamental “secret” of PBR. We want to calculate an area (or an integral), but it’s too hard to do directly. So we use random samples. This project teaches you about convergence, variance, and the Law of Large Numbers.

Core challenges you’ll face:

  • Understanding Variance → Watching how the estimate “wiggles” and slowly settles on 3.1415…
  • Sample Count vs. Accuracy → Learning that to get 2x more accuracy, you need 4x more samples (The 1/sqrt(N) rule).
  • Stochastic Noise → Seeing “noise” as a statistical error.

Key Concepts:

  • Probability Density Function (PDF): The likelihood of picking a certain point.
  • Expected Value: What the average of your samples will eventually be.
  • Convergence: How fast the noise disappears.

Difficulty: Beginner Time estimate: 2 hours Prerequisites: Basic math.

Real World Outcome

You’ll have a program that prints Pi with increasing accuracy as you let it run.

$ ./pi_estimator 1000
Pi estimate: 3.124
$ ./pi_estimator 1000000
Pi estimate: 3.14168

The Core Question You’re Answering

“How can we solve a math problem we don’t know the answer to, just by being lucky?”

This project removes the “graphics” and shows you the “math engine” that powers every path tracer.

Concepts You Must Understand First

  1. Area Ratios
    • The area of a circle is π r². The area of a square is (2r)². What is the ratio?
  2. Pseudo-Randomness
    • Why do we need “uniform” random numbers?

Questions to Guide Your Design

  1. Precision
    • How many samples do you need to get 4 decimal places of Pi?
  2. Visualization
    • Can you print a ‘*’ for every hit and a ‘.’ for every miss to “see” the circle forming?

Thinking Exercise

Integration by Darts

If you wanted to calculate the area under the curve y = x² from 0 to 1, how would you change your “dart” throwing logic?

The Interview Questions They’ll Ask

  1. “What is Monte Carlo Integration?”
  2. “Why is the error in Monte Carlo proportional to 1/sqrt(N)?”
  3. “What is a ‘Uniform’ distribution?”
  4. “How do you transform a 1D random number into a 2D point on a sphere?”
  5. “What is ‘Variance Reduction’?”

Hints in Layers

Hint 1: The Circle Test A point (x,y) is inside the circle if x² + y² < 1 (assuming radius 1).

Hint 2: The Ratio Pi = 4 * (Hits / TotalSamples). Why 4? Because the circle area is π and the square area is 4.

Hint 3: 1/sqrt(N) Notice that the first 1,000 samples get you close, but the next 9,000 samples don’t improve it nearly as much.

Books That Will Help

Topic Book Chapter
Monte Carlo Integration “PBRT v4” Ch. 2
Statistical Methods “Introduction to Probability” by Bertsekas Ch. 1

Project 7: The First Path Tracer (Solving the Integral)

  • File: PHYSICALLY_BASED_RENDERING_MASTERY.md
  • Main Programming Language: C++
  • Alternative Programming Languages: Rust, C
  • Coolness Level: Level 4: Hardcore Tech Flex
  • Business Potential: 1. The “Resume Gold”
  • Difficulty: Level 3: Advanced
  • Knowledge Area: Global Illumination / Monte Carlo
  • Software or Tool: C++ Standard Library
  • Main Book: “Ray Tracing: The Next Week”

What you’ll build: You will convert your ray tracer into a Path Tracer. Instead of shooting a single ray to a light source, you will bounce rays randomly according to a PDF (Probability Density Function) and calculate the incoming radiance.

Why it teaches PBR: This is where you actually solve the Rendering Equation. You’ll understand why “Diffuse” materials aren’t just a color, but a distribution of reflected light. You’ll implement Cosine Importance Sampling to reduce noise.

Core challenges you’ll face:

  • Probability Density Functions (PDFs) → Mapping random numbers to a hemisphere.
  • The Rendering Equation Loop → Implementing recursion (or iteration) that accumulates color based on the BRDF and incoming light.
  • Russian Roulette → A technique to terminate ray paths without biasing the image.

Key Concepts:

  • Importance Sampling: Why shooting rays towards the light (or the normal) is better than shooting them everywhere.
  • Global Illumination: Light bouncing from the floor onto the ceiling (color bleeding).
  • Soft Shadows: Naturally occurring because “lights” are now objects in the scene.

Difficulty: Advanced Time estimate: 1-2 weeks Prerequisites: Completion of Project 6.

Real World Outcome

You’ll render the “Cornell Box” (a classic graphics test). You’ll see “Color Bleeding” (the red wall makes the white floor look slightly red) and soft, realistic shadows.

The Core Question You’re Answering

“How can we simulate light that bounces infinitely many times in a scene?”

The answer is “Path Tracing” - a stochastic approximation of the infinite series of light bounces.

Concepts You Must Understand First

  1. Hemisphere Sampling
    • How do you pick a random direction on a dome?
  2. The Geometry Term
    • Why do we multiply by cos(θ) when a ray hits a surface?

Questions to Guide Your Design

  1. Noise
    • Why does the image start out “speckled” and then get smooth?
  2. Termination
    • If a ray bounces 100 times, it takes a long time. If it bounces 2 times, it looks dark. What is the “correct” number of bounces?

Thinking Exercise

The White Room

If you are in a room where every wall is perfectly white (reflects 100% light) and there is one light, how bright will the room be? What happens to your path tracer if you don’t use Russian Roulette?

The Interview Questions They’ll Ask

  1. “What is the difference between Whitted Ray Tracing and Path Tracing?”
  2. “How does Importance Sampling reduce variance?”
  3. “What is a Probability Density Function (PDF) in the context of rendering?”
  4. “What is ‘Russian Roulette’ in path tracing and why is it unbiased?”
  5. “What causes ‘Fireflies’ in a path tracer?”

Hints in Layers

Hint 1: The Loop Instead of Material.scatter(), your color() function should now look like: L_o = Emitted + Albedo * color(ScatteredRay).

Hint 2: Sampling the Hemisphere To sample a hemisphere according to a cosine distribution: Pick a random point on a unit disk and project it up to the unit sphere.

Hint 3: Russian Roulette To stop a ray: Generate a random number. If it’s less than P, continue and divide the color by P. Otherwise, stop. This keeps the expected value the same.

Hint 4: PDF Division In the final equation, you must always divide by the PDF of the direction you chose. For cosine sampling, the PDF is cos(θ)/π.

Books That Will Help

Topic Book Chapter
Path Tracing “PBRT v4” Ch. 14
Importance Sampling “Real-Time Rendering” Ch. 9

Project 8: Bounding Volume Hierarchies (BVH)

  • File: PHYSICALLY_BASED_RENDERING_MASTERY.md
  • Main Programming Language: C++
  • Alternative Programming Languages: Rust, C
  • Coolness Level: Level 3: Genuinely Clever
  • Business Potential: 1. The “Resume Gold”
  • Difficulty: Level 3: Advanced
  • Knowledge Area: Data Structures / Computational Geometry
  • Software or Tool: Recursion and Binary Trees
  • Main Book: “Ray Tracing: The Next Week”

What you’ll build: A tree structure that wraps objects in boxes. Instead of checking every object in the scene for every ray, you check the boxes first.

Why it teaches PBR: Speed is a feature. Without a BVH, you can’t render complex scenes (like a forest or a car). This project teaches you the difference between O(N) and O(log N) and how spatial partitioning is the key to scaling ray tracing.

Core challenges you’ll face:

  • AABB (Axis-Aligned Bounding Box) Intersection → Implementing the “slab method” for ultra-fast box tests.
  • Tree Construction → Deciding how to “split” the objects into two groups (X, Y, or Z axis?).
  • Tree Traversal → Efficiently walking the tree without using too much memory or recursion depth.

Key Concepts:

  • Spatial Partitioning: Dividing 3D space into manageable chunks.
  • SAH (Surface Area Heuristic): A fancy way to build the best possible tree (optional but recommended).

Difficulty: Advanced Time estimate: 1 week Prerequisites: Completion of Project 2.

Real World Outcome

You’ll be able to render a scene with 10,000 spheres in the same time it previously took to render 10. Your render times will drop from hours to seconds.

The Core Question You’re Answering

“How can we find one needle in a haystack of a billion needles in less than a microsecond?”

The answer is hierarchy. If you know the needle isn’t in the left half of the room, you don’t look there.

Concepts You Must Understand First

  1. AABBs (Axis-Aligned Bounding Boxes)
    • Why are they faster to test than spheres?
  2. Binary Search Trees
    • How does a 3D BVH relate to a standard 1D binary tree?

Questions to Guide Your Design

  1. Memory
    • Should your BVH nodes store the objects themselves, or just pointers/indices?
  2. The Split
    • If you have 100 objects, where do you draw the line to split them? In the middle of the objects, or in the middle of the space?

Thinking Exercise

The Slab Method

Imagine a ray and a box. The box is defined by xmin, xmax, ymin, ymax, zmin, zmax. How can you use the “enter” and “exit” times of the ray for each pair of planes to see if it hits the box?

The Interview Questions They’ll Ask

  1. “What is an AABB and why is it used in ray tracing?”
  2. “What is the Surface Area Heuristic (SAH)?”
  3. “How do you handle moving objects in a BVH?”
  4. “What is the difference between a BVH and an Octree?”
  5. “What is the time complexity of building a BVH vs. searching it?”

Hints in Layers

Hint 1: AABB Test The “Slab Method” involves calculating t_min and t_max for each axis and taking the intersection of those intervals.

Hint 2: Recursive Construction BVHNode(list): 1. Pick an axis. 2. Sort objects. 3. Split list in half. 4. left = new BVHNode(first_half), right = new BVHNode(second_half).

Hint 3: Base Case If the list has only 1 or 2 objects, just store them in a “Leaf Node” instead of splitting further.

Hint 4: Sorting Use std::sort with a custom comparator that compares the center of the objects’ bounding boxes along the chosen axis.

Books That Will Help

Topic Book Chapter
BVH & SAH “PBRT v4” Ch. 7
Spatial Data Structures “Real-Time Rendering” Ch. 19

Project 9: Image-Based Lighting (IBL) & HDR

  • File: PHYSICALLY_BASED_RENDERING_MASTERY.md
  • Main Programming Language: C++
  • Alternative Programming Languages: Rust, Python
  • Coolness Level: Level 5: Pure Magic (Super Cool)
  • Business Potential: 1. The “Resume Gold”
  • Difficulty: Level 2: Intermediate
  • Knowledge Area: Imaging / Environment Mapping
  • Software or Tool: .hdr file loader (like stb_image.h)
  • Main Book: “Real-Time Rendering”

What you’ll build: Instead of a solid background color, your ray tracer will read an HDR (High Dynamic Range) panoramic image (a .hdr file) and use it to light the scene.

Why it teaches PBR: In the real world, light comes from everywhere (the sky, the ground, the trees). This project teaches you that the environment is the light source. You’ll learn about Equirectangular Projection and how to sample a spherical image.

Core challenges you’ll face:

  • HDR Loading → Handling floating-point color values that can be much larger than 1.0 (e.g., the sun at 10,000.0).
  • UV Mapping → Converting a 3D ray direction into 2D (u,v) coordinates for the environment map.
  • Tone Mapping → Converting those massive HDR values back into the 0-255 range so they don’t look “blown out” on your monitor.

Key Concepts:

  • Dynamic Range: The difference between the darkest shadow and the brightest sun.
  • Reinhard Tone Mapping: A simple formula to map [0, ∞] to [0, 1].
  • Latitude-Longitude Mapping: The math of a global map.

Difficulty: Intermediate Time estimate: 8 hours Prerequisites: Completion of Project 7.

Real World Outcome

Your spheres will now reflect a real-world environment (like a forest or a cathedral). The lighting will look incredibly rich and complex because it’s based on a real photograph.

The Core Question You’re Answering

“How can we capture the complexity of real-world lighting without manually placing thousands of virtual lamps?”

The answer is IBL - using a 360-degree photograph as a giant, infinite light source.

Concepts You Must Understand First

  1. Spherical Coordinates
    • How do you turn (x, y, z) into θ and φ?
  2. High Dynamic Range (HDR)
    • Why do we need 32-bit floats per color channel instead of 8-bit integers?

Questions to Guide Your Design

  1. The Sun
    • If your HDR image has a sun, why do your renders look noisy? (Hint: The sun is a tiny, extremely bright point).
  2. Tone Mapping
    • What happens if you just “clamp” colors at 1.0? (Hint: Everything becomes flat white).

Thinking Exercise

The Mirrored Sphere

Imagine a perfectly mirrored sphere in a forest. Every ray that hits the sphere bounces out and hits the forest. How do you find the pixel color in the HDR map for that reflected ray?

The Interview Questions They’ll Ask

  1. “What is HDR and why is it essential for PBR?”
  2. “How do you map a 3D direction vector to a 2D equirectangular texture?”
  3. “What is Tone Mapping and what problem does it solve?”
  4. “What is the difference between an Environment Map and a Point Light?”
  5. “How do you sample an HDR map efficiently to reduce noise?”

Hints in Layers

Hint 1: Loading HDR Use stbi_loadf from the stb_image.h library. It returns an array of floats.

Hint 2: UV Mapping phi = atan2(z, x), theta = asin(y). u = 1 - (phi + pi) / (2 * pi), v = (theta + pi/2) / pi.

Hint 3: HDR Values Don’t be afraid if your color values are 10.0 or 100.0. This is good! It means your reflections will be bright.

Hint 4: Simple Tone Mapping At the very end of your pixel calculation: final_color = color / (color + 1.0). This is the Reinhard operator. It ensures no color ever exceeds 1.0.

Books That Will Help

Topic Book Chapter
Environment Mapping “Real-Time Rendering” Ch. 10
Tone Mapping “PBRT v4” Ch. 10

Project 10: The Microfacet BRDF: Cook-Torrance

  • File: PHYSICALLY_BASED_RENDERING_MASTERY.md
  • Main Programming Language: C++
  • Alternative Programming Languages: Rust, GLSL
  • Coolness Level: Level 4: Hardcore Tech Flex
  • Business Potential: 1. The “Resume Gold”
  • Difficulty: Level 3: Advanced
  • Knowledge Area: Microfacet Theory / Calculus
  • Software or Tool: C++ Standard Library
  • Main Book: “Real-Time Rendering”

What you’ll build: You will implement the industry-standard PBR material model: the Cook-Torrance BRDF. This includes the $D$, $G$, and $F$ terms (Distribution, Geometry, and Fresnel).

Why it teaches PBR: This is the heart of PBR. You will move away from “shiny” or “matte” to Roughness and Metalness. You’ll understand how the shape of a specular highlight is determined by the statistical distribution of tiny mirror-like facets on a surface.

Core challenges you’ll face:

  • The Trowbridge-Reitz (GGX) Distribution → The math that defines the “long tail” of PBR highlights.
  • The Smith Geometry Term → Accounting for facets that shadow or mask each other.
  • Energy Conservation → Ensuring that the BRDF integral doesn’t create light out of nowhere.

Key Concepts:

  • Microfacet Theory: Roughness is just many small mirrors.
  • GGX Distribution: The most popular $D$ term in modern rendering.
  • F0 (Fresnel at Zero Degrees): The base reflectivity of a material.

Difficulty: Advanced Time estimate: 1 week Prerequisites: Completion of Project 9.

Real World Outcome

You’ll be able to render materials that look like brushed aluminum, rough plastic, or polished chrome using just two sliders: Roughness and Metalness.

The Core Question You’re Answering

“If a surface is made of perfect mirrors, why does it look blurry when it’s rough?”

The answer is statistical dispersion. The mirrors aren’t all pointing the same way.

Concepts You Must Understand First

  1. The Half-Vector (H)
    • Why do we calculate shading relative to the vector exactly between the Light and the Eye?
  2. Solid Angles
    • How do you measure the “size” of a patch on a sphere?

Questions to Guide Your Design

  1. Singularities
    • What happens to the math when Roughness is exactly 0.0? (Hint: Division by zero).
  2. Metallic vs Dielectric
    • Why do metals have colored reflections, while plastics have white reflections?

Thinking Exercise

The Rough Mirror

Trace a ray hitting a rough surface. Instead of a single reflection vector, you now have a “probability” of reflecting in many directions. How do you pick one? (Hint: Importance sampling the GGX distribution).

The Interview Questions They’ll Ask

  1. “Explain the three components of the Cook-Torrance BRDF.”
  2. “Why is GGX preferred over the older Blinn-Phong model?”
  3. “What is the difference between shadowing and masking in microfacet theory?”
  4. “How do you ensure energy conservation in a microfacet BRDF?”
  5. “What is the relationship between IOR and F0?”

Hints in Layers

Hint 1: The Half-Vector H = normalize(V + L). In a path tracer, you generate L based on H.

Hint 2: The D Term (GGX) The formula is $D(h) = \alpha^2 / (\pi ( (n \cdot h)^2 (\alpha^2 - 1) + 1 )^2)$. $\alpha$ is roughness * roughness.

Hint 3: Importance Sampling GGX You can’t just pick a random direction; you need to pick directions that D(h) likes. This involves a mapping from two random numbers to spherical coordinates.

Hint 4: Fresnel Use the Schlick approximation, but remember that for metals, $F_0$ is the albedo color, while for dielectrics, it’s usually (0.04, 0.04, 0.04).

Books That Will Help

Topic Book Chapter
Microfacet Models “PBRT v4” Ch. 8
Cook-Torrance “Real-Time Rendering” Ch. 9

Project 11: Multi-Importance Sampling (MIS)

  • File: PHYSICALLY_BASED_RENDERING_MASTERY.md
  • Main Programming Language: C++
  • Alternative Programming Languages: Rust
  • Coolness Level: Level 5: Pure Magic (Super Cool)
  • Business Potential: 1. The “Resume Gold”
  • Difficulty: Level 4: Expert
  • Knowledge Area: Statistics / Variance Reduction
  • Software or Tool: Veach’s Power Heuristic
  • Main Book: “PBRT v4”

What you’ll build: An advanced sampling system that combines two strategies: 1) Sampling the Light Source, and 2) Sampling the BRDF.

Why it teaches PBR: This project addresses the “Firefly” problem. You’ll learn that no single sampling strategy is perfect. If the light is small, you should sample the light. If the surface is a mirror, you should sample the BRDF. MIS allows you to do both and weight them so the result is always low-noise.

Core challenges you’ll face:

  • Understanding Variance → Seeing why sampling a tiny light with a BRDF ray is “lucky” and causes bright white pixels (fireflies).
  • The Balance Heuristic → Math to combine two different PDFs without double-counting light.
  • Implementation Complexity → Managing multiple ray paths and weight calculations.

Key Concepts:

  • MIS: Multiple Importance Sampling.
  • Power Heuristic: A weighting function that gives more weight to the “better” sampling strategy.
  • Veach’s Thesis: The breakthrough that made modern path tracing possible.

Difficulty: Expert Time estimate: 1-2 weeks Prerequisites: Completion of Project 10.

Real World Outcome

Your renders will become clean much faster. Scenarios that were previously “impossible” (like a small lamp reflecting in a shiny floor) will now converge quickly.

The Core Question You’re Answering

“How do we handle the case where we have two ways to solve a problem, and both are sometimes wrong?”

MIS is a mathematical way to get the best of both worlds.

Concepts You Must Understand First

  1. PDF Weighted Sums
    • If you have two random variables, how do you average them correctly?
  2. Light Sampling
    • How do you pick a random point on a light source and calculate its PDF?

Questions to Guide Your Design

  1. The Small Light
    • Why is it so hard to hit a small light source by just bouncing rays randomly off a surface?
  2. The Mirror
    • Why is it useless to sample a light source if the surface is a perfect mirror? (Hint: The mirror only cares about one specific direction).

Thinking Exercise

The Two Lamps

Imagine a scene with a giant, dim light and a tiny, incredibly bright light. Which sampling strategy will work best for each?

The Interview Questions They’ll Ask

  1. “What is Multiple Importance Sampling (MIS)?”
  2. “Why do we need MIS in a path tracer?”
  3. “Explain the Balance Heuristic and the Power Heuristic.”
  4. “How do you calculate the PDF for sampling a spherical light source?”
  5. “What is the ‘Double Counting’ problem and how does MIS solve it?”

Hints in Layers

Hint 1: The Strategy For every bounce: 1. Pick a direction by sampling the BRDF. 2. Pick a direction by sampling the Light. 3. Calculate both results.

Hint 2: The Weight weight_a = pdf_a / (pdf_a + pdf_b). This is the Balance Heuristic.

Hint 3: PDF Calculation When you sample the light, you MUST also calculate what the BRDF PDF would have been for that same direction, and vice-versa.

Hint 4: Visibility Don’t forget to shoot shadow rays! If the light is blocked, its contribution (and weight) is zero.

Books That Will Help

Topic Book Chapter
MIS “PBRT v4” Ch. 13
Sampling Theory Eric Veach’s PhD Thesis Ch. 9

Project 12: Participating Media (Homogeneous Fog)

  • File: PHYSICALLY_BASED_RENDERING_MASTERY.md
  • Main Programming Language: C++
  • Alternative Programming Languages: Rust, GLSL
  • Coolness Level: Level 5: Pure Magic (Super Cool)
  • Business Potential: 1. The “Resume Gold”
  • Difficulty: Level 3: Advanced
  • Knowledge Area: Volumetric Rendering
  • Software or Tool: Beer-Lambert Law
  • Main Book: “Ray Tracing: The Next Week”

What you’ll build: You’ll implement “Volume” objects—spheres or boxes filled with a constant-density fog that scatters and absorbs light.

Why it teaches PBR: Light doesn’t just bounce off surfaces; it travels through matter. This project introduces the Volume Rendering Equation. You’ll learn about Phase Functions (the BRDF of air) and how light intensity decays over distance.

Core challenges you’ll face:

  • Distance Sampling → Picking a random point inside a volume where a ray “hits” a particle.
  • The Beer-Lambert Law → Calculating how much light is lost as it travels through fog.
  • Isotropic Scattering → Handling particles that reflect light equally in all directions.

Key Concepts:

  • Absorption: Light turning into heat.
  • Scattering: Light changing direction.
  • Transmittance: The fraction of light that makes it through.

Difficulty: Advanced Time estimate: 1 week Prerequisites: Completion of Project 8 (BVH is very helpful for volume boundaries).

Real World Outcome

You’ll see “God Rays” or soft glowing fog around light sources. Your scenes will gain a sense of atmosphere and depth.

The Core Question You’re Answering

“What happens to a ray of light when it’s traveling through ‘nothing’ that isn’t actually empty?”

You’ll discover that volumes are just “spread out” surfaces.

Concepts You Must Understand First

  1. Exponential Decay
    • Why does $e^{-dx}$ describe light loss?
  2. Phase Functions
    • How does the Henyey-Greenstein function describe “dusty” air vs “misty” air?

Questions to Guide Your Design

  1. Inside or Outside?
    • How do you know when a ray enters a volume and when it leaves?
  2. Probability of a Hit
    • If the fog is thin, the ray might go all the way through. How do you handle that in a path tracer?

Thinking Exercise

The Searchlight

Trace a ray through a thick fog. At every millimeter, there is a chance the ray hits a fog particle and bounces. How do you decide where it hits?

The Interview Questions They’ll Ask

  1. “What is the Beer-Lambert Law?”
  2. “Explain the difference between absorption and scattering coefficients.”
  3. “What is a Phase Function and what is its surface-equivalent?”
  4. “How do you sample a distance through a homogeneous volume?”
  5. “What is ‘Single Scattering’ vs ‘Multiple Scattering’?”

Hints in Layers

Hint 1: Sampling Distance If a ray is inside a volume with density d, the distance it travels before hitting a particle is t = -log(rand()) / d.

Hint 2: The Hit Test If the sampled t is greater than the distance to the next surface, the ray “misses” the fog and hits the wall.

Hint 3: Albedo of Fog Just like surfaces, fog has an albedo. If it hits a particle, the new color is color * fog_albedo.

Hint 4: Phase Function For simple fog, use a “Uniform” phase function: just pick a random direction on the whole sphere.

Books That Will Help

Topic Book Chapter
Volume Scattering “PBRT v4” Ch. 11
Volumetric Integration “Real-Time Rendering” Ch. 14

Project 13: Subsurface Scattering (Skin, Wax, Marble)

  • File: PHYSICALLY_BASED_RENDERING_MASTERY.md
  • Main Programming Language: C++
  • Alternative Programming Languages: Rust, GLSL
  • Coolness Level: Level 5: Pure Magic (Super Cool)
  • Business Potential: 1. The “Resume Gold”
  • Difficulty: Level 4: Expert
  • Knowledge Area: BSSRDF / Light Transport
  • Software or Tool: Dipole Approximation
  • Main Book: “PBRT v4”

What you’ll build: You’ll implement a BSSRDF (Bidirectional Scattering-Surface Reflectance Distribution Function) to simulate light that enters a surface, bounces around inside, and exits at a different point.

Why it teaches PBR: This project shatters the “light hits a point, light leaves a point” assumption of basic BRDFs. You’ll understand why human skin looks “waxy” or “alive” because of light scattering under the surface. This is essential for photorealistic characters.

Core challenges you’ll face:

  • Sampling the Surface → Picking a random exit point near the entry point.
  • The Dipole Model → A mathematical shortcut to simulate thousands of internal bounces.
  • Translucency → Seeing light “glow” through thin objects (like a candle or an ear).

Key Concepts:

  • BSSRDF: The 8-dimensional function of light transport.
  • Scattering Mean Free Path: How far light travels on average inside a material.
  • Diffusion: The process of light “spreading out” inside a medium.

Difficulty: Expert Time estimate: 2 weeks Prerequisites: Completion of Project 12.

Real World Outcome

You’ll render a jade statue or a candle where the edges “glow” with light, and the shadows are soft and colorful instead of hard and black.

The Core Question You’re Answering

“Why do some materials look ‘deep’ and others look ‘flat’, even if they have the same surface texture?”

The answer is subsurface transport.

Concepts You Must Understand First

  1. Entry vs Exit Point
    • How do you calculate the distance between two points on a 3D surface?
  2. Diffusion Profiles
    • Why does red light travel further in skin than blue light?

Questions to Guide Your Design

  1. Efficiency
    • How do you find a nearby surface point without re-tracing the whole scene?
  2. The “Glow”
    • Why do objects look more translucent when lit from behind?

Thinking Exercise

The Flashlight on the Hand

Put a flashlight against your palm. Why does the back of your hand glow red? Trace the path of the photons through the skin, muscle, and bone.

The Interview Questions They’ll Ask

  1. “What is a BSSRDF and how does it differ from a BRDF?”
  2. “Explain the concept of ‘Diffusion’ in subsurface scattering.”
  3. “What is the Dipole Approximation?”
  4. “Why is SSS important for rendering human skin?”
  5. “How do you importance-sample a BSSRDF?”

Hints in Layers

Hint 1: The Function A BSSRDF takes (Pi, wi) and returns (Po, wo). Note the two different points.

Hint 2: Sampling Po Pick a random radius r from a diffusion profile and a random angle. Project this onto the surface to find Po.

Hint 3: Diffusion Profile Use a sum of two exponentials (the dipole) to determine the probability of light traveling a certain distance r.

Hint 4: Transmittance For thin objects, the entry and exit points might be on opposite sides of the mesh. Your sampler must handle this!

Books That Will Help

Topic Book Chapter
Subsurface Scattering “PBRT v4” Ch. 11
Human Skin Rendering “Real-Time Rendering” Ch. 14

Project 14: The Disney Principled BRDF (Production Standard)

  • File: PHYSICALLY_BASED_RENDERING_MASTERY.md
  • Main Programming Language: C++
  • Alternative Programming Languages: Rust, GLSL
  • Coolness Level: Level 5: Pure Magic (Super Cool)
  • Business Potential: 5. The “Industry Disruptor”
  • Difficulty: Level 3: Advanced
  • Knowledge Area: Shader Engineering
  • Software or Tool: Disney “Principled” Paper (2012)
  • Main Book: “Real-Time Rendering”

What you’ll build: A “Uber-Shader” that combines many effects into a single set of intuitive parameters: Subsurface, Metallic, Specular, Roughness, Anisotropic, Sheen, Clearcoat, and ClearcoatGloss.

Why it teaches PBR: This is how the real industry works. You’ll learn how to unify complex physics into a set of “Artist Friendly” controls. You’ll implement Clearcoat (like car paint) and Sheen (like fabric) layers.

Core challenges you’ll face:

  • Layer Blending → Ensuring that adding a “Clearcoat” layer doesn’t break energy conservation.
  • Anisotropy → Shading surfaces like brushed metal or vinyl records where highlights “stretch.”
  • Code Organization → Managing a massive mathematical function without it becoming a mess.

Key Concepts:

  • Anisotropy: When roughness is different in the X and Y directions.
  • Sheen: Back-scattering for fabric (velvet).
  • Clearcoat: A second, perfectly smooth specular layer on top of a rough one.

Difficulty: Advanced Time estimate: 1 week Prerequisites: Completion of Project 10.

Real World Outcome

You will have a single material that can represent almost any object in the world: a car, a t-shirt, a piece of wood, or a gold coin, just by changing values.

The Core Question You’re Answering

“How can we make a complex physics system easy for an artist to use without losing realism?”

This project is about the intersection of Art and Science.

Concepts You Must Understand First

  1. Bitangents
    • For anisotropic surfaces, you need more than just a Normal; you need to know which way the “grooves” go.
  2. Layered Materials
    • How does light travel through a clear top coat, hit the rough paint underneath, and come back out?

Questions to Guide Your Design

  1. Normalization
    • As you increase “Metallic”, what should happen to the “Diffuse” color? (Hint: It should go to zero).
  2. Clearcoat
    • Does a clearcoat have its own normal, or does it share the surface normal?

Thinking Exercise

The Velvet Chair

Look at a piece of velvet. It’s brightest at the edges, not where the light hits it directly. Why? How would you model this “Sheen”?

The Interview Questions They’ll Ask

  1. “What are the core principles of the Disney Principled BRDF?”
  2. “How do you implement Anisotropic GGX?”
  3. “Explain the ‘Clearcoat’ model and how it interacts with the base layer.”
  4. “Why did Disney move away from traditional IOR sliders to ‘Specular’ sliders?”
  5. “How do you handle importance sampling for a BRDF with 10+ parameters?”

Hints in Layers

Hint 1: The Base Start with your GGX Metallic/Roughness model from Project 10.

Hint 2: Anisotropy In the GGX $D$ term, replace $\alpha^2$ with $\alpha_x \alpha_y$. This “stretches” the highlight.

Hint 3: Clearcoat Clearcoat is a hardcoded IOR of 1.5 (F0 = 0.04). It’s a second specular bounce.

Hint 4: Sheen Sheen is often modeled using a “Schlick-like” term that only appears at grazing angles to simulate tiny fibers catching light.

Books That Will Help

Topic Book Chapter
Disney BRDF “Physically Based Shading at Disney” (Brent Burley) Original Paper
Advanced BRDFs “Real-Time Rendering” Ch. 9

Project 15: Wavefront Path Tracing (Performance at Scale)

  • File: PHYSICALLY_BASED_RENDERING_MASTERY.md
  • Main Programming Language: C++ / CUDA
  • Alternative Programming Languages: Rust, Metal
  • Coolness Level: Level 4: Hardcore Tech Flex
  • Business Potential: 5. The “Industry Disruptor”
  • Difficulty: Level 5: Master
  • Knowledge Area: GPU Architecture / Parallel Programming
  • Software or Tool: NVIDIA CUDA or OptiX
  • Main Book: “PBRT v4”

What you’ll build: You will rewrite your path tracer to run on the GPU using a “Wavefront” architecture. Instead of one ray at a time, you’ll process millions of rays in parallel stages (Generate -> Intersect -> Shade -> Compact).

Why it teaches PBR: Rendering is a “massively parallel” problem. This project teaches you how to map the recursive nature of path tracing to the SIMD (Single Instruction, Multiple Data) architecture of a GPU. You’ll learn about Coalesced Memory Access and Stream Compaction.

Core challenges you’ll face:

  • GPU Memory Management → Moving thousands of spheres and textures to VRAM.
  • Divergence → Handling the fact that different rays hit different materials and want to do different math.
  • Stackless Traversal → How to traverse a BVH on a GPU without using recursion.

Key Concepts:

  • SIMT: Single Instruction, Multiple Threads.
  • Wavefront: Organizing rays into “waves” that all perform the same task.
  • Throughput vs Latency: Why the GPU is 100x faster for rendering.

Difficulty: Master Time estimate: 1 month Prerequisites: Completion of Project 8 and Project 11.

Real World Outcome

You’ll render your scenes in seconds instead of minutes. You’ll have the foundation of a modern, production-grade GPU renderer like Octane or Redshift.

The Core Question You’re Answering

“How do we coordinate a million tiny processors to solve a single massive math problem without them stepping on each other’s toes?”

This is the peak of graphics engineering.

Concepts You Must Understand First

  1. Kernels
    • What is a CUDA kernel and how does it execute?
  2. Stream Compaction
    • When 50% of your rays hit the sky and 50% hit a wall, how do you keep the GPU busy with only the rays that are still “alive”?

Questions to Guide Your Design

  1. Registers
    • If your “Shade” kernel is too complex, the GPU can’t run as many threads. How do you split the work?
  2. Atomic Operations
    • How do you safely add color from 1,000 threads into the same pixel?

Thinking Exercise

The Parallel Ray

If you have 32 rays in a “warp”, and 31 rays hit a simple matte wall but 1 ray hits a complex glass sphere, the whole warp has to wait for that 1 ray. How can you “re-sort” your rays to avoid this “Divergence”?

The Interview Questions They’ll Ask

  1. “What is a Wavefront Path Tracer?”
  2. “How do you handle BVH traversal on the GPU?”
  3. “What is ‘Warp Divergence’ and how does it affect rendering performance?”
  4. “Explain Stream Compaction in the context of a path tracer.”
  5. “What are the advantages of a GPU path tracer over a CPU one?”

Hints in Layers

Hint 1: The Buffers Create large buffers in VRAM for RayOrigins, RayDirections, RayThroughputs, and PixelIndices.

Hint 2: The Stages Your main loop should call: GenerateRays(), then while(depth < max_depth) { IntersectRays(); ShadeRays(); CompactRays(); }.

Hint 3: Stream Compaction Use a library like Thrust or implement a parallel “Prefix Sum” to move active rays to the front of the buffer.

Hint 4: Textures On the GPU, use cudaTextureObject_t for your HDR maps. It handles the UV interpolation and wrap-around math for you in hardware!

Books That Will Help

Topic Book Chapter
GPU Path Tracing “PBRT v4” Ch. 15
CUDA Programming “Programming Massively Parallel Processors” Ch. 1-5

Project Comparison Table

Project Difficulty Time Depth of Understanding Fun Factor
1. Ray-Sphere Intersector Beginner 4h ★☆☆☆☆ ★★☆☆☆
2. Normals & Lambertian Beginner 4h ★☆☆☆☆ ★★★☆☆
3. Anti-Aliasing Beginner 6h ★★☆☆☆ ★★★☆☆
4. Metal & Glass Intermediate 8h ★★★☆☆ ★★★★☆
5. Positionable Camera Intermediate 6h ★★★☆☆ ★★★★☆
6. Monte Carlo Pi Beginner 2h ★★★★☆ ★★☆☆☆
7. First Path Tracer Advanced 2w ★★★★★ ★★★★★
8. BVH Optimization Advanced 1w ★★★★☆ ★★★☆☆
9. HDR & IBL Intermediate 8h ★★★☆☆ ★★★★★
10. Cook-Torrance BRDF Advanced 1w ★★★★★ ★★★★☆
11. Multi-Importance (MIS) Expert 2w ★★★★★ ★★★★☆
12. Fog / Volumetrics Advanced 1w ★★★★☆ ★★★★★
13. Subsurface (SSS) Expert 2w ★★★★★ ★★★★★
14. Disney Principled Advanced 1w ★★★★☆ ★★★★★
15. Wavefront GPU Master 4w ★★★★★ ★★★★★

Recommendation

If you are new to Graphics: Start strictly at Project 1 and follow the “Ray Tracing in One Weekend” sequence. Computer graphics is a “stack” of knowledge; if you don’t understand vectors, you will fail at BRDFs.

If you already have a basic Ray Tracer: Jump to Project 7 (Path Tracing). This is the transition from “Legacy” graphics to “Modern” PBR. It is the single most important conceptual leap you will make.

If you want a Job in the Industry: Focus on Project 10 (Cook-Torrance) and Project 14 (Disney Principled). Most professional graphics work involves implementing or optimizing these specific material models.

Final Overall Project: The “Toy Story” Renderer

The Goal: Build a fully featured, GPU-accelerated (or high-performance CPU) path tracer that can render a complex scene (like a room with 1 million polygons, HDR lighting, and characters with skin/hair) using the Disney Principled BRDF.

What you’ll build:

  • A scene parser (JSON or USD) to load complex geometry.
  • A BVH that handles 1M+ triangles.
  • A path tracer with MIS and Russian Roulette.
  • The full Disney Principled BRDF suite.
  • An HDR environment lighting system.
  • Volumetric fog for atmospheric depth.
  • A basic denoiser (using a library like Open Image Denoise).

Success Criteria: You can produce a 4K image of a complex 3D model (like the Stanford Dragon or a Pixar-style character) that looks indistinguishable from a professional render in a reasonable amount of time (under 5 minutes).

Summary

This learning path covers Physically Based Rendering through 15 hands-on projects. Here’s the complete list:

# Project Name Main Language Difficulty Time Estimate
1 Ray-Sphere Intersector C++ Beginner 4 hours
2 Normals & Lambertian C++ Beginner 4 hours
3 Anti-Aliasing C++ Beginner 6 hours
4 Metal & Glass C++ Intermediate 8 hours
5 Positionable Camera C++ Intermediate 6 hours
6 Monte Carlo Pi C++ Beginner 2 hours
7 First Path Tracer C++ Advanced 1-2 weeks
8 BVH Optimization C++ Advanced 1 week
9 HDR & IBL C++ Intermediate 8 hours
10 Cook-Torrance BRDF C++ Advanced 1 week
11 Multi-Importance (MIS) C++ Expert 1-2 weeks
12 Fog / Volumetrics C++ Advanced 1 week
13 Subsurface (SSS) C++ Expert 2 weeks
14 Disney Principled C++ Advanced 1 week
15 Wavefront GPU CUDA Master 1 month

For beginners: Start with projects #1, #2, #3, #4, #5, #6. For intermediate: Focus on projects #7, #8, #9. For advanced: Master projects #10, #11, #12, #13, #14, #15.

Expected Outcomes

After completing these projects, you will:

  • Understand the physics of light transport (The Rendering Equation).
  • Be able to implement complex BRDFs (Cook-Torrance, Disney Principled).
  • Master Monte Carlo integration and variance reduction techniques.
  • Build high-performance spatial data structures (BVH).
  • Understand how modern GPU renderers (Cycles, Octane, Arnold) work from first principles.

You’ll have built a production-grade renderer that demonstrates deep understanding of light and matter from first principles.