Interactive ray tracing of skinned animations

Visual Comput (2006) 22: 785–792DOI 10.1007/s00371-006-0063-x O R I G I N A L A R T I C L E

Johannes GuntherHeiko FriedrichHans-Peter SeidelPhilipp Slusallek

Interactive ray tracing of skinned animations

Published online: 15 August 2006© Springer-Verlag 2006

J. Gunther (�) · H.-P. SeidelMPI Informatik, Stuhlsatzenhausweg 85,66123 Saarbrucken, Germany{guenther, hpseidel}@mpi-inf.mpg.de

H. Friedrich · P. SlusallekSaarland University,Stuhlsatzenhausweg 85,66123 Saarbrucken, Germany{friedrich, slusallek}@graphics.cs.uni-sb.de

Abstract Recent high-performanceray tracing implementations havealready achieved interactive perform-ance on a single PC even for highlycomplex scenes. However, so farthese approaches have been limitedto mostly static scenes due to the highcost of updating the necessary spatialindex structures after modifyingscene geometry. In this paper, wepresent an approach that avoids theseupdates almost completely for thecase of skinned models as typicallyused in computer games. We assumethat the characters are built frommeshes with an underlying skeletonstructure, where the set of joint anglesdefines the character’s pose and deter-mines the skinning parameters. Basedon a sampling of the possible pose

space we build a static fuzzy kd-treefor each skeleton segment in a fastpreprocessing step. This fuzzy kd-tree is then organized into a top-levelkd-tree. Together with the skeleton’saffine transformations this multi-levelkd-tree allows fast and efficient scenetraversal at runtime, while arbitrarycombinations of animation sequencescan be applied interactively to thejoint angles. We achieve a real-timeray tracing performance of up to 15frames per second at 1024×1024resolution even on a single processorcore.

Keywords Ray tracing · Fuzzykd-tree · Dynamic scenes

1 Introduction

Interactive image synthesis and real-time visualization istoday a matter-of-course. Rasterization hardware is con-tinuously using new tricks to support more advanced shad-ing and lighting effects. Moreover, ray tracing – famousfor its superior rendering quality – has finally become fastenough for real-time applications. Even highly complexscenes with millions of primitives can be ray traced at real-time frame rates [23].

A feature that is still not supported to its full extentin real-time ray tracing is dynamic scenes. Unfortunately,many applications require at least the interactive render-ing of dynamically changing objects, and computer gameseven demand at least 60 Hz. Real-time rendering of an-

imations is still the domain of graphics hardware be-cause of its immense hardware acceleration, e.g. for ver-tex shaders. With more than 48 pipelines [3] at present,GPUs provide massive parallel computation power. Fur-thermore, rasterization does not depend on precomputedacceleration structures for rendering, since every polygonis rendered in every frame anyway.

However, ray tracing, first introduced into the field ofcomputer graphics by Appel et al. [2], must exploit spa-tial index structures to speed up the rendering process byminimizing the number of ray-primitive intersections. Allcurrent spatial index structures used in ray tracing, suchas octrees [8], bounding volume hierarchies [24] (BVH),grids [1, 6], and kd-trees [14] must be rebuilt when objectschange. Depending on the scene and the type of indexstructure, the reconstruction can take up to several min-

786 J. Günther et al.

Fig. 1. The “UT 2003” and “Cally” example scenes demonstrating interactively skinned meshes. These dynamic scenes are ray tracedbetween 4 (including shadows, right two images) and 15 frames per second (with a simple shader, left two images) at 1024×1024 pixelson a single CPU

utes, which of course is not tolerable for interactive ap-plications [11]. Especially highly optimized kd-trees [30]built with surface area heuristics [18] tend to have ex-tremely long construction times.

In recent years, kd-trees have been shown to be an ef-ficient acceleration structure for static scenes, which canyield excellent ray tracing performance [12]. One main ad-vantage of kd-trees is that they subdivide space into irreg-ularly sized areas [11, 21] and thus they also adapt to un-evenly distributed scene-primitives very well (comparedto grids). Additionally, the simple traversal algorithm ofkd-trees can be mapped efficiently to modern processors(compared to octrees and BVH) [27]. As a consequence,most modern real-time ray tracing systems implement kd-trees, including CPU-based systems [23, 32], ray tracinghardware [25, 34], and GPU-based ray tracers [7].

2 Related work

Real-time ray tracing has a short history and not much re-search has been done in the area of interactive ray tracingof dynamic scenes yet.

In 2001 first practical results towards real-time raytracing of static scenes on commodity PCs were presentedby Wald et al. [32]. An extensive study of accelerationstructures by Havran [11] showed that kd-trees performbest for a large number of test scenes.

Lext et al. [16] proposed a novel algorithm to effi-ciently ray trace animated objects that undergo simpleaffine transformations such as rotation and translation. Todo so, they used a hierarchy of oriented bounding boxesover the objects, with each object having its own grid asthe acceleration structure. Two years later, Wald et al. [28]introduced the concept of a two-level kd-tree to ray tracethe same class of dynamic objects as Lext but with kd-trees.

Reihard et al. [22] proposed the usage of interactivegrids to render scenes with random motion like particle-

and turbulence systems. In order to achieve interactive re-sults they used an SGI Onyx 2000 with 32 processors.

Recently, Günther et al. [10] proposed a motion decom-position approach to ray trace animations. In their worka motion clustering algorithm identifies regions with co-herent motion that can be expressed as an affine trans-formation of the scene vertices. After subtraction of thiscommon transformation for each cluster, the residual mo-tion is handled by a so-called fuzzy kd-tree. A fuzzykd-tree is not directly built over the scene primitives butover axis-aligned fuzzy boxes, which bound the spacewhere an primitive can be located during the animation.Although real-time rendering frame rates can be achievedwith this approach, the algorithm has the disadvantagethat the complete animation sequence has to be knownin advance. Furthermore, the motion clustering is a costlypreprocessing step. In this paper, we extend the idea ofmotion decomposition to skinned animations.

Very recently it was demonstrated that ray tracing ofdynamic scenes at interactive frame rates can also beaccomplished with grids [22, 31], bounding volume hier-archies (BVHs) [5, 15, 29], or hybrid data structures [26,33]. These acceleration structures can be rebuilt or up-dated faster than kd-trees when geometry changes. How-ever, they are still inferior in ray tracing performance inthe general case.

3 Ray tracing of skinned animations

Although kd-trees are widely considered as the most ef-ficient acceleration structure for ray tracing, their largeconstruction time heavily complicates its use for dynamicscenes. Thus our goal is to avoid rebuilding the kd-treewhile still retaining its efficiency as an acceleration struc-ture.

The idea is to compensate for most of the motion ofthe scene by transforming rays instead of the geometry.For this purpose, we adapt the concept of two-level kd-

Interactive ray tracing of skinned animations 787

trees [28]. The residual motion of the scene that cannot becompensated is handled separately by fuzzy kd-trees simi-lar to the approach in [10].

We extend the approaches of previous work by sup-porting a more flexible type of animation, specificallyskinned meshes. By exploiting the underlying bone in-formation, we can efficiently construct the fuzzy kd-treesonce in a preprocessing phase. During ray tracing of theskinned animation these fuzzy kd-trees do not need to beupdated.

Before describing our work in detail, we will brieflyreview the concept of two-level kd-trees.

3.1 Two-level kd-trees

If an animated scene consists of several moving rigid ob-jects, separate kd-trees can be built, one for each object.This has the advantage that these kd-trees can be prebuilt-built and remain valid during the course of the animation.

The absolute motion of all objects is accounted for bya top-level kd-tree. Only this kd-tree needs to be updatedin every frame as it is built over the current boundingboxes of all objects. This way the top-level kd-tree adaptsto the changing positions and orientations of moving ob-jects (Fig. 2). However, this rebuilding can be done veryquickly because the number of moving objects is usuallyrather small (less than 100), allowing interactive framerates.

To render a new frame, ray traversal starts in the top-level kd-tree. For every intersected bounding box the rayis transformed into the local coordinate system of that boxand traversal continues at the root node of the correspond-ing second-level kd-tree.

With such a two-level kd-tree hierarchy it is possible tointeractively ray trace animated objects that just undergosimple affine transformations. A distinct example for thistype of animation is the BART robots scene [17].

3.2 Vertex skinning

Nevertheless, for more flexible animation types the two-level kd-tree scheme alone is not sufficient. Our goal is toray trace skinned animations because they provide manyadvantages. Skinned meshes are a powerful tool for con-tent creation in computer games and animated movies.Artists create meshes, e.g. an avatar for a game such asthe “UT 2003” model in Fig. 1 and attach a bone modelas well as physics to it. Using this additional informationthey can then apply deformations to the mesh. This typeof motion is a good approximation of many real scenariosand is also common for animated synthetic datasets.

A skinned mesh is animated with the help of an under-lying skeleton, usually referred to as skeleton subspace de-formation [19, 20]. Each vertex of the mesh is influencedby one or more bones. For example, vertices forming an

Fig. 2. To ray trace a frame of an animation we first build a smallkd-tree over the current bounding boxes of each bone object. Theseboxes are shown for three configurations of the “Cally” scene. Rayshitting a box get inversely transformed into the local coordinatesystem of this box and traverse its fuzzy kd-tree

arm move together with the corresponding arm bone. Ad-ditionally, vertices near the joints of two bones are influ-enced by both bones, resulting in a smooth skin surfacewithout cracks or other artifacts near the joints.

Mathematically, bones are described by transform-ations and standard skinning is a simple weighted interpo-lation:

v′ =n∑

i=1

wi Xiv, withn∑

i=1

wi = 1 .

The value n is the number of bones influencing theskinned position v′. Xi is the current transformation ofbone i and wi is the associated scalar weight (or influence)of that bone for the vertex v in the rest pose of the mesh.The rest pose is the original mesh configuration modeledby an artist without skinning.

If all vertices were to be influenced by only one bone(n = 1), we would have the situation of simple affine-onlytransformations where the two-level kd-tree scheme canbe applied.

However, it is an important observation that even whenn > 1 the interpolated motion of a vertex in the local coor-dinate system of a carefully chosen bone is typically rathersmall. The reason is that usually vertices are significantlyinfluenced by neighboring bones only.

This small residual motion of the vertices and trian-gles is then bounded by so-called fuzzy boxes. A fuzzy boxis an axis-aligned bounding box in the local coordinatesystem that contains the valid positions of a triangle. Foreach bone, a fuzzy kd-tree [10] is then built over the fuzzyboxes rather than the triangles. This has to be done onlyonce in a preprocessing step, because the local movementof the triangles does not invalidate the fuzzy kd-tree (seealso Fig. 3).

To render a new frame the pose of the skeleton is up-dated as well as the vertex positions. Then the world coor-dinate bounding boxes of each bone and associated trian-gles are calculated. Finally, we can apply the two-level kd-


Fig. 3. The residual motion of each triangle (green) is bounded bya fuzzy box (red). As the fuzzy kd-tree is built over these fuzzyboxes instead of the triangles it is valid for all poses of the skinnedmodel

tree scheme and rebuild the small top-level kd-tree overthe bone fuzzy kd-trees.

3.3 Stochastic fuzzy box computation

For the correctness of this algorithm it is crucial that thefuzzy boxes used to build the fuzzy kd-trees are conser-vative. Otherwise it might happen that triangles get culledduring traversal of the fuzzy kd-trees and that rays erro-neously miss these triangles, which will result in holes inthe mesh.

Additionally, we also want to optimize ray tracing per-formance. Thus it is preferable to have small fuzzy boxes,because the surface area of the fuzzy boxes is propor-tional to the probability that a random ray will hit thisbox [18].

To estimate a set of small, but sufficiently conserva-tive fuzzy boxes, we sample the pose space during thepreprocessing phase. The full pose space can be sam-pled by rotating each bone arbitrarily. However, tighterfuzzy boxes and thus better ray tracing performance canbe achieved by restricting the bone rotation relative to itsparent bone. Additional information from the rendering

Fig. 4. “Cally” featuring self shadowing in different poses

application – such as joint limits – can be used to re-strict the pose space, because arbitrary bone rotations arequite unnatural for most models. Another possibility is toonly sample the different animation sequences – such aswalking, running, or kicking – used e.g. by a game appli-cation.

Note that the size of the fuzzy boxes depends not onlyon the pose space but also on the choice of the bone a tri-angle is assigned to. In order to find the optimal bone, wedo an exhaustive search by calculating the fuzzy box inevery bone’s local coordinate system. The fuzzy box ofa triangle is the union of the fuzzy boxes of its vertices.

The fuzzy boxes of all vertices are calculated by sam-pling as follows. For each sample (i.e. a pose of theskeleton), every vertex is skinned and subsequently trans-formed into the local coordinate space of each bone. Thefuzzy box of a vertex in a bone’s local coordinate system isthen the axis-aligned bounding box of its samples, i.e. itstransformed positions.

4 Implementation and results

We implemented our ray tracing engine with C++ and useSSE [13] for optimizing inner loops. The kd-tree traver-sal is loosely based on multi-level ray tracing and theinverse frustum culling approach of Reshetov et al. [23]with a ray packet size of 4 × 4. The ray-triangle inter-section test is basically the same as described in [27]for packets of rays. To manage the skeleton and skin-ning parameters of the models, we use the open sourcelibrary Cal3D [4]. With Cal3D we can also smoothlyblend different animation sequences as well as interpolatebetween key frames (see Fig. 4). All measurements aredone on a workstation equipped with two AMD Opteron2.4 GHz processors and a GeForce 6800 GT PCIe graph-ics board.


4.1 GPU accelerated display

In real-time ray tracing implementations it was common tostore the color of each computed pixel of the current framein the main memory of the PC. After all pixel calculationswere done, an OpenGL or DirectX call was made to trans-fer the image to the graphics hardware for display. Witha float frame buffer of full-screen resolution, this trans-fer can easily be a bottleneck – measurements have shownthat it can slow down the overall rendering process by upto 25%.

To ease this problem, we use the OpenGL pixel bufferobjects extension to directly store computed pixel valuesin the texture memory of the graphics board. Besides re-ducing the display overhead to only 4 ms, this approachhas the additional advantage that color channel swizzlingor tone mapping (see e.g. [9]) can be efficiently performedby the pixel shader pipelines of the GPU. Merely movingthe swizzling and float-to-int conversion of the color chan-nels from the CPU to the GPU significantly increases theframe rate.

4.2 Fuzzy box estimation

To evaluate the trade-off between the flexibility of pos-ing a skinned mesh and the ray tracing performance, werestricted the valid pose space in several steps. Arbitraryrotations of the bones on the one hand allow the great-est freedom for a user to interact with the model. On theother hand, it is often meaningful to apply joint limits tothe skeleton to avoid unnatural mesh deformations. Thepose space can be further restricted by allowing only cer-tain types of (predefined) movements (such as walking orwaving), which is often the case in game applications.

Table 1 shows our measurements for all these posespace configurations. With increasing freedom of the bonerotations, the fuzzy boxes become larger. This leads tomore overlap of the fuzzy boxes, which decreases the effi-ciency of the fuzzy kd-tree. More intersections need to becalculated, resulting in decreased ray tracing performance.

The accumulated surface area of the fuzzy boxes of alltriangles is a good measure for the expected ray tracingperformance because it is proportional to the number of

Table 1. Influence of the valid pose space on the fuzzy box sur-face area, the quality of the fuzzy kd-trees and subsequently therendering performance for the “UT 2003” scene. Restricting thepose space – at least by joint limits – greatly improves ray tracingperformance

Fuzzy Avg. #trisPose space #samples Area Per leave fps

Arbitrary bone rotations 1000 747k 4.1 7.7Applying joint limits 245 580k 3.4 10.2Many animation sequences 124 552k 3.2 11.6Single animation sequence 62 515k 3.1 12.0

intersections of a random ray with these boxes [18]. Notethat the absolute value of the surface area is meaningless,as it directly depends on the scale of the scene. One meas-ure for the efficiency of kd-trees is the average numberof triangles per kd-tree leaf. Higher numbers account forlarger overlap of fuzzy boxes, because it is not meaning-ful to split the overlapping area during kd-tree creation –every child node would have the same number of triangles– and we cannot save intersection tests. Finally, we ver-ified our expectations by measuring the achieved framesper second for ray tracing the rest pose with the sameviewpoint for all the different pose space configurations.

All these measures show that restricting the pose spaceimproves the ray tracing performance. The biggest per-formance gain can be obtained by applying joint limits.

4.3 Performance depending on mesh size

To evaluate the preprocessing as well as the rendering per-formance of our ray tracing implementation we measuredthe pose space sampling time, the time to construct thefuzzy kd-trees, and the achieved frames per second for twoscenes. We were not able to acquire models with a highnumber of polygons that include the necessary skeletonand skinning parameters. To still be able to estimate theperformance of our system for scenes with a high num-ber of triangles, we decided to iteratively subdivide ourlow-resolution models.

Table 2 summarizes our results. All numbers weremeasured at a screen resolution of 1024×1024 pixels ona single CPU with a simple diffuse shader. Even with hun-dreds of thousands of triangles we achieved reasonablefast preprocessing within seconds to a few minutes. Asexpected, the sampling time was roughly linear in thenumber of triangles. For ray tracing dynamic scenes, weachieved a rendering performance of up to 15 frames persecond. Furthermore, interactive frame rates were stillpossible for large scenes.

Table 2. Measured performance data of our example scenes fordifferent subdivision levels. Even with hundreds of thousands oftriangles we achieve reasonable fast preprocessing within a fewminutes and still ray trace at interactive frame rates

Preprocessing time in secsScene #tris Sampling Building kd-trees fps

Cally 3k 0.63 0.65 9.5Cally 10k 1.80 2.28 7.1Cally 30k 5.21 8.77 5.7Cally 90k 16.4 34.5 3.6Cally 271k 50.4 150 2.0UT 2003 2k 0.59 0.39 15.5UT 2003 7k 1.23 1.67 12.3UT 2003 22k 3.08 6.41 7.4UT 2003 67k 8.63 23.8 4.0UT 2003 200k 29.7 88.9 1.9


Günther et al. [10] compared their fuzzy kd-tree fora predefined animation with highly optimized kd-trees canbe prebuilt for every time-step. Our results are congru-ent with their reported numbers: The more flexible fuzzykd-trees degrade rendering performance approximately bya reasonable factor of two.

5 Discussion and conclusions

We have presented a novel algorithmic approach to effi-ciently ray trace skinned meshes. We use a small top-levelkd-tree and bone transformations to account for the dom-inating deformations of the mesh. As the residual motionof triangles can be handled by fuzzy kd-trees, we avoid al-most completely the costly reconstruction of accelerationstructures. As a result, we are able to achieve interactiveframe rates even for high polygonal models.

Supporting skinned meshes rather than only predefinedanimations as in [10] has several advantages:

– The preprocessing time is greatly reduced. For prede-fined animations an expensive clustering step is neces-sary to find coherent moving triangles.

– We save a lot of memory because we just need one basemesh for the entire animation, plus the correspondingbones and skinning information, in contrast to manymeshes, one for every time-step.

– The most important advantage is the gained flexibil-ity: With skinned meshes it is no problem to smoothlyinterpolate between key frames or to blend severalanimation sequences. Even direct user interaction ispossible if we sample the (optionally limited) posespace.

6 Future work

One direction for future work is the investigation of raytracing even more general types of animations such asblending meshes or meshes deformed by physical simula-tions. For example, ray tracing the cloth worn by a gamecharacter is not yet possible with our method.

Under-sampling of the pose space can lead to underes-timation of the fuzzy boxes and consequently to renderingartifacts. Thus instead of sampling the pose space it mightbe desirable to find the extent of the fuzzy boxes ana-lytically or by using affine arithmetic. Nevertheless, inpractice we noticed no such artifacts when using a moder-ate number of samples (i.e. one sample per key frame, seealso Table 1).

With the advancements in ray traversal and intersectionperformance, the actual shading of the hit-points alreadybecame the bottleneck. Thus it is not yet possible to runa fully featured ray tracing system at interactive framerates on a single CPU. Advanced ray tracing effects, suchas glossy reflections, soft shadows, or global illumina-tion still require the combined power of many processors– even with static scenes. Thus it is desirable to furtherresearch the acceleration of distribution ray tracing andshading operations.

It has been shown by Yoon and Manocha [35] thata cache-efficient layout of BVHs significantly increasesray tracing performance. Certainly the same idea shouldbe applicable to (fuzzy) kd-trees.

It would also be interesting to compare our approach ofusing approved kd-trees for ray tracing dynamic scenes toother acceleration structures, such as grids or BVHs thatcan be quickly updated.

References1. Amanatides, J., Woo, A.: A fast voxel

traversal algorithm for ray tracing. In:Proceedings of Eurographics, pp. 3–10.Eurographics Association(1987)

2. Appel, A.: Some techniques for shadingmachine renderings of solids. In: AF/PSConference Proceedings (Springer JointComputer Conference), vol. 32, pp. 37–45.Thompson Book Company, Washington,DC (1968)

3. ATI: The ATI homepage.http://www.ati.com/

4. Cal3D: 3D character animation library.https://gna.org/projects/cal3d/

5. Carr, N.A., Hoberock, J., Crane, K., Hart,J.C.: Fast GPU ray tracing of dynamicmeshes using geometry images. In:Proceedings of Graphics Interface. A.K.Peters, Wellesley, MA (2006)

6. Cleary, J., Wyvill, B., Birtwistle, G., Vatti,R.: A parallel ray tracing computer. In:Proceedings of the Association of Simula

Users Conference, pp. 77–80. CanadianInformation Processing Society,Mississauge, ON (1983)

7. Foley, T., Sugerman, J.: KD-treeacceleration structures for a GPU raytracer.In: HWWS ’05 Proceedings, pp. 15–22.ACM Press, New York (2005)

8. Glassner, A.S.: Space subdivision for fastray tracing. IEEE Comput. Graph. Appl.4(10), 15–22 (1984)

9. Goodnight, N., Wang, R., Woolley, C.,Humphreys, G.: Interactive time-dependenttone mapping using programmable graphicshardware. In: Christensen, P.H., Cohen-Or,D. (eds.) Proceedings of the 2003Eurographics Symposium on Rendering,pp. 26–37. Eurographics Association,Aire-la-Ville, Switzerland (2003)

10. Günther, J., Friedrich, H., Wald, I., Seidel,H.P., Slusallek, P.: Ray tracing animatedscenes using motion decomposition.Comput. Graph. Forum 25(3) (2006).(Proceedings of Eurographics) (to appear,

preprint available athttp://www.mpi-inf.mpg.de/∼guenther/modecomp/)

11. Havran, V.: Heuristic Ray ShootingAlgorithms. Ph.D. thesis, Faculty ofElectrical Engineering, Czech TechnicalUniversity in Prague (2001)

12. Havran, V., Prikryl, J., Purgathofer, W.:Statistical comparison of ray-shootingefficiency schemes. Tech. Rep.TR-186-2-00-14, Department of ComputerScience, Czech Technical University;Vienna University of Technology (2000)

13. Intel Corp.: Intel Pentium III StreamingSIMD Extensions.http://developer.intel.com/vtune/cbts/simd.htm (2002)

14. Jansen, F.W.: Data structures for raytracing. In: Proceedings of the Workshopon Data structures for Raster Graphics, pp.57–73. Springer, New York, NY (1986)

15. Lauterbach, C., Yoon, S.E., Tuft, D.,Manocha, D.: RT-DEFORM Interactive


Ray tracing of dynamic scenes usingBVHs. Technical Report TR06-010,Department of Computer ScienceUniversity of North Carolina (2006). URLhttp://gamma.cs.unc.edu/BVH/. (availableat http://gamma.cs.unc.edu/BVH/)

16. Lext, J., Akenine-Möller, T.: Towards rapidreconstruction for animated ray tracing. In:Eurographics 2001 – Short Presentations,pp. 311–318 (2001)

17. Lext, J., Assarsson, U., Möller, T.: BART:A benchmark for animated ray tracing.Tech. Rep., Department of ComputerEngineering, Chalmers University ofTechnology, Göteborg, Sweden (2000).Available at http://www.ce.chalmers.se/BART/

18. MacDonald, J.D., Booth, K.S.: Heuristicsfor ray tracing using space subdivision. In:Proceedings of Graphics Interface, pp.152–63. A.K. Peters, Wellesley, MA (1989)

19. Magnenat-Thalmann, N., Laperrière, R.,Thalmann, D.: Joint-dependent localdeformations for hand animation and objectgrasping. In: Proceedings of GraphicsInterface ’88, pp. 26–33. CanadianInformation Processing Society, Toronto,Ont., Canada (1988)

20. Magnenat-Thalmann, N., Thalmann, D.:Human body deformations usingjoint-dependent local operators andfinite-element theory, pp. 243–262. MorganKaufmann, San Francisco, CA (1991)

21. Pharr, M., Humphreys, G.: PhysicallyBased Rendering: From Theory toImplementation. Morgan Kaufman, SanFrancisco, CA (2004)

22. Reinhard, E., Smits, B., Hansen, C.:Dynamic acceleration structures forinteractive ray tracing. In: Proceedings ofthe Eurographics Workshop on Rendering,pp. 299–306. Brno, Czech Republic (2000)

23. Reshetov, A., Soupikov, A., Hurley, J.:Multi-level ray tracing algorithm. ACMTrans. Graph. 24(3), 1176–1185 (2005).(Proceedings of ACM SIGGRAPH)

24. Rubin, S.M., Whitted, T.:A three-dimensional representation for fastrendering of complex scenes. Comput.Graph. 14(3), 110–116 (1980)

25. Schmittler, J., Wald, I., Slusallek, P.:SaarCOR – A hardware architecture for raytracing. In: Proceedings of the ACMSIGGRAPH/Eurographics Conference onGraphics Hardware, pp. 27–36 (2002)

26. Wächter, C., Keller, A.: Instant ray tracing:The bounding interval hierarchy. In:Rendering Techniques 2006, Proceedings ofthe Eurographics Symposium on Rendering(2006)

27. Wald, I.: Realtime Ray Tracing andInteractive Global Illumination. Ph.D.thesis, Computer Graphics Group, SaarlandUniversity (2004)

28. Wald, I., Benthin, C., Slusallek, P.:Distributed interactive ray tracing ofdynamic scenes. In: Proceedings of theIEEE Symposium on Parallel andLarge-Data Visualization and Graphics(PVG), pp. 77–86 (2003)

29. Wald, I., Boulos, S., Shirley, P.: Ray tracingdeformable scenes using dynamic boundingvolume hierarchies. SCI Institute Technical

Report UUSCI-2006-015, University ofUtah (2006). (conditionally accepted forACM Trans. Graph., preprint available athttp://www.sci.utah.edu/∼wald/Publications/webgen/2006/BVH/download/togbvh.pdf)

30. Wald, I., Havran, V.: On building fastkd-trees for ray tracing, and on doing thatin O(N log N). In: Proceedings of the 2006IEEE Symposium on Interactive RayTracing (2006)

31. Wald, I., Ize, T., Kensler, A., Knoll, A.,Parker, S.G.: Ray tracing animated scenesusing coherent grid traversal. ACM Trans.Graph. 25(3), 485–493 (2006)

32. Wald, I., Slusallek, P., Benthin, C., Wagner,M.: Interactive rendering with coherent raytracing. Comput. Graph. Forum 20(3),153–164 (2001). (Proceedings ofEurographics)

33. Woop, S., Marmitt, G., Slusallek, P.: B-kdtrees for hardware accelerated ray tracingof dynamic scenes. In: Proceedings ofGraphics Hardware (2006), to appear

34. Woop, S., Schmittler, J., Slusallek, P.: RPU:A Programmable ray processing unit forrealtime ray tracing. In: Proceedings ofACM SIGGRAPH, vol. 24(3), pp. 434–444.ACM Press, New York, NY, USA (2005)

35. Yoon, S.E., Manocha, D.: Cache-efficientlayouts of bounding volume hierarchies.Comput. Graph. Forum 25(3) (2006), toappear


JOHANNES GÜNTHER is currently a PhD stu-dent at the Computer Graphics Group at theMax-Planck-Institute for Computer Science inSaarbrücken, Germany. In 2004, he finished hisdiploma thesis on real-time photon mapping forcaustic illumination at the Saarland University.Before 2003 he studied physics and computerscience at the Chemnitz University of Technol-ogy and worked as an intern at the Technion –Israel Institute of Technology, Haifa. His mainresearch interests are real-time global illumina-tion and ray tracing.

HEIKO FRIEDRICH is currently a PhD studentat the Computer Graphics Group at SaarlandUniversity in Saarbrücken, Germany. In 2004,he finished his Master’s thesis on real-time iso-surface ray tracing. Before doing so, he receiveda Bachelor’s degree from Saarland State Uni-versity in 2002, and worked as an intern atthe Imaging and Visualization Department of

Siemens Corporate Research in Princeton/USA.His main research interests are real-time volumerendering and ray tracing.

HANS-PETER SEIDEL studied mathematics,physics and computer science at the Universityof Tübingen, Germany. He received his PhDin mathematics in 1987, and his habilitationdegree in computer science in 1989, both fromthe University of Tübingen. From 1989, he wasan assistant professor at the University of Wa-terloo, Canada. In 1992, he was appointed tothe University of Erlangen-Nürnberg, Germany.Since 1999 he has been director of the ComputerGraphics Group at the Max-Planck-Institute forComputer Science and cross-appointed to Saar-land University in Saarbrücken, Germany. In hisresearch, Seidel investigates algorithms for 3Dimage analysis and synthesis. This involves thecomplete processing chain from data acquisitionover geometric modeling to image synthesis. In

2003, Seidel was awarded the Leibniz Preis, themost prestigious German research award, fromthe German Research Foundation (DFG). Seidelwas the first computer graphics researcher toreceive this award. In 2004, he was selectedas founding chair of the Eurographics AwardsProgramme.

PHILIPP SLUSALLEK is full professor at thecomputer graphics laboratory of Saarland Uni-versity. In 1998/99, he was visiting assistant pro-fessor at the Stanford University graphics lab-oratory. His current research activities focus onreal-time ray tracing on off-the-shelf computersand on designing hardware architecture for real-time ray tracing. Other research topics includethe design of a network-aware multi-media in-frastructure, consistent illumination in virtual en-vironments, physically-based and realistic imagesynthesis, and object-oriented software design.

Documents

Interactive ray tracing of skinned animations