## Further Reading

After the introduction of the ray-tracing algorithm, an enormous amount of
research was done to try to find effective ways to speed it up, primarily
by developing improved ray-tracing acceleration structures. Arvo and
Kirk’s chapter in *An Introduction to Ray Tracing* (Glassner 1989a)
summarizes the state of the art as of 1989 and still provides an excellent
taxonomy for categorizing different approaches to ray intersection
acceleration.

Kirk and Arvo (1988) introduced the unifying principle of
*meta-hierarchies.* They showed that by implementing acceleration data
structures to conform to the same interface as is used for primitives in
the scene, it’s easy to mix and match different intersection acceleration
schemes. `pbrt` follows this model since the `Aggregate` inherits from
the `Primitive` base class.

#### Grids

Fujimoto, Tanaka, and Iwata (1986) introduced uniform grids, a spatial subdivision approach where the scene bounds are decomposed into equally sized grid cells. More efficient grid traversal methods were described by Amanatides and Woo (1987) and Cleary and Wyvill (1988). Snyder and Barr (1987) described a number of key improvements to this approach and showed the use of grids for rendering extremely complex scenes. Hierarchical grids, where grid cells with many primitives in them are themselves refined into grids, were introduced by Jevans and Wyvill (1989). More complex techniques for hierarchical grids were developed by Cazals, Drettakis, and Puech (1995) and Klimaszewski and Sederberg (1997).

Ize et al. (2006) developed an efficient algorithm for parallel construction of grids. One of their interesting findings was that grid construction performance quickly became limited by available memory bandwidth as the number of processing cores used increased.

Choosing an optimal grid resolution is important for getting good performance from grids. A good paper on this topic is by Ize et al. (2007), who provided a solid foundation for fully automatically selecting the resolution and for deciding when to refine into subgrids when using hierarchical grids. They derived theoretical results using a number of simplifying assumptions and then showed the applicability of the results to rendering real-world scenes. Their paper also includes a good selection of pointers to previous work in this area.

Lagae and Dutré (2008a) described an innovative representation for uniform grids based on hashing that has the desirable properties that not only does each primitive have a single index into a grid cell but also each cell has only a single primitive index. They show that this representation has very low memory usage and is still quite efficient.

Hunt and Mark (2008a) showed that building grids in perspective space, where the center of projection is the camera or a light source, can make tracing rays from the camera or light substantially more efficient. Although this approach requires multiple acceleration structures, the performance benefits from multiple specialized structures for different classes of rays can be substantial. Their approach is also notable in that it is in some ways a middle ground between rasterization and ray tracing.

#### Bounding Volume Hierarchies

Clark (1976) first suggested using bounding volumes to cull collections of objects for standard visible-surface determination algorithms. Building on this work, Rubin and Whitted (1980) developed the first hierarchical data structures for scene representation for fast ray tracing, although their method depended on the user to define the hierarchy. Kay and Kajiya (1986) implemented one of the first practical object subdivision approaches based on bounding objects with collections of slabs. Goldsmith and Salmon (1987) described the first algorithm for automatically computing bounding volume hierarchies. Although their algorithm was based on estimating the probability of a ray intersecting a bounding volume based on the volume’s surface area, it was much less effective than modern SAH BVH approaches.

The `BVHAccel` implementation in this chapter is based on the
construction algorithm described by Wald (2007) and Günther et al. (2007).
The bounding box test is the one introduced by Williams et al. (2005). An even more efficient bounding box test that does
additional precomputation in exchange for higher performance when the same
ray is tested for intersection against many bounding boxes was developed by
Eisemann et al. (2007); we leave implementing their method for an exercise.

The BVH traversal algorithm used in `pbrt` was concurrently developed by a
number of researchers; see the notes by Boulos and Haines (2006) for more
details and background. Another option for tree traversal is that of Kay and Kajiya (1986); they maintained a heap of nodes ordered by ray distance.
On GPUs, which have relatively limited amounts of on-chip memory,
maintaining a stack of to-be-visited nodes for each ray may have a
prohibitive memory cost. Foley and Sugerman (2005) introduced a
“stackless” kd-tree traversal algorithm that periodically backtracks and
searches starting from the tree root to find the next node to visit rather
than storing all nodes to visit explicitly. Laine (2010) made a number of
improvements to this approach, reducing the frequency of retraversals from
the tree root and applying the approach to BVHs.

A number of researchers have developed techniques for improving the quality of BVHs after construction. Yoon et al. (2007) and Kensler (2008) presented algorithms that make local adjustments to the BVH, and Kopta et al. (2012) reused BVHs over multiple frames of an animation, maintaining their quality by updating the parts that bound moving objects. See also Bittner et al. (2013), Karras and Aila (2013), and Bittner et al. (2014) for recent work in this area.

Most current methods for building BVHs are based on top-down construction of the tree, first creating the root node and then partitioning the primitives into children and continuing recursively. An alternative approach was demonstrated by Walter et al. (2008), who showed that bottom-up construction, where the leaves are created first and then agglomerated into parent nodes, is a viable option. Gu et al. (2013b) developed a much more efficient implementation of this approach and showed its suitability for parallel implementation.

One shortcoming of BVHs is that even a small number of relatively large primitives that have overlapping bounding boxes can substantially reduce the efficiency of the BVH: many of the nodes of the tree will be overlapping, solely due to the overlapping bounding boxes of geometry down at the leaves. Ernst and Greiner (2007) proposed “split clipping” as a solution; the restriction that each primitive only appears once in the tree is lifted, and the bounding boxes of large input primitives are subdivided into a set of tighter sub-bounds that are then used for tree construction. Dammertz and Keller (2008a) observed that the problematic primitives are the ones with a large amount of empty space in their bounding box relative to their surface area, so they subdivided the most egregious triangles and reported substantial performance improvements. Stich et al. (2009) developed an approach that splits primitives during BVH construction, making it possible to only split primitives when an SAH cost reduction was found. See also Popov et al.’s paper (2009) on a theoretically optimum BVH partitioning algorithm and its relationship to previous approaches, and Karras and Aila (2013) for improved criteria for deciding when to split triangles. Woop et al. (2014) developed an approach to building BVHs for long, thin geometry like hair and fur; because this sort of geometry is quite thin with respect to the volume of its bounding boxes, it normally has poor performance with most acceleration structures.

The memory requirements for BVHs can be significant. In our
implementation, each node is 32 bytes. With up to 2 BVH tree nodes needed
per primitive in the scene, the total overhead may be as high as 64 bytes
per primitive. Cline et al. (2006) suggested a more compact representation
for BVH nodes, at some expense of efficiency. First, they quantized the
bounding box stored in each node using 8 or 16 bytes to encode its position
with respect
to the node’s parent’s bounding box. Second, they used *implicit
indexing*, where the node ’s children are at positions and
in the node array (assuming a branching factor). They showed
substantial memory savings, with moderate performance impact. Bauszat et al. (2010) developed another space-efficient BVH representation.
See also Segovia and Ernst (2010), who developed compact representations
of both BVH nodes and triangle meshes.

Yoon and Manocha (2006) described algorithms for cache-efficient layout of BVHs and kd-trees and demonstrated performance improvements from using them. See also Ericson’s book (2004) for extensive discussion of this topic.

The linear BVH was introduced by Lauterbach et al. (2009). Pantaleoni and Luebke (2010) developed the HLBVH generalization, using the SAH at the upper levels of the tree. They also noted that the upper bits of the Morton coded values can be used to efficiently find clusters of primitives—both of these ideas are used in our HLBVH implementation. Garanzha et al. (2011) introduced further improvements to the HLBVH, most of them targeting GPU implementations.

Other than the HLBVH path, the BVH construction implementations in the
`BVHAccel` here haven’t been parallelized. See Wald (2012) for an approach
for high-performance parallel BVH construction using the SAH throughout.

#### kd-trees

Glassner (1984) introduced the use of octrees for ray intersection acceleration. Use of the kd-tree for ray tracing was first described by Kaplan (1985). Kaplan’s tree construction algorithm always split nodes down their middle; MacDonald and Booth (1990) introduced the SAH approach, estimating ray–node traversal probabilities using relative surface areas. Naylor (1993) has also written on general issues of constructing good kd-trees. Havran and Bittner (2002) revisited many of these issues and introduced useful improvements. Adding a bonus factor to the SAH for tree nodes that are completely empty, as is done in our implementation, was suggested by Hurley et al. (2002). See Havran’s Ph.D. thesis (2000) for an excellent overview of high-performance kd-construction and traversal algorithms.

Jansen (1986) first developed the efficient ray traversal algorithm for
kd-trees. Arvo (1988) also investigated this problem and discussed it in a
note in *Ray Tracing News*. Sung and Shirley (1992)
described a ray traversal algorithm’s implementation for a BSP-tree
accelerator; our `KdTreeAccel` traversal code is loosely based on
theirs.

The asymptotic complexity of the kd-tree construction algorithm in `pbrt` is
. Wald and Havran (2006) showed that it’s possible to build
kd-trees in time with some additional implementation
complexity; they reported a to speedup in construction time for
typical scenes.

The best kd-trees for ray tracing are built using “perfect splits,” where the primitive being inserted into the tree is clipped to the bounds of the current node at each step. This eliminates the issue that, for example, an object’s bounding box may intersect a node’s bounding box and thus be stored in it, even though the object itself doesn’t intersect the node’s bounding box. This approach was introduced by Havran and Bittner (2002) and discussed further by Hurley et al. (2002) and Wald and Havran (2006). See also Soupikov et al. (2008). Even with perfect splits, large primitives may still be stored in many kd-tree leaves; Choi et al. (2013) suggest storing some primitives in interior nodes to address this issue.

kd-tree construction tends to be much slower than BVH construction (especially if “perfect splits” are used), so parallel construction algorithms are of particular interest. Recent work in this area includes that of Shevtsov et al. (2007b) and Choi et al. (2010), who presented efficient parallel kd-tree construction algorithms with good scalability to multiple processors.

#### The Surface Area Heuristic

A number of researchers have investigated improvements to the SAH since its introduction to ray tracing by MacDonald and Booth (1990). Fabianowski et al. (2009) derived a version that replaces the assumption that rays are uniformly distributed throughout space with the assumption that ray origins are uniformly distributed inside the scene’s bounding box. Hunt and Mark (2008b) introduced a new SAH that accounts for the fact that rays generally aren’t uniformly distributed but rather that many of them originate from a single point or a set of nearby points (cameras and light sources, respectively). Hunt (2008) showed how the SAH should be modified when the “mailboxing” optimization is being used, and Vinkler et al. (2012) used assumptions about the visibility of primitives to adjust their SAH cost. Ize and Hansen (2011) derived a “ray termination surface area heuristic” (RTSAH), which they use to adjust BVH traversal order for shadow rays in order to more quickly find intersections with occluders. See also Moulin et al. (2015), who adapted the SAH to account for shadow rays being occluded during kd-tree traversal.

Evaluating the SAH can be costly, particularly when many different splits
or primitive partitions are being considered. One solution to this problem
is to only compute it at a subset of the candidate points—for example,
along the lines of the bucketing approach used in the `BVHAccel` in
`pbrt`. Hurley et al. (2002) suggested this approach for building kd-trees,
and Popov et al. (2006) discusses it in detail. Shevtsov et al. (2007b)
introduced the improvement of binning the full extents of triangles, not
just their centroids.

Hunt et al. (2006) noted that if you only have to evaluate the SAH at one point, for example, you don’t need to sort the primitives but only need to do a linear scan over them to compute primitive counts and bounding boxes at the point. They showed that approximating the SAH with a piecewise quadratic based on evaluating it at a number of individual positions and using that to choose a good split leads to effective trees. A similar approximation was used by Popov et al. (2006).

While the SAH has led to very effective kd-trees and BVHs, it has become clear that it isn’t perfect: a number of researchers have noted that it’s not unusual to encounter cases where a kd-tree or BVH with a higher SAH-estimated cost gives better performance than one with lower estimated cost. Aila et al. (2013) survey some of these results and propose two additional heuristics that help address them; one accounts for the fact that most rays start on surfaces—ray origins aren’t actually randomly distributed throughout the scene, and another accounts for SIMD divergence when multiple rays traverse the hierarchy together. While these new heuristics are effective at explaining why a given tree delivers the performance that it does, it’s not yet clear how to incorporate them into tree construction algorithms.

#### Other Topics in Acceleration Structures

Weghorst, Hooper, and Greenberg (1984) discussed the trade-offs of using various shapes for bounding volumes and suggested projecting objects to the screen and using a -buffer rendering to accelerate finding intersections for camera rays.

A number of researchers have investigated the applicability of general BSP trees, where the splitting planes aren’t necessarily axis aligned, as they are with kd-trees. Kammaje and Mora (2007) built BSP trees using a preselected set of candidate splitting planes. Budge et al. (2008) developed a number of improvements to their approach, though their results only approached kd-tree performance in practice due to a slower construction stage and slower traversal than kd-trees. Ize et al. (2008) showed a BSP implementation that renders scenes faster than modern kd-trees but at the cost of extremely long construction times.

There are many techniques for traversing a collection of rays through the acceleration structure together, rather than just one at a time. This approach (“packet tracing”) is an important component of high-performance ray tracing; it’s discussed in more depth in Section 17.2.2.

Animated primitives present two challenges to ray tracers: first, renderers that try to reuse acceleration structures over multiple frames of an animation must update the acceleration structures if objects are moving. Wald et al. (2007) showed how to incrementally update BVHs in this case, and Garanzha (2009) suggested creating clusters of nearby primitives and then building BVHs of those clusters (thus lightening the load on the BVH construction algorithm). A second problem is that for primitives that are moving quickly, the bounding boxes of their full motion over the frame time may be quite large, leading to many unnecessary ray–primitive intersection tests. Notable work on this issue includes Glassner (1988), who generalized ray tracing (and an octree for acceleration) to four dimensions, adding time. More recently, Grünschloß et al. (2011) developed improvements to BVHs for moving primitives. See also Wald et al.’s (2007b) survey paper on ray tracing animated scenes.

An innovative approach to acceleration structures was suggested by Arvo and Kirk (1987), who introduced a 5D data structure that subdivided based on both 3D spatial and 2D ray directions. Another interesting approach for scenes described with triangle meshes was developed by Lagae and Dutré (2008b): they computed a constrained tetrahedralization, where all triangle faces of the model are represented in the tetrahedralization. Rays are then stepped through tetrahedra until they intersect a triangle from the scene description. This approach is still a few times slower than the state-of-the-art in kd-trees and BVHs but is an interesting new way to think about the problem.

There is an interesting middle ground between kd-trees and BVHs, where the tree node holds a splitting plane for each child rather than just a single splitting plane. For example, this refinement makes it possible to do object subdivision in a kd-tree-like acceleration structure, putting each primitive in just one subtree and allowing the subtrees to overlap, while still preserving many of the benefits of efficient kd-tree traversal. Ooi et al. (1987) first introduced this refinement to kd-trees for storing spatial data, naming it the “spatial kd-tree” (skd-tree). Skd-trees have recently been applied to ray tracing by a number of researchers, including Zachmann (2002), Woop et al. (2006), Wächter and Keller (2006), Havran et al. (2006), and Zuniga and Uhlmann (2006).

When spatial subdivision approaches like grids or kd-trees are used, primitives may overlap multiple nodes of the structure and a ray may be tested for intersection with the same primitive multiple times as it passes through the structure. Arnaldi, Priol, and Bouatouch (1987) and Amanatides and Woo (1987) developed the “mailboxing” technique to address this issue: each ray is given a unique integer identifier, and each primitive records the id of the last ray that was tested against it. If the ids match, then the intersection test is unnecessary and can be skipped.

While effective, this approach doesn’t work well with a multi-threaded ray tracer. To address this issue, Benthin (2006) suggested storing a small per-ray hash table to record ids of recently intersected primitives. Shevtsov et al. (2007a) maintained a small array of the last intersected primitive ids and searched it linearly before performing intersection tests. Although some primitives may still be checked multiple times with both of these approaches, they usually eliminate most redundant tests.

### References

- Aila, T., T. Karras, and S. Laine.
On quality metrics of bounding volume hierarchies.
In
*Proceedings of High Performance Graphics 2013*, 101–07. - Akenine-Möller, T. 2001.
Fast 3D triangle-box overlap testing.
*Journal of Graphics Tools**6*(1), 29–33. - Amanatides, J., and A. Woo. 1987.
A fast voxel traversal algorithm for ray tracing.
In
*Proceedings of Eurographics ’87,*3–10. - Arnaldi, B., T. Priol, and K. Bouatouch. 1987.
A new space subdivision method for ray tracing CSG modeled scenes.
*The Visual Computer**3*(2), 98–108. - Arvo, J. 1988.
Linear-time voxel walking for octrees.
*Ray Tracing News 12*(1). - Arvo, J., and D. Kirk. 1987.
Fast ray tracing by ray classification.
*Computer Graphics (SIGGRAPH ’87 Proceedings)**21*(4), 55–64. - Bauszat, P., M. Eisemann, and M. Magnor.
The minimal bounding volume hierarchy.
*Vision, Modeling, and Visualization (2010)*. - Benthin, C. Realtime ray tracing on current CPU architectures. Ph.D. thesis, Saarland University.
- Bittner, J., M. Hapala, and V. Havran.
Fast insertion-based optimization of bounding volume hierarchies.
*Computer Graphics Forum**32*(1), 85–100. - Bittner, J., M. Hapala, and V. Havran.
Incremental BVH construction for ray tracing.
*Computers & Graphics**47*, 135–44. - Boulos, S., and E. Haines. 2006.
Ray–box sorting.
*Ray Tracing News**19*(1), www.realtimerendering.com/resources/RTNews/html/rtnv19n1.html. - Budge, B., D. Coming, D. Norpchen, and K. Joy. 2008.
Accelerated building and ray tracing of restricted BSP trees.
In
*IEEE Symposium on Interactive Ray Tracing,*167–74. - Cazals, F., G. Drettakis, and C. Puech. 1995.
Filtering, clustering and hierarchy construction: a new solution for
ray-tracing complex scenes.
*Computer Graphics Forum**14*(3), 371–82. - Choi, B., B. Chang, and I. Ihm.
Improving memory space efficiency of kd-tree for real-time ray tracing.
*Computer Graphics Forum**32*(7), 335–44. - Choi, B., R. Komuravelli, V. Lu, H. Sung, R. L. Bocchino,
S. V. Adve, and J. C. Hart.
Parallel SAH k-D tree construction.
In
*Proceedings of High Performance Graphics 2010*, 77–86. - Clark, J. H. 1976.
Hierarchical geometric models for visible surface algorithms.
*Communications of the ACM**19*(10), 547–54. - Cleary, J. G., and G. Wyvill. 1988.
Analysis of an algorithm for fast ray tracing using uniform space
subdivision.
*The Visual Computer**4*(2), 65–83. - Cline, D., P. Egbert, J. Talbot, and D. Cardon.
Two stage importance sampling for direct lighting.
*Rendering Techniques 2006: 17th Eurographics Workshop on Rendering,*103–14. - Dammertz, H., and A. Keller. 2008a.
The edge volume heuristic—robust triangle subdivision for improved BVH
performance, In
*IEEE Symposium on Interactive Ray Tracing*, 155–58. - Eisemann, M., M. Magnor, T. Grosch, and S. Müller. 2007.
Fast ray/axis-aligned bounding box overlap tests using ray slopes.
*Journal of Graphics, GPU, and Game Tools**12*(4), 35–46. - Ericson, C. 2004.
*Real-Time Collision Detection*. Morgan Kaufmann Series in Interactive 3D Technology. San Francisco: Morgan Kaufmann. - Ernst, M., and G. Greiner. 2007.
Early split clipping for bounding volume hierarchies.
*IEEE Symposium on Interactive Ray Tracing*, 73–78. - Fabianowski, B., C. Fowler, and J. Dingliana. 2009.
A cost metric for scene-interior ray origins.
In
*Short Paper Proceedings of the 30th Annual Conference of the European Association for Computer Graphics (Eurographics 2009),*49–50. - Foley, T., and J. Sugerman.
KD-tree acceleration structures for a GPU raytracer.
In
*Proceedings of the ACM SIGGRAPH/EUROGRAPHICS Conference on Graphics Hardware*, 15–22. - Fujimoto, A., T. Tanaka, and K. Iwata. 1986.
Arts: accelerated ray-tracing system.
*IEEE Computer Graphics and Applications**6*(4), 16–26. - Günther, J., S. Popov, H. P. Seidel, and P. Slusallek. 2007.
Realtime ray tracing on GPU with BVH-based packet traversal.
In
*IEEE Symposium on Interactive Ray Tracing,*113–18. - Garanzha, K.
The use of precomputed triangle clusters for accelerated ray tracing in dynamic scenes.
*Computer Graphics Forum (Proceedings of the 2009 Eurographics Symposium on Rendering)**28*(4), 1199–1206. - Garanzha, K., J. Pantaleoni, D. McAllister.
Simpler and faster HLBVH with work queues.
In
*Proceedings of High Performance Graphics 2011*, 59–64. - Glassner, A.
Spacetime ray tracing for animation.
*IEEE Computer Graphics & Applications**8*(2), 60–70. - Glassner, A. (Ed.) 1989a.
*An Introduction to Ray Tracing*. San Diego: Academic Press. - Glassner, A. 1984.
Space subdivision for fast ray tracing.
*IEEE Computer Graphics and Applications**4*(10), 15–22. - Goldsmith, J., and J. Salmon. 1987.
Automatic creation of object hierarchies for ray tracing.
*IEEE Computer Graphics and Applications**7*(5), 14–20. - Grünschloß, L., M. Stich, S. Nawaz, and A. Keller.
MSBVH: an efficient acceleration data structure for ray traced motion blur.
In
*Proceedings of High Performance Graphics 2011*, 65–70. - Gu, Y., Y. He, K. Fatahalian, and G. Blelloch.
Efficient BVH construction via approximate agglomerative clustering.
*Proceesings of High Performance Graphics 2013*, 81–88. - Havran, V. Heuristic ray shooting algorithms. Ph.D. thesis, Czech Technical University.
- Havran, V., and J. Bittner. 2002.
On improving kd-trees for ray shooting.
In
*Proceedings of WSCG 2002 Conference,*209–17. - Havran, V., R. Herzog, and H.-P. Seidel. 2006.
On the fast construction of spatial hierarchies for ray tracing.
In
*IEEE Symposium on Interactive Ray Tracing,*71–80. - Hunt, W. 2008.
Corrections to the surface area metric with respect to mail-boxing.
In
*IEEE Symposium on Interactive Ray Tracing,*77–80. - Hunt, W., and B. Mark. 2008a.
Ray-specialized acceleration structures for ray tracing.
In
*IEEE Symposium on Interactive Ray Tracing,*3–10. - Hunt, W., and B. Mark. 2008b.
Adaptive acceleration structures in perspective space.
In
*IEEE Symposium on Interactive Ray Tracing,*117–17. - Hunt, W., W. Mark, and G. Stoll. 2006.
Fast kd-tree construction with an adaptive error-bounded heuristic.
In
*IEEE Symposium on Interactive Ray Tracing,*81–88. - Hurley, J., A. Kapustin, A. Reshetov, and A. Soupikov. 2002.
Fast ray tracing for modern general purpose CPU.
In
*Proceedings of GraphiCon 2002*. - Ize, T., and C. Hansen.
RTSAH traversal order for occlusion rays.
*Computer Graphics Forum (Proceedings of Eurographics 2011)**30*(2), 295–305. - Ize, T., I. Wald, and S. Parker. 2008.
Ray tracing with the BSP tree.
In
*IEEE Symposium on Interactive Ray Tracing,*159–66. - Ize, T., I. Wald, C. Robertson, and S. G. Parker.
An evaluation of parallel grid construction for ray tracing dynamic scenes.
*IEEE Symposium on Interactive Ray Tracing*, 47–55. - Ize, T., P. Shirley, and S. Parker. 2007.
Grid creation strategies for efficient ray tracing.
In
*IEEE Symposium on Interactive Ray Tracing,*27–32. - Jansen, F. W. 1986.
Data structures for ray tracing.
In L. R. A. Kessener, F. J. Peters, and M. L. P. Lierop (Eds.),
*Data Structures for Raster Graphics, Workshop Proceedings,*57–73. New York: Springer-Verlag. - Jevans, D., and B. Wyvill. 1989.
Adaptive voxel subdivision for ray tracing.
In
*Proceedings of Graphics Interface 1989*, 164–72. - Kammaje, R., and B. Mora. 2007.
A study of restricted BSP trees for ray tracing.
In
*IEEE Symposium on Interactive Ray Tracing,*55–62. - Kaplan, M. R. 1985.
The uses of spatial coherence in ray tracing.
In
*ACM SIGGRAPH Course Notes 11*. - Karras, T., and T. Aila.
Fast parallel construction of high-quality bounding volume hierarchies.
In
*Proceedings of High Performance Graphics 2013*, 89–99. - Kay, T., and J. Kajiya. 1986.
Ray tracing complex scenes.
In
*Computer Graphics (SIGGRAPH ’86 Proceedings),*Volume 20, 269–78. - Kensler, A. 2008.
Tree rotations for improving bounding volume hierarchies.
In
*IEEE Symposium on Interactive Ray Tracing,*73–76. - Kirk, D., and J. Arvo. 1988.
The ray tracing kernel.
In
*Proceedings of Ausgraph ’88,*75–82. - Klimaszewski, K. S., and T. W. Sederberg. 1997.
Faster ray tracing using adaptive grids.
*IEEE Computer Graphics and Applications**17*(1), 42–51. - Kopta, D., T. Ize, J. Spjut, E. Brunvand, A. Davis, and A. Kensler.
Fast, effective BVH updates for animated scenes.
In
*Proceedings of the ACM SIGGRAPH Symposium on Interactive 3D Graphics and Games*, 197–204. - Lacewell, D., B. Burley, S. Boulos, and P. Shirley. 2008.
Raytracing prefiltered occlusion for aggregate geometry.
In
*IEEE Symposium on Interactive Ray Tracing,*19–26. - Lagae, A., and P. Dutré. 2008a.
Compact, fast, and robust grids for ray tracing.
In
*Computer Graphics Forum (Proceedings of the 2008 Eurographics Symposium on Rendering)**27*(4), 1235–1244. - Lagae, A., and P. Dutré. 2008b.
Accelerating ray tracing using constrained tetrahedralizations.
In
*Computer Graphics Forum (Proceedings of the 2008 Eurographics Symposium on Rendering)**27*(4), 1303–12. - Laine, S.
Restart trail for stackless BVH traversal.
In
*Proceedings of High Performance Graphics 2010*, 107–11. - Lauterbach, C., M. Garland, S. Sengupta, D. Luebke, and D. Manocha. 2009.
Fast BVH construction on GPUs.
*Computer Graphics Forum (Eurographics 2009 Conference Proceedings)**28*(2), 422–30. - MacDonald, J. D., and K. S. Booth. 1990.
Heuristics for ray tracing using space subdivision.
*The Visual Computer**6*(3), 153–66. - Moulin, M., N. Billen, P. Dutré.
Efficient visibility heuristics for kd-trees using the RTSAH.
*Eurographics Symposium on Rendering–Experimental Ideas & Implementations*. - Naylor, B. 1993.
Constructing good partition trees.
In
*Proceedings of Graphics Interface 1993*, 181–91. - Ooi, B. C., K. McDonell, and R. Sacks-Davis. 1987.
Spatial kd-tree: a data structure for geographic databases.
In
*Proceedings of the IEEE COMPSAC Conference*. - Pantaleoni, J., and D. Luebke.
HLBVH: hierarchical LBVH construction for real-time ray tracing of dynamic geometry.
In
*Proceedings of the Conference on High Performance Graphics 2010*, 87–95. - Popov, S., J. Gunther, H. P. Seidel, and P. Slusallek. 2006.
Experinces with streaming construction of SAH kd-trees.
In
*IEEE Symposium on Interactive Ray Tracing,*89–94. - Popov, S., R. Dimov, I. Georgiev, and P. Slusallek.
Object partitioning considered harmful: space subdivision for BVHs.
In
*Proceedings of High Performance Graphics 2009,*15–22. - Rubin, S. M., and T. Whitted. 1980.
A 3-dimensional representation for fast rendering of complex scenes.
*Computer Graphics**14*(3), 110–16. - Segovia, B., and M. Ernst.
Memory efficient ray tracing with hierarchical mesh quantization.
In
*Proceedings of Graphics Interface 2010*, 153–60. - Shevtsov, M., A. Soupikov, and A. Kapustin. 2007a.
Ray–triangle intersection algorithm for modern CPU architectures.
In
*Proceedings of GraphiCon 2007,*33–39. - Shevtsov, M., A. Soupikov, and A. Kapustin. 2007b.
Highly parallel fast kd-tree construction for interactive ray tracing of
dynamic scenes.
In
*Computer Graphics Forum (Proceedings of Eurographics 2007)**26*(3), 395–404. - Snyder, J. M., and A. H. Barr. 1987.
Ray tracing complex models containing surface tessellations.
*Computer Graphics (SIGGRAPH ’87 Proceedings),*Volume 21, 119–28. - Soupikov, A., M. Shevtsov, and A. Kapustin. 2008.
Improving kd-tree quality at a reasonable construction cost.
In
*IEEE Symposium on Interactive Ray Tracing,*67–72. - Stich, M., H. Friedrich, and A. Dietrich.
Spatial splits in bounding volume hierarchies.
In
*Proceedings of High Performance Graphics 2009,*7–14. - Sung, K., and P. Shirley. 1992.
Ray tracing with the BSP tree.
In D. Kirk (Ed.),
*Graphics Gems III,*271–274. San Diego: Academic Press. - Vinkler, M., V. Havran, and J. Sochora.
Visibility driven BVH build up algorithm for ray tracing.
*Computers & Graphics**36*(4), 283–96. - Wächter, C. A., and A. Keller.
Instant ray tracing: the bounding interval hierarchy.
In
*Rendering Techniques 2006: 17th Eurographics Workshop on Rendering,*139–49. - Wald, I.
Fast construction of SAH BVHs on the Intel Many Integrated Core (MIC) architecture.
*IEEE Transactions on Visualization and Computer Graphics**18*(1), 47–57. - Wald, I. 2007.
On fast construction of SAH-based bounding volume hierarchies.
In
*IEEE Symposium on Interactive Ray Tracing,*33–40. - Wald, I., and V. Havran. 2006.
On building fast kd-trees for ray tracing and on doing that in .
In
*IEEE Symposium on Interactive Ray Tracing,*61–69. - Wald, I., S. Boulos, and P. Shirley. 2007a.
Ray tracing deformable scenes using dynamic bounding volume hierarchies.
*ACM Transactions on Graphics**26*(1). - Wald, I., W. Mark, J. Günther, S. Boulos, T. Ize, W. Hunt, S. Parker,
and P. Shirley.
State of the art in ray tracing animated scenes.
In
*Eurographics 2007 State of the Art Reports*. - Walter, B., K. Bala, M. Kilkarni, and K. Pingali. 2008.
Fast agglomerative clustering for rendering.
In
*IEEE Symposium on Interactive Ray Tracing,*81–86. - Weghorst, H., G. Hooper, and D. P. Greenberg. 1984.
Improved computational methods for ray tracing.
*ACM Transactions on Graphics**3*(1), 52–69. - Williams, A., S. Barrus, R. K. Morley, and P. Shirley. 2005.
An efficient and robust ray–box intersection algorithm.
*Journal of Graphics, GPU, and Game Tools**10*(4), 49–54. - Woop, S., C. Benthin, I. Wald, G. S. Johnson, and E. Tabellion.
Exploiting local orientation similarity for efficient ray traversal of hair
and fur.
In
*Proceedings of High Performance Graphics 2014*, 41–49. - Woop, S., G. Marmitt, and P. Slusallek. 2006.
B-kd trees for hardware accelerated ray tracing of dynamic scenes.
In
*Graphics Hardware 2006: Eurographics Symposium Proceedings,*Vienna, Austria, 67–76. - Yoon, S.-E., and D. Manocha. 2006.
Cache-efficient layouts of bounding volume hierarchies.
In
*Computer Graphics Forum: Proceedings of Eurographics 2006**25*(3), 507–16. - Yoon, S.-E., S. Curtis, and D. Manocha.
Ray tracing dynamic scenes using selective restructuring.
In
*Proceedings of the Eurographics Symposium on Rendering*, 73–84. - Zachmann, G. 2002.
Minimal hierarchical collision detection.
In
*Proceedings of the ACM Symposium on Virtual Reality Software and Technology,*121–28. - Zuniga, M., and J. Uhlmann. 2006.
Ray queries with wide object isolation and the S-tree.
*Journal of Graphics, GPU, and Game Tools**11*(3), 27–45.