## 1.4 How to Proceed through This Book

We have written this book assuming it will be read in roughly front-to-back order. We have tried to minimize the number of forward references to ideas and interfaces that have not yet been introduced, but we do assume that the reader is acquainted with the previous content at any particular point in the text. Some sections go into depth about advanced topics that some readers may wish to skip over, particularly on first reading; each advanced section is identified by an asterisk in its title.

Because of the modular nature of the system, the main requirements are that
the reader be familiar with the low-level classes like `Point3f`,
`Ray`, and `SampledSpectrum`; the interfaces defined by the
abstract base classes listed in Table 1.1; and the
rendering loop that culminates in calls to integrators’
`RayIntegrator::Li()` methods. Given that knowledge, for example, the
reader who does not care about precisely how a camera model based on a
perspective projection matrix maps `CameraSample`s to rays can skip
over the implementation of that camera and can just remember that the
`Camera::GenerateRayDifferential()` method somehow turns a
`CameraSample` into a `RayDifferential`.

The remainder of this book is divided into four main parts of a few
chapters each. First, Chapters 2 through 4
introduce the foundations of the system.
A brief introduction to the key ideas underlying Monte Carlo integration is
provided in Chapter 2, and
Chapter 3 then describes
widely used geometric classes like `Point3f`, `Ray`, and
`Bounds3f`.
Chapter 4 introduces the physical units used to
measure light and the `SampledSpectrum` class that `pbrt` uses to
represent spectral distributions. It also discusses color, the human
perception of spectra, which affects how input is provided to the renderer
and how it generates output.

The second part of the book covers image formation and how the scene
geometry is represented. Chapter 5 defines the
`Camera` interface and a few different camera implementations
before discussing the overall process of turning spectral radiance arriving
at the film into images.
Chapter 6 then introduces the `Shape` interface and gives
implementations of a number of shapes, including showing how to perform ray
intersection tests with them. Chapter 7 describes the implementations
of the acceleration structures that make ray tracing more efficient by skipping
tests with primitives that a ray can be shown to definitely not intersect.
Finally, Chapter 8’s topic is the `Sampler`
classes that place samples on the image plane
and provide random samples for Monte Carlo integration.

The third part of the book is about light and how it scatters from surfaces and participating media. Chapter 9 includes a collection of classes that define a variety of types of reflection from surfaces. Materials, described in Chapter 10, use these reflection functions to implement a number of different surface types, such as plastic, glass, and metal. Spatial variation in material properties (color, roughness, etc.) is modeled by textures, which are also described in Chapter 10. Chapter 11 introduces the abstractions that describe how light is scattered and absorbed in participating media, and Chapter 12 then describes the interface for light sources and a variety of light source implementations.

The last part brings all the ideas from the rest of the book together to
implement a number of interesting light transport algorithms. The
integrators in
Chapters 13 and 14
represent a
variety of different applications of Monte Carlo integration to compute
more accurate approximations of the light transport equation than the
`RandomWalkIntegrator`.
Chapter 15 then describes the implementation of a
high-performance integrator that runs on the GPU, based on all the same classes
that are used in the implementations of the CPU-based integrators.

Chapter 16, the last chapter of the book, provides a brief retrospective and discussion of system design decisions along with a number of suggestions for more far-reaching projects than those in the exercises. Appendices contain more Monte Carlo sampling algorithms, describe utility functions, and explain details of how the scene description is created as the input file is parsed.

### 1.4.1 The Exercises

At the end of each chapter you will find exercises related to the material covered in that chapter. Each exercise is marked as one of three levels of difficulty:

- ① An exercise that should take only an hour or two
- ② A reading and/or implementation task that would be suitable for a course assignment and should take between 10 and 20 hours of work
- ③ A suggested final project for a course that will likely take 40 hours or more to complete

### 1.4.2 Viewing the Images

Figures throughout the book compare the results of rendering the same scene using different algorithms. As with previous editions of the book, we have done our best to ensure that these differences are evident on the printed page, though even high quality printing cannot match modern display technology, especially now with the widespread availability of high dynamic range displays.

We have therefore made all of the rendered images that are used in figures available online. For example, the first image shown in this chapter as Figure 1.1 is available at the URL pbr-book.org/4ed/fig/1.1. All of the others follow the same naming scheme.

### 1.4.3 The Online Edition

Starting on November 1, 2023, the full contents of this book will be freely available online at pbr-book.org/4ed. (The previous edition of the book is already available at that website.)

The online edition includes additional content that could not be included in the printed book due to page constraints. All of that material is supplementary to the contents of this book. For example, it includes the implementation of an additional camera model, a kd-tree acceleration structure, and a full chapter on bidirectional light transport algorithms. (Almost all of the additional material appeared in the previous edition of the book.)