Physically Based Rendering: From Theory to Implementation / Edition 1

Hardcover (Print)
Buy New
Buy New from BN.com
$94.17
Used and New from Other Sellers
Used and New from Other Sellers
from $6.92
Usually ships in 1-2 business days
(Save 93%)
Other sellers (Hardcover)
  • All (6) from $6.92   
  • New (2) from $23.57   
  • Used (4) from $6.92   

Overview

Rendering is a crucial component of computer graphics- the conversion of a description of a 3D scene into an image for display. Algorithms for animation, geometric modeling, and texturing all must feed their results through some sort of rendering process for the results to be visible in an image. Focusing on realistic images, physically based rendering incorporates ideas from a range of disciplines, including physics, biology, psychology, cognitive science, and mathematics. This book presents the algorithms of modern photorealistic rendering and follows step by step the creation of a complete rendering system. As each new rendering concept is introduced it is also shown implemented in code-there is no better way to understand the subtle and complex process of rendering. The code itself is highly readable, written in the literate programming style that mixes text describing the system with the code that implements it. The result is a stunning achievement in graphics education for students, professionals, and researchers.

*CD-ROM with the source code for a complete rendering system for Windows, OS X, & Linux-with many examples of images created by the system throughout the 4 color text
*The code and text are tightly woven together through the technique of literate programming with a unique indexing feature that lists all locations of functions, variables, and methods on the page they are first described
*The most complete guide to understanding, designing, and building a rendering system

Read More Show Less

Editorial Reviews

From the Publisher
"I think this book is great. It's state-of-the-art, and covers the area from soup to nuts and with more depth than any other book I know." —Eric Haines, Autodesk Inc.
Read More Show Less

Product Details

Meet the Author

Matt Pharr is works as an engineer for Neoptica, a San Francisco start-up, where he works on interactive graphics. Previously, he was a member of the technical staff at NVIDIA and was a co-founder of Exluna, where he developed off-line rendering software and investigated applications of graphics hardware to high-quality rendering. He holds a BS degree from Yale University and a PhD from the Stanford Graphics Laboratory under the supervision of Pat Hanrahan, where he researched both theoretical and systems issues related to rendering and has written a series of SIGGRAPH papers on these topics.

Greg Humphreys is an assistant professor of Computer Science at the University of Virginia, where his research focuses on interactive visualization of very large datasets. Greg has a B.S. degree from Princeton University and a Ph.D. in Computer Science from Stanford University under the supervision of Pat Hanrahan. His doctoral dissertation "A Stream Processing Approach to Interactive Graphics on Clusters of Workstations" showed that it was possible to build scalable interactive graphics systems using only commodity components. His cluster rendering software called "Chromium" is in widespread use in research and industry labs around the world.

Read More Show Less

Read an Excerpt

Physically Based Rendering

FROM THEORY TO IMPLEMENTATION
By MATT PHARR GREG HUMPHREYS

Morgan Kaufmann

Copyright © 2010 Elsevier Inc.
All right reserved.

ISBN: 978-0-12-378580-0


Chapter One

01 INTRODUCTION

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, pbrt.org/downloads.php.

1.1 LITERATE PROGRAMMING

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.

1.1.1 INDEXING AND CROSS-REFERENCING

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.

1.2 PHOTOREALISTIC RENDERING AND THE RAY-TRACING ALGORITHM

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.

(Continues...)



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 Show Less

Table of Contents

Geometry and transformations; Primitives & intersection acceleration; Camera models; Sampling and reconstruction; Film and the imaging pipeline; Reflection models; Materials; Texture; Volume scattering; Light sources; Monte Carlo Integration I & II: Improving efficiency; Light Transport I & II: Volume rendering; Summary and conclusion; Appendices, Index
Read More Show Less

Customer Reviews

Be the first to write a review
( 0 )
Rating Distribution

5 Star

(0)

4 Star

(0)

3 Star

(0)

2 Star

(0)

1 Star

(0)

Your Rating:

Your Name: Create a Pen Name or

Barnes & Noble.com Review Rules

Our reader reviews allow you to share your comments on titles you liked, or didn't, with others. By submitting an online review, you are representing to Barnes & Noble.com that all information contained in your review is original and accurate in all respects, and that the submission of such content by you and the posting of such content by Barnes & Noble.com does not and will not violate the rights of any third party. Please follow the rules below to help ensure that your review can be posted.

Reviews by Our Customers Under the Age of 13

We highly value and respect everyone's opinion concerning the titles we offer. However, we cannot allow persons under the age of 13 to have accounts at BN.com or to post customer reviews. Please see our Terms of Use for more details.

What to exclude from your review:

Please do not write about reviews, commentary, or information posted on the product page. If you see any errors in the information on the product page, please send us an email.

Reviews should not contain any of the following:

  • - HTML tags, profanity, obscenities, vulgarities, or comments that defame anyone
  • - Time-sensitive information such as tour dates, signings, lectures, etc.
  • - Single-word reviews. Other people will read your review to discover why you liked or didn't like the title. Be descriptive.
  • - Comments focusing on the author or that may ruin the ending for others
  • - Phone numbers, addresses, URLs
  • - Pricing and availability information or alternative ordering information
  • - Advertisements or commercial solicitation

Reminder:

  • - By submitting a review, you grant to Barnes & Noble.com and its sublicensees the royalty-free, perpetual, irrevocable right and license to use the review in accordance with the Barnes & Noble.com Terms of Use.
  • - Barnes & Noble.com reserves the right not to post any review -- particularly those that do not follow the terms and conditions of these Rules. Barnes & Noble.com also reserves the right to remove any review at any time without notice.
  • - See Terms of Use for other conditions and disclaimers.
Search for Products You'd Like to Recommend

Recommend other products that relate to your review. Just search for them below and share!

Create a Pen Name

Your Pen Name is your unique identity on BN.com. It will appear on the reviews you write and other website activities. Your Pen Name cannot be edited, changed or deleted once submitted.

 
Your Pen Name can be any combination of alphanumeric characters (plus - and _), and must be at least two characters long.

Continue Anonymously

    If you find inappropriate content, please report it to Barnes & Noble
    Why is this product inappropriate?
    Comments (optional)