## Further Reading

*An Introduction to Ray Tracing* has an extensive survey of algorithms
for ray–shape intersection (Glassner 1989a). Goldstein and Nagel (1971) discussed ray–quadric intersections, and Heckbert (1984)
discussed the mathematics of quadrics for graphics applications in detail,
with many citations to literature in mathematics and other fields.
Hanrahan (1983) described a system that automates the process of deriving a
ray intersection routine for surfaces defined by implicit polynomials; his
system emits C source code to perform the intersection test and normal
computation for a surface described by a given equation. Mitchell (1990)
showed that interval arithmetic could be applied to develop algorithms for
robustly computing intersections with implicit surfaces that cannot be
described by polynomials and are thus more difficult to accurately compute
intersections for; more recent work in this area was done by Knoll et al. (2009). See Moore’s book (1966) for an introduction to interval
arithmetic.

Other notable early papers related to ray–shape intersection include Kajiya’s (1983) work on computing intersections with surfaces of revolution and procedurally generated fractal terrains. Fournier et al.’s (1982) paper on rendering procedural stochastic models and Hart et al.’s (1989) paper on finding intersections with fractals illustrate the broad range of shape representations that can be used with ray-tracing algorithms.

Kajiya (1982) developed the first algorithm for computing intersections with parametric patches. Subsequent work on more efficient techniques for direct ray intersection with patches includes papers by Stürzlinger (1998), Martin et al. (2000), and Roth et al. (2001). Benthin et al. (2004) presented more recent results and include additional references to previous work. Ramsey et al. (2004) describe an efficient algorithm for computing intersections with bilinear patches, and Ogaki and Tokuyoshi (2011) introduce a technique for directly intersecting smooth surfaces generated from triangle meshes with per-vertex normals.

An excellent introduction to differential geometry was written by Gray (1993); Section 14.3 of his book presents the Weingarten equations.

The ray–triangle intersection test in Section 3.6 was developed by Woop et al. (2013). See Möller and Trumbore (1997) for another widely used ray–triangle intersection algorithm. A ray–quadrilateral intersection routine was developed by Lagae and Dutré (2005). Shevtsov et al. (2007a) described a highly optimized ray–triangle intersection routine for modern CPU architectures and included a number of references to other recent approaches. An interesting approach for developing a fast ray–triangle intersection routine was introduced by Kensler and Shirley (2006): they implemented a program that performed a search across the space of mathematically equivalent ray–triangle tests, automatically generating software implementations of variations and then benchmarking them. In the end, they found a more efficient ray–triangle routine than had been in use previously.

Phong and Crow (1975) first introduced the idea of interpolating per-vertex shading normals to give the appearance of smooth surfaces from polygonal meshes.

The layout of triangle meshes in memory can have a measurable impact on performance in many situations. In general, if triangles that are close together in 3D space are close together in memory, cache hit rates will be higher, and overall system performance will benefit. See Yoon et al. (2005) and Yoon and Lindstrom (2006) for algorithms for creating cache-friendly mesh layouts in memory.

The curve intersection algorithm in Section 3.7 is based on the approach developed by Nakamaru and Ohno (2002). Earlier methods for computing ray intersections with generalized cylinders are also applicable to rendering curves, though they are much less efficient (Bronsvoort and Klok 1985; de Voogt et al. 2000). The book by Farin (2001) provides an excellent general introduction to splines, and the blossoming approach used in Section 3.7 was introduced by Ramshaw (1987).

One challenge with rendering thin geometry like hair and fur is that thin geometry may require many pixel samples to be accurately resolved, which in turn increases rendering time. van Swaaij (2006) described a system that precomputed voxel grids to represent hair and fur, storing aggregate information about multiple hairs in a small region of space for more efficient rendering. More recently, Qin et al. (2014) described an approach based on cone tracing for rendering fur, where narrow cones are traced instead of rays. In turn, all of the curves that intersect a cone can be considered in computing the cone’s contribution, allowing high-quality rendering with a small number of cones per pixel.

Subdivision surfaces were invented by Doo and Sabin (1978) and Catmull and Clark (1978). The Loop subdivision method was originally developed by
Charles Loop (1987), although the implementation in `pbrt` uses the
improved rules for subdivision and tangents along boundary edges developed
by Hoppe et al. (1994). There has been extensive subsequent work in subdivision
surfaces. The SIGGRAPH course notes give a good summary of the
state of the art in the year 2000 and also have extensive references (Zorin et al. 2000).
See also Warren’s book on the topic (Warren 2002). Müller et al. (2003) described an approach that refines a subdivision surface on
demand for the rays to be tested for intersection with it. (See also
Benthin et al. (2007) for a related approach.)

An exciting development in subdivision surfaces is the ability to evaluate them at arbitrary points on the surface (Stam 1998). Subdivision surface implementations like the one in this chapter are often relatively inefficient, spending as much time dereferencing pointers as they do applying subdivision rules. Stam’s approach avoids these inefficiencies. Bolz and Schröder (2002) suggest an improved implementation approach that precomputes a number of quantities that make it possible to compute the final mesh much more efficiently. More recently, Patney et al. (2009) have demonstrated a very efficient approach for tessellating subdivision surfaces on data-parallel throughput processors.

Higham’s (2002) book on floating-point computation is excellent; it also
develops the notation that we have used in
Section 3.9. Other good references to this topic are
Wilkinson (1994) and Goldberg (1991). While we have derived floating-point
error bounds manually, see the *Gappa* system by Daumas and Melquiond (2010) for a tool that automatically derives forward error bounds of
floating-point computations.

The incorrect self-intersection problem has been a known problem for
ray-tracing practitioners for quite some
time (Haines 1989; Amanatides and Mitchell 1990).
In addition to offsetting rays by
an “epsilon” at their origin, approaches that have been suggested include
ignoring intersections with the object that was previously intersected, “root
polishing” (Haines 1989; Woo et al. 1996), where the computed
intersection point is refined to become more numerically accurate; and
using higher precision floating-point representations (e.g., `double`
instead of `float`).

Kalra and Barr (1989) and Dammertz and Keller (2006) developed algorithms for numerically robust intersections based on recursively subdividing object bounding boxes, discarding boxes that don’t encompass the object’s surface, and discarding boxes missed by the ray. Both of these approaches are much less efficient than traditional ray–object intersection algorithms as well as the techniques introduced in Section 3.9.

Salesin et al. (1989) introduced techniques to derive robust primitive
operations for computational geometry that accounted for floating-point
round-off error, and Ize showed how to perform numerically robust
ray-bounding box intersections (Ize 2013); his approach is implemented in
Section 3.9.2. (With a more careful
derivation, he shows that a scale factor
of can actually be used to increase `tMax`, rather than
the we have derived here.) Wächter (2008) discussed
self-intersection issues in his thesis; he suggested recomputing the
intersection point starting from the initial intersection (root polishing)
and offsetting spawned rays along the normal by a fixed small fraction of
the intersection point’s magnitude. The approach implemented in this
chapter uses his approach of offsetting ray origins along the normal but
is based on conservative bounds on the offsets based on the numerical error
present in computed intersection points. (As it turns out, our bounds are
generally tighter than Wächter’s offsets while also being provably
conservative.)

### References

- Amanatides, J., and D. P. Mitchell. 1990.
Some regularization problems in ray tracing.
In
*Proceedings of Graphics Interface 1990*, 221–28. - Benthin, C., I. Wald, and P. Slusallek. 2004.
Techniques for interactive ray tracing of Bézier surfaces.
*Journal of Graphics, GPU, and Game Tools**11*(2), 1–16. - Benthin, C., S. Boulos, D. Lacewell, and I. Wald. 2007.
Packet-based ray tracing of Catmull–Clark subdivision surfaces.
*SCI Institute Technical Report, No. UUSCI-2007-011*. University of Utah. - Blinn, J. F. 1982a.
A generalization of algebraic surface drawing.
*ACM Transactions on Graphics**1*(3), 235–56. - Bolz, J., and P. Schröder. 2002.
Rapid evaluation of Catmull–Clark subdivision surfaces.
In
*Web3D 2002 Symposium*. - Bronsvoort, W. F., and F. Klok. 1985.
Ray tracing generalized cylinders.
*ACM Transactions on Graphics**4*(4), 291–303. - Catmull, E., and J. Clark. 1978.
Recursively generated B-spline surfaces on arbitrary topological
meshes.
*Computer-Aided Design**10,*350–55. - Dammertz, H., and A. Keller. 2006.
Improving ray tracing precision by object space intersection computation.
*IEEE Symposium on Interactive Ray Tracing*, 25–31. - Daumas, M., and G. Melquiond.
Certification of bounds on expressions involving rounded operators.
*ACM Transactions on Mathematical Software**37*(1), 2:1–2:20. - de Voogt, E., A. van der Helm, and W. F. Bronsvoort. 2000.
Ray tracing deformed generalized cylinders.
*The Visual Computer**16*(3–4), 197–207. - Deussen, O., P. M. Hanrahan, B. Lintermann, R. Mech, M. Pharr, and
P. Prusinkiewicz. 1998.
Realistic modeling and rendering of plant ecosystems.
In
*Proceedings of SIGGRAPH ’98,*Computer Graphics Proceedings, Annual Conference Series, 275–86. - Doo, D., and M. Sabin. 1978.
Behaviour of recursive division surfaces near extraordinary points.
*Computer-Aided Design**10,*356–60. - Farin, G.
*Curves and Surfaces for CAGD: A Practical guide*, (5th ed.). San Francisco: Morgan Kaufmann. - Fisher, M., K. Fatahalian, S. Boulos, K. Akeley, W. R. Mark, and
P. Hanrahan.
DiagSplit: parallel, crack-free, adaptive tessellation for micropolygon rendering.
*ACM Transactions on Graphics (Proceedings of ACM SIGGRAPH Asia 2009)**28*(5), 150:1–150:10. - Fournier, A., D. Fussel, and L. Carpenter. 1982.
Computer rendering of stochastic models.
*Communications of the ACM**25*(6), 371–84. - Glassner, A. (Ed.) 1989a.
*An Introduction to Ray Tracing*. San Diego: Academic Press. - Goldberg, D.
What every computer scientist should know about floating-point arithmetic.
*ACM Computing Surveys**23*(1), 5–48. - Goldstein, R. A., and R. Nagel. 1971.
3-D visual simulation.
*Simulation**16*(1), 25–31. - Gray, A. 1993.
*Modern Differential Geometry of Curves and Surfaces*. Boca Raton, Florida: CRC Press. - Haines, E. A. 1989.
Essential ray tracing algorithms.
In A. Glassner (Ed.),
*An Introduction to Ray Tracing*, 33–78. San Diego: Academic Press. - Haines, E. A. 1994.
Point in polygon strategies.
In P. Heckbert (Ed.),
*Graphics Gems IV,*24–46. San Diego: Academic Press. - Hanrahan, P. 1983.
Ray tracing algebraic surfaces.
*Computer Graphics (Proceedings of SIGGRAPH ’83),**17,*83–90. - Hart, J. C. 1996.
Sphere tracing: a geometric method for the antialiased ray tracing of
implicit surfaces.
*The Visual Computer**12*(9), 527–45. - Hart, J. C., D. J. Sandin, and L. H. Kauffman. 1989.
Ray tracing deterministic 3-D fractals.
*Computer Graphics (Proceedings of SIGGRAPH ’89),**23,*289–96. - Heckbert, P. S. 1984.
The Mathematics of Quadric Surface Rendering and SOID.
*3-D Technical Memo,*New York Institute of Technology Computer Graphics Lab. - Higham, N. J.
*Accuracy and Stability of Numerical Algorithms*(2nd ed.). Philadelphia: Society for Industrial and Applied Mathematics. - Hoffmann, C. M. 1989.
*Geometric and Solid Modeling: An Introduction*. San Francisco: Morgan Kaufmann. - Hoppe, H., T. DeRose, T. Duchamp, M. Halstead, H. Jin, J. McDonald,
J. Schweitzer, and W. Stuetzle. 1994.
Piecewise smooth surface reconstruction.
In
*Proceedings of SIGGRAPH ’94,*Computer Graphics Proceedings, Annual Conference Series, Orlando, Florida, 295–302. - Institute of Electrical and Electronic Engineers. 1985.
IEEE standard 754-1985 for binary floating-point arithmetic.
Reprinted in
*SIGPLAN 22*(2), 9–25. - Institute of Electrical and Electronic Engineers. 2008. IEEE standard 754-2008 for binary floating-point arithmetic.
- Ize, T.
Robust BVH ray traversal.
*Journal of Computer Graphics Techniques (JCGT)**2*(2), 12–27. - Kajiya, J. T. 1982.
Ray tracing parametric patches.
In
*Computer Graphics (SIGGRAPH 1982 Conference Proceedings),*245–54. - Kajiya, J. T. 1983.
New techniques for ray tracing procedurally defined objects.
In
*Computer Graphics (Proceedings of SIGGRAPH ’83),**17,*91–102. - Kalra, D., and A. H. Barr. 1989.
Guaranteed ray intersections with implicit surfaces.
In
*Computer Graphics (Proceedings of SIGGRAPH ’89),*Volume 23, 297–306. - Kensler, A., and P. Shirley. 2006.
Optimizing ray-triangle intersection via automated search.
In
*IEEE Symposium on Interactive Ray Tracing,*33–38. - Knoll, A., Y. Hijazi, C. D. Hansen, I. Wald, and H. Hagen. 2009.
Fast ray tracing of arbitrary implicit surfaces with interval and affine
arithmetic.
*Computer Graphics Forum**28*(1), 26–40. - Lagae, A., and P. Dutré. 2005.
An efficient ray-quadrilateral intersection test.
*Journal of Graphics Tools**10*(4), 23–32. - Levoy, M., and T. Whitted. 1985.
The use of points as a display primitive.
*Technical Report 85-022*. Computer Science Department, University of North Carolina at Chapel Hill. - Loop, C. 1987. Smooth subdivision surfaces based on triangles. M.S. thesis, University of Utah.
- Möller, T., and B. Trumbore. 1997.
Fast, minimum storage ray–triangle intersection.
*Journal of Graphics Tools**2*(1), 21–28. - Müller, K., T. Techmann, and D. Fellner. 2003.
Adaptive ray tracing of subdivision surfaces.
*Computer Graphics Forum**22*(3), 553–62. - Martin, W., E. Cohen, R. Fish, and P. S. Shirley. 2000.
Practical ray tracing of trimmed NURBS surfaces.
*Journal of Graphics Tools**5*(1), 27–52. - Mitchell, D. P. 1990.
Robust ray intersection with interval arithmetic.
In
*Proceedings of Graphics Interface 1990*, 68–74. - Moore, R. E. 1966.
*Interval Analysis*. Englewood Cliffs, New Jersey: Prentice Hall. - Nakamaru, K., and Y. Ohno.
Ray tracing for curves primitive.
In
*Journal of WSCG (WSCG 2002 Proceedings)**10*, 311–16. - Ogaki, S., and Y. Tokuyoshi.
Direct ray tracing of Phong tessellation.
*Computer Graphics Forum (Proceedings of the 2011 Eurographics Symposium on Rendering)**30*(4), 1337–44. - Patney, A., M. S. Ebeida, and J. D. Owens.
Parallel view-dependent tessellation of Catmull–Clark subdivision surfaces.
In
*Proceedings of High Performance Graphics 2009*, 99–108. - Pfister, H., M. Zwicker, J. van Baar, and M. Gross. 2000.
Surfels: Surface elements as rendering primitives.
In
*Proceedings of ACM SIGGRAPH 2000,*Computer Graphics Proceedings, Annual Conference Series, 335–42. - Phong, B.-T., and F. C. Crow. 1975.
Improved rendition of polygonal models of curved surfaces.
In
*Proceedings of the 2nd USA–Japan Computer Conference*. - Prusinkiewicz, P. 1986.
Graphical applications of L-systems.
In
*Proceedings of Graphics Interface 1986*, 247–53. - Prusinkiewicz, P., L. Mündermann, R. Karwowski, and B. Lane. 2001.
The use of positional information in the modeling of plants.
In
*Proceedings of ACM SIGGRAPH 2001,*Computer Graphics Proceedings, Annual Conference Series, 289–300. - Prusinkiewicz, P., M. James, and R. Mech. 1994.
Synthetic topiary.
In
*Proceedings of SIGGRAPH ’94,*Computer Graphics Proceedings, Annual Conference Series, 351–58. - Qin, H., M. Chai, Q. Hou, Z. Ren, and K. Zhou.
Cone tracing for furry object rendering.
*IEEE Transactions on Visualization and Computer Graphics**20*(8), 1178–88. - Ramsey, S. D., K. Potter., and C. Hansen.
Ray bilinear patch intersections.
*Journal of Graphics Tools**9*(3), 41–47. - Ramshaw, L.
Blossoming: a connect-the-dots approach to splines.
*Digital Systems Research Center Technical Report*. - Roth, S. D. 1982.
Ray casting for modeling solids.
*Computer Graphics and Image Processing**18,*109–44. - Roth, S. H., P. Diezi, and M. Gross. 2001.
Ray tracing triangular Bézier patches.
In
*Computer Graphics Forum (Eurographics 2001 Conference Proceedings)**20*(3), 422–30. - Rusinkiewicz, S., and M. Levoy. 2000.
Qsplat: a multiresolution point rendering system for large meshes.
In
*Proceedings of ACM SIGGRAPH 2000,*Computer Graphics Proceedings, Annual Conference Series, 343–52. - Salesin, D., J. Stolfi, and L. Guibas.
Epsilon geometry: building robust algorithms from imprecise computations.
In
*Proceedings of the Fifth Annual Symposium on Computational Geometry (SCG ’89)*, 208–17. - Schaufler, G., and H. W. Jensen. 2000.
Ray tracing point sampled geometry.
In
*Rendering Techniques 2000: 11th Eurographics Workshop on Rendering,*319–28. - Schneider, P. J., and D. H. Eberly. 2003.
*Geometric Tools for Computer Graphics*. San Francisco: Morgan Kaufmann. - Shevtsov, M., A. Soupikov, and A. Kapustin. 2007a.
Ray–triangle intersection algorithm for modern CPU architectures.
In
*Proceedings of GraphiCon 2007,*33–39. - Smith, A. R. 1984.
Plants, fractals and formal languages.
In
*Computer Graphics (Proceedings of SIGGRAPH ’84),*Volume 18, 1–10. - Stürzlinger, W. 1998.
Ray tracing triangular trimmed free-form surfaces.
*IEEE Transactions on Visualization and Computer Graphics**4*(3), 202–14. - Stam, J. 1998.
Exact evaluation of Catmull-Clark subdivision surfaces at
arbitrary parameter values.
In
*Proceedings of SIGGRAPH ’98,*Computer Graphics Proceedings, Annual Conference Series, 395–404. - Stam, J., and C. Loop. 2003.
Quad/triangle subdivision.
*Computer Graphics Forum**22*(1), 79–85. - van Swaaij, M.
Ray-tracing fur for Ice Age: The Melt Down.
*ACM SIGGRAPH 2006 Sketches*. - Wächter, C. A. Quasi Monte Carlo light transport simulation by efficient ray tracing. Ph.D. thesis, University of Ulm.
- Warren, J. 2002.
*Subdivision Methods for Geometric Design: A Constructive Approach*. San Francisco: Morgan Kaufmann. - Wilkinson, J. H.
*Rounding Errors in Algebraic Processes*. New York: Dover Publications, Inc. Originally published by Prentice-Hall Inc., 1963. - Woo, A., A. Pearce, and M. Ouellette. 1996.
It’s really not a rendering bug, you see….
*IEEE Computer Graphics and Applications**16*(5), 21–25. - Woop, S., C. Benthin, and I. Wald.
Watertight ray/triangle intersection.
*Journal of Computer Graphics Techniques (JCGT)**2*(1), 65–82. - Wyvill, B., and G. Wyvill. 1989.
Field functions for implicit surfaces.
*The Visual Computer**5*(1/2), 75–82. - Yoon, S.-E., and P. Lindstrom. 2006.
Mesh layouts for block-based caches.
IEEE Transactions on Visualization and Computer
Graphics,
*12*(5), 1213–20. - Yoon, S.-E., P. Lindstrom, V. Pascucci, and D. Manocha. 2005.
Cache-oblivious mesh layouts.
In
*ACM Transactions on Graphics (Proceedings of SIGGRAPH 2005)**24*(3), 886–93. - Zorin, D., P. Schröder, T. DeRose, L. Kobbelt, A. Levin, and
W. Sweldens.
2000.
*Subdivision for Modeling and Animation*. SIGGRAPH 2000 Course Notes.