Pub. Date:
Elsevier Science
Physically Based Rendering: From Theory to Implementation / Edition 3

Physically Based Rendering: From Theory to Implementation / Edition 3


View All Available Formats & Editions
Current price is , Original price is $109.95. You
Select a Purchase Option (New Edition)
  • purchase options
    $92.35 $109.95 Save 16% Current price is $92.35, Original price is $109.95. You Save 16%.
  • purchase options

Product Details

ISBN-13: 9780128006450
Publisher: Elsevier Science
Publication date: 11/25/2016
Edition description: New Edition
Pages: 1266
Product dimensions: 7.80(w) x 9.40(h) x 2.30(d)

About the Author

Matt Pharr is a Software Engineer at Google. He previously co-founded Neoptica, which was acquired by Intel, and co-founded Exluna, which was acquired by NVIDIA. He has a B.S. degree from Yale and a Ph.D. from the Stanford Graphics Lab, where he worked under the supervision of Pat Hanrahan.

Wenzel Jakob is an assistant professor at EPFL's School of Computer and Communication Sciences. His research interests revolve around material appearance modeling, rendering algorithms, and the high-dimensional geometry of light paths. Wenzel obtained his Ph.D. at Cornell University under the supervision of Steve Marschner, after which he joined ETH Zürich for postdoctoral studies under the supervision of Olga Sorkine Hornung. Wenzel is also the lead developer of the Mitsuba renderer, a research-oriented rendering system.

Greg Humphreys is Director of Engineering at FanDuel, having previously worked on the Chrome graphics team at Google and the OptiX GPU raytracing engine at NVIDIA. Before that, he was a professor of Computer Science at the University of Virginia, where he conducted research in both high performance and physically based computer graphics, as well as computer architecture and visualization. Greg has a B.S.E. degree from Princeton, and a Ph.D. in Computer Science from Stanford under the supervision of Pat Hanrahan. When he's not tracing rays, Greg can usually be found playing tournament bridge.

Read an Excerpt

Physically Based Rendering


Morgan Kaufmann

Copyright © 2010 Elsevier Inc.
All right reserved.

ISBN: 978-0-12-378580-0

Chapter One


Rendering is the process of producing a 2D image from a description of a 3D scene. Obviously, this is a very broad task, and there are many ways to approach it. Physically based techniques attempt to simulate reality; that is, they use principles of physics to model the interaction of light and matter. In physically based rendering, realism is usually the primary goal. This approach is in contrast to interactive rendering, which sacrifices realism for high performance and low latency, or nonphotorealistic rendering, which strives for artistic freedom and expressiveness.

This book describes pbrt, a physically based rendering system based on the ray-tracing algorithm. Most computer graphics books present algorithms and theory, sometimes combined with snippets of code. In contrast, this book couples the theory with a complete implementation of a fully functional rendering system. The source code to the system (as well as example scenes and a collection of data for rendering) can be found from the pbrt Web site's downloads page,


While writing the TEX typesetting system, Donald Knuth developed a new programming methodology based on the simple but revolutionary idea that programs should be written more for people's consumption than for computers' consumption. He named this methodology literate programming. This book (including the chapter you're reading now) is a long literate program. This means that in the course of reading this book, you will read the full implementation of the pbrt rendering system, not just a high-level description of it.

Literate programs are written in a metalanguage that mixes a document formatting language (e.g., TEX or HTML) and a programming language (e.g., C++). Two separate systems process the program: a "weaver" that transforms the literate program into a document suitable for typesetting, and a "tangler" that produces source code suitable for compilation. Our literate programming system is homegrown, but it was heavily influenced by Norman Ramsey's noweb system.

The literate programming metalanguage provides two important features. The first is the ability to mix prose with source code. This feature makes the description of the program just as important as its actual source code, encouraging careful design and documentation. Second, the language provides mechanisms for presenting the program code to the reader in an entirely different order than it is supplied to the compiler. Thus, the program can be described in a logical manner. Each named block of code is called a fragment, and each fragment can refer to other fragments by name.

As a simple example, consider a function InitGlobals() that is responsible for initializing all of a program's global variables:

void InitGlobals(void) { num_marbles = 25.7; shoe_size = 13; dielectric = true; my_senator = REPUBLICAN; }

Despite its brevity, this function is hard to understand without any context. Why, for example, can the variable num_marbles take on floating-point values? Just looking at the code, one would need to search through the entire program to see where each variable is declared and how it is used in order to understand its purpose and the meanings of its legal values. Although this structuring of the system is fine for a compiler, a human reader would much rather see the initialization code for each variable presented separately, near the code that actually declares and uses the variable.

In a literate program, one can instead write InitGlobals() like this:

<Function Definitions> [equivalent] void InitGlobals() { <Initialize Global Variables 2>

This defines a fragment, called <Function Definitions>, that contains the definition of the InitGlobals() function. The InitGlobals() function itself refers to another fragment, <Initialize Global Variables>. Because the initialization fragment has not yet been defined, we don't know anything about this function except that it will contain assignments to global variables. This is just the right level of abstraction for now, since no variables have been declared yet. When we introduce the global variable shoe_size somewhere later in the program, we can then write

<Initialize Global Variables> [equivalent] shoe_size = 13;

Here we have started to define the contents of <Initialize Global Variables>. When the literate program is tangled into source code for compilation, the literate programming system will substitute the code shoe_size = 13; inside the definition of the InitGlobals() function. Later in the text, we may define another global variable, dielectric, and we can append its initialization to the fragment:

<Initialize Global Variables> +[equivalent] dielectric = true;

The +[equivalent] symbol after the fragment name shows that we have added to a previously defined fragment. When tangled, the result of these three fragments is the code

void InitGlobals() { shoe_size = 13; dielectric = true; }

In this way, we can decompose complex functions into logically distinct parts, making them much easier to understand. For example, we can write a complicated function as a series of fragments:

<Function Definitions> +[equivalent] void complex_func(int x, int y, double *data) { <Check validity of arguments> f (x < y) { <Swap parameter values> } <Do precomputation before loop> <Loop through and update data array>


Again, the contents of each fragment are expanded inline in complex_func() for compilation. In the document, we can introduce each fragment and its implementation in turn. This decomposition lets us present code a few lines at a time, making it easier to understand. Another advantage of this style of programming is that by separating the function into logical fragments, each with a single and well-delineated purpose, each one can then be written and verified independently. In general, we will try to make each fragment less than 10 lines long.

In some sense, the literate programming system is just an enhanced macro substitution package tuned to the task of rearranging program source code. This may seem like a trivial change, but in fact literate programming is quite different from other ways of structuring software systems.


The following features are designed to make the text easier to navigate. Indices in the page margins give page numbers where the functions, variables, and methods used on that page are defined. Indices at the end of the book collect all of these identifiers so that it's possible to find definitions by name. Appendix C, "Index of Fragments," lists the pages where each fragment is defined and the pages where it is used. Within the text, a defined fragment name is followed by a list of page numbers on which that fragment is used. For example, a hypothetical fragment definition such as

<A fascinating fragment> [equivalent] 184, 690 num_marbles += .001;

indicates that this fragment is used on pages 184 and 690. If the fragments that use this fragment are not included in the book text, no page numbers will be listed. When a fragment is used inside another fragment, the page number on which it is first defined appears after the fragment name. For example,

<Do something interesting> + [equivalent] InitializeSomethingInteresting(); <Do something else interesting 486> CleanUp();

indicates that the <Do something else interesting> fragment is defined on page 486. If the definition of the fragment is not included in the book, no page number will be listed.


The goal of photorealistic rendering is to create an image of a 3D scene that is indistinguishable from a photograph of the same scene. Before we describe the rendering process, it is important to understand that in this context the word "indistinguishable" is imprecise because it involves a human observer, and different observers may perceive the same image differently. Although we will cover a few perceptual issues in this book, accounting for the precise characteristics of a given observer is a very difficult and largely unsolved problem. For the most part, we will be satisfied with an accurate simulation of the physics of light and its interaction with matter, relying on our understanding of display technology to present a good image to the viewer.

Most photorealistic rendering systems are based on the ray-tracing algorithm. Ray tracing is actually a very simple algorithm; it is based on following the path of a ray of light through a scene as it interacts with and bounces off objects in an environment. Although there are many ways to write a ray tracer, all such systems simulate at least the following objects and phenomena:

Cameras: How and from where is the scene being viewed? Cameras generate rays from the viewing point into the scene.

Ray-object intersections: We must be able to tell precisely where a given ray pierces a geometric object. In addition, we need to determine certain geometric properties of the object at the intersection point, such as a surface normal or its material. Most ray tracers also have some facility for finding the intersection of a ray with multiple objects, typically returning the closest intersection along the ray.

Light distribution: Without lighting, there would be little point in rendering a scene. A ray tracer must model the distribution of light throughout the scene, including not only the locations of the lights themselves, but also the way in which they distribute their energy throughout space.

Visibility: In order to know whether a given light deposits energy at a point on a surface, we must know whether there is an uninterrupted path from the point to the light source. Fortunately, this question is easy to answer in a ray tracer, since we can just construct the ray from the surface to the light, find the closest ray-object intersection, and compare the intersection distance to the light distance.

Surface scattering: Each object must provide a description of its appearance, including information about how light interacts with the object's surface, as well as the nature of the reradiated (or scattered) light. We are usually interested in the properties of the light that is scattered directly toward the camera. Models for surface scattering are typically parameterized so that they can simulate a variety of appearances.

Recursive ray tracing: Because light can arrive at a surface after bouncing off or passing through several other surfaces, it is usually necessary to trace additional rays originating at the surface to fully capture this effect. This is particularly important for shiny surfaces like metal or glass.

Ray propagation: We need to know what happens to the light traveling along a ray as it passes through space. If we are rendering a scene in a vacuum, light energy remains constant along a ray. Although most human observers have never been in a vacuum, this is the typical assumption made by most ray tracers. More sophisticated models are available for tracing rays through fog, smoke, the Earth's atmosphere, and so on.


Excerpted from Physically Based Rendering by MATT PHARR GREG HUMPHREYS Copyright © 2010 by Elsevier Inc. . Excerpted by permission of Morgan Kaufmann. All rights reserved. No part of this excerpt may be reproduced or reprinted without permission in writing from the publisher.
Excerpts are provided by Dial-A-Book Inc. solely for the personal use of visitors to this web site.

Table of Contents

1. Introduction 2. Geometry and Transformations 3. Shapes 4. Primitives and Intersection Acceleration 5. Color and Radiometry 6. Camera Models 7. Sampling Reconstruction 8. Reflection Models 9. Materials 10. Texture 11. Volume Scattering 12. Light Sources 13. Monte Carlo Integration 14. Light Transport I: Surface Reflection 15. Light Transport II: Volume Rendering 16. Light Transport III: Bidirectional Methods 17: Retrospective and the Future

Customer Reviews

Most Helpful Customer Reviews

See All Customer Reviews