Physically Based Rendering: From Theory To Implementation

Physically Based Rendering: From Theory To Implementation

by Matt Pharr, Greg Humphreys

View All Available Formats & Editions

Physically Based Rendering, Second Edition describes both the mathematical theory behind a modern photorealistic rendering system as well as its practical implementation. A method known as "literate programming" combines human-readable documentation and source code into a single reference that is specifically designed to aid comprehension. The result is a

See more details below


Physically Based Rendering, Second Edition describes both the mathematical theory behind a modern photorealistic rendering system as well as its practical implementation. A method known as "literate programming" combines human-readable documentation and source code into a single reference that is specifically designed to aid comprehension. The result is a stunning achievement in graphics education. Through the ideas and software in this book, you will learn to design and employ a full-featured rendering system for creating stunning imagery.

This new edition greatly refines its best-selling predecessor by streamlining all obsolete code as well as adding sections on parallel rendering and system design; animating transformations; multispectral rendering; realistic lens systems; blue noise and adaptive sampling patterns and reconstruction; measured BRDFs; and instant global illumination, as well as subsurface and multiple-scattering integrators. These updates reflect the current state-of-the-art technology, and along with the lucid pairing of text and code, ensure the book's leading position as a reference text for those working with images, whether it is for film, video, photography, digital design, visualization, or gaming.

The author team of Matt Pharr, Greg Humphreys, and Pat Hanrahan garnered a 2014 Academy Award for Scientific and Technical Achievement from the Academy of Motion Picture Arts and Sciences based on the knowlege shared in this book.The Academy called the book a "widely adopted practical roadmap for most physically based shading and lighting systems used in film production."

  • The book that won its authors a 2014 Academy Award for Scientific and Technical Achievement from the Academy of Motion Picture Arts and Sciences
  • New sections on subsurface scattering, Metropolis light transport, precomputed light transport, multispectral rendering, and much more
  • Includes a companion site complete with source code for the rendering system described in the book, with support for Windows, OS X, and Linux: visit
  • Code and text are tightly woven together through a unique indexing feature that lists each function, variable, and method on the page that they are first described

Read More

Editorial Reviews

From the Publisher
"Physically Based Rendering is a terrific book. It covers all the marvelous math, fascinating physics, practical software engineering, and clever tricks that are necessary to write a state-of-the-art photorealistic renderer. All of these topics are dealt with in a clear and pedagogical manner without omitting the all-important practical details."—Per Christensen Senior Software Developer, RenderMan Products Pixar Animation Studios

"Intended for graduate or advanced undergraduate students in a computer graphics course, this large volume provides a comprehensive examination of complex rendering algorithms and demonstrates, through detailed examination of source code and example projects, the practical development and application of cutting edge image creation and processing software. This second edition is updated to reflect current technologies and contains updated information on relevant recent hardware improvements such as advanced multi-core processors as well as an increased focus on production graphics techniques. The text includes numerous illustrations, code examples, and formulas as well as recommendations for further reading and chapter exercises. Pharr is a principle engineer for Intel and Humphreys is an engineer for NVIDIA and a former professor of computer science at the University of Virginia."—SciTech Book News

"Pharr and Humphreys’ textbook is beautifully typeset, thoroughly indexed, unendingly cross-referenced, extensively illustrated, and printed in full color. Given its unconventional preparation style, this textbook stands out because of its descriptions of the tradeoffs involved in developing a complete working renderer. Although somewhat verbose at times, the discussions of design tradeoffs and performance considerations are an excellent complement to the more traditional coverage of the theory behind photorealistic rendering. C++ idioms sometimes get in the way of more elegant solutions, but their use is always reasonably justified. If you are just looking for a general introduction to image synthesis and rendering, standard graphics textbooks [2] might fit the bill; however, if you intend to develop your own renderer or try out new ideas, this textbook provides an excellent starting point."—Computing

Read More

Product Details

Elsevier Science
Publication date:
Sold by:
Barnes & Noble
File size:
31 MB
This product may take a few minutes to download.

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.

Read More

Customer Reviews

Average Review:

Write a Review

and post it to your social network


Most Helpful Customer Reviews

See all customer reviews >