3D graphics eBook - Course Materials Repository

Path tracing 98
History
Further information: Rendering, Chronology of important published ideas
The rendering equation and its use in computer graphics was presented by James Kajiya in 1986. kajiya1986rendering
This presentation contained what was probably the first description of the path tracing algorithm. A decade later,
Lafortune suggested many refinements, including bidirectional path tracing. lafortune1996mathematical
Metropolis light transport, a method of perturbing previously found paths in order to increase performance for
difficult scenes, was introduced in 1997 by Eric Veach and Leonidas J. Guibas.
More recently, CPUs and GPUs have become powerful enough to render images more quickly, causing more
widespread interest in path tracing algorithms. Tim Purcell first presented a global illumination algorithm running on
a GPU in 2002. purcell2002ray In February 2009 Austin Robison of Nvidia demonstrated the first commercial
implementation of a path tracer running on a GPU robisonNVIRT , and other implementations have followed, such as
that of Vladimir Koylazov in August 2009. pathGPUimplementations This was aided by the maturing of GPGPU
programming toolkits such as CUDA and OpenCL and GPU ray tracing SDKs such as OptiX.
Description
In the real world, many small amounts of light are emitted from light sources, and travel in straight lines (rays) from
object to object, changing colour and intensity, until they are absorbed (possibly by an eye or camera). This process
is simulated by path tracing, except that the paths are traced backwards, from the camera to the light. The
inefficiency arises in the random nature of the bounces from many surfaces, as it is usually quite unlikely that a path
will intersect a light. As a result, most traced paths do not contribute to the final image.
This behaviour is described mathematically by the rendering equation, which is the equation that path tracing
algorithms try to solve.
Path tracing is not simply ray tracing with infinite recursion depth. In conventional ray tracing, lights are sampled
directly when a diffuse surface is hit by a ray. In path tracing, a new ray is randomly generated within the
hemisphere of the object and then traced until it hits a light — possibly never. This type of path can hit many diffuse
surfaces before interacting with a light.
A simple path tracing pseudocode might look something like this:
Color TracePath(Ray r,depth) {
if(depth == MaxDepth)
return Black; // bounced enough times
r.FindNearestObject();
if(r.hitSomething == false)
return Black; // nothing was hit
Material m = r.thingHit->material;
Color emittance = m.emittance;
// pick a random direction from here and keep going
Ray newRay;
newRay.origin = r.pointWhereObjWasHit;
newRay.direction = RandomUnitVectorInHemisphereOf(r.normalWhereObjWasHit);
float cos_omega = DotProduct(newRay.direction, r.normalWhereObjWasHit);
Color BDRF = m.reflectance*cos_omega;