https://github.com/mmp/pbrt-v3
Source code for pbrt, the renderer described in the third edition of "Physically Based Rendering: From Theory To Implementation", by Matt Pharr, Wenzel Jakob, and Greg Humphreys.
https://github.com/mmp/pbrt-v3
Last synced: 11 days ago
JSON representation
Source code for pbrt, the renderer described in the third edition of "Physically Based Rendering: From Theory To Implementation", by Matt Pharr, Wenzel Jakob, and Greg Humphreys.
- Host: GitHub
- URL: https://github.com/mmp/pbrt-v3
- Owner: mmp
- License: bsd-2-clause
- Created: 2015-06-15T18:13:08.000Z (almost 10 years ago)
- Default Branch: master
- Last Pushed: 2023-09-03T11:38:00.000Z (over 1 year ago)
- Last Synced: 2025-04-19T09:22:09.957Z (about 1 month ago)
- Language: C++
- Homepage: http://pbrt.org
- Size: 5.46 MB
- Stars: 4,988
- Watchers: 252
- Forks: 1,207
- Open Issues: 57
-
Metadata Files:
- Readme: README.md
- License: LICENSE.txt
Awesome Lists containing this project
- AwesomeCppGameDev - pbrt-v3
README
pbrt, Version 3
===============
[](https://travis-ci.org/mmp/pbrt-v3)
[](https://ci.appveyor.com/project/mmp/pbrt-v3/branch/master)
This repository holds the source code to the version of pbrt that is
described in the third edition of *Physically Based Rendering: From
Theory to Implementation*, by [Matt Pharr](http://pharr.org/matt), [Wenzel
Jakob](http://www.mitsuba-renderer.org/~wenzel/), and Greg Humphreys. As
before, the code is available under the BSD license.
The [pbrt website](http://pbrt.org) has general information about both the
*Physically Based Rendering* book as well as many other resources for pbrt.
As of October 2018, the full [text of the book](http://www.pbr-book.org) is
now available online, for free.
Example scenes
--------------
Over 8GB of example scenes are available for download. (Many are new and
weren't available with previous versions of pbrt.) See the [pbrt-v3 scenes
page](http://pbrt.org/scenes-v3.html) on the pbrt website for information
about how to download them.
After downloading them, see the `README.md.html` file in the scene
distribution for more information about the scenes and preview images.
Additional resources
--------------------
* There is a [pbrt Google
Groups](https://groups.google.com/forum/#!forum/pbrt) mailing list that can
be a helpful resource.
* Please see the [User's Guide](http://pbrt.org/users-guide.html) for more
information about how to check out and build the system as well as various
additional information about working with pbrt.
* Should you find a bug in pbrt, please report it in the [bug
tracker](https://github.com/mmp/pbrt-v3/issues).
* Please report any errors you find in the *Physically Based Rendering*
book to [email protected].
Note: we tend to let bug reports and book errata emails pile up for a few
months for processing them in batches. Don't think we don't appreciate
them. :-)
Building pbrt
-------------
To check out pbrt together with all dependencies, be sure to use the
`--recursive` flag when cloning the repository, i.e.
```bash
$ git clone --recursive https://github.com/mmp/pbrt-v3/
```
If you accidentally already cloned pbrt without this flag (or to update an
pbrt source tree after a new submodule has been added, run the following
command to also fetch the dependencies:
```bash
$ git submodule update --init --recursive
```
pbrt uses [cmake](http://www.cmake.org/) for its build system. On Linux
and OS X, cmake is available via most package management systems. To get
cmake for Windows, or to build it from source, see the [cmake downloads
page](http://www.cmake.org/download/). Once you have cmake, the next step
depends on your operating system.
### Makefile builds (Linux, other Unixes, and Mac) ###
Create a new directory for the build, change to that directory, and run
`cmake [path to pbrt-v3]`. A Makefile will be created in the current
directory. Next, run `make` to build pbrt, the obj2pbrt and imgtool
utilities, and an executable that runs pbrt's unit tests. Depending on the
number of cores in your system, you will probably want to supply make with
the `-j` parameter to specify the number of compilation jobs to run in
parallel (e.g. `make -j8`).
By default, the makefiles that are created that will compile an optimized
release build of pbrt. These builds give the highest performance when
rendering, but many runtime checks are disabled in these builds and
optimized builds are generally difficult to trace in a debugger.
To build a debug version of pbrt, set the `CMAKE_BUILD_TYPE` flag to
`Debug` when you run cmake to create build files to make a debug build. To
do so, provide cmake with the argument `-DCMAKE_BUILD_TYPE=Debug` and build
pbrt using the resulting makefiles. (You may want to keep two build
directories, one for release builds and one for debug builds, so that you
don't need to switch back and forth.)
Debug versions of the system run much more slowly than release
builds. Therefore, in order to avoid surprisingly slow renders when
debugging support isn't desired, debug versions of pbrt print a banner
message indicating that they were built for debugging at startup time.
### Xcode ###
To make an Xcode project on OS X, run `cmake -G Xcode [path to pbrt-v3]`.
A `PBRT-V3.xcodeproj` project file that can be opened in Xcode. Note that
the default build settings have an optimization level of "None"; you'll
almost certainly want to choose "Faster" or "Fastest".
### MSVC on Windows ###
On Windows, first point the cmake GUI at the directory with pbrt's source
code. Create a separate directory to hold the result of the build
(potentially just a directory named "build" inside the pbrt-v3 directory)
and set that for "Where to build the binaries" in the GUI.
Next, click "Configure". Note that you will want to choose the "Win64"
generator for your MSVC installation unless you have a clear reason to need
a 32-bit build of pbrt. Once cmake has finished the configuration step,
click "Generate"; when that's done, there will be a "PBRT-V3.sln" file in
the build directory you specified. Open that up in MSVC and you're ready to
go.
### Build Configurations ###
There are two configuration settings that must be set when configuring the
build. The first controls whether pbrt uses 32-bit or 64-bit values for
floating-point computation, and the second controls whether tristimulus RGB
values or sampled spectral values are used for rendering. (Both of these
aren't amenable to being chosen at runtime, but must be determined at
compile time for efficiency). The cmake configuration variables
`PBRT_FLOAT_AS_DOUBLE` and `PBRT_SAMPLED_SPECTRUM` configure them,
respectively.
If you're using a GUI version of cmake, those settings should be available
in the list of configuration variables; set them as desired before choosing
'Generate'.
With command-line cmake, their values can be specified when you cmake via
`-DPBRT_FLOAT_AS_DOUBLE=1`, for example.