Whitted ray-tracing for dynamic scenes using a ray-space hierarchy on the GPU (original) (raw)
Related papers
Lecture Notes in Computer Science, 2012
Rendering in 3D games typically uses rasterization approaches in order to guarantee interactive frame rates, since ray tracing, a superior method for rendering photorealistic images, has greater computational cost. With the advent of massively parallel processors in the form of GPUs, parallelized ray tracing have been investigated as an alternative to rasterization techniques. While many works present parallelization methods for the classical ray tracing algorithm, in order to achieve interactive, or even real time ray tracing rendering, we present a rasterized and ray traced hybrid technique, completely done in GPU. While a deferred render model determines the colors of primary rays, a ray tracing phase compute other effects such as specular reflection and transparency, in order to achieve effects that are not easily obtained with rasterization. We also present a heuristic approach that select a subset of relevant objects to be ray traced, avoiding traversing rays for objects that might not have a significant contribution to the real time experience. This selection is capable of maintaining the real time requirement of games, while offering superior visual effects. possibility to accelerate ray tracing in order to make it a real-time process with GPU only or hybrid CPU and GPU approaches. However, results of different investigations indicate that RTRT remains a challenging computational task , suitable only with specific conditions and constraints.
GPU-based Ray Tracing of Dynamic Scenes
2010
This paper presents the design and implementation of a GPU-based ray tracing system for dynamic scenes consisting of a set of individual, non-deformable objects. The triangles of each object are organized in a separate Kd-tree. A bounding volume hierarchy (BVH) is built on top of these Kd-trees. The BVH is updated and uploaded into GPU memory on a frame-by-frame basis, whereas the Kd-trees are uploaded only once. We use a single ray tracing kernel for handling all ray generations. Code execution path divergence is limited by the use of a ray stack, which treats all ray types in the same way. We make effective use of the very limited high bandwidth memory of the GPU's multiprocessors by using a smart stack for the acceleration structure traversals. The results show that our GPU implementation of a two-level acceleration approach performs between 40 and 105 percent as fast as a single Kd-tree containing the entire scene.
HART: A Hybrid Architecture for Ray Tracing Animated Scenes
IEEE Transactions on Visualization and Computer Graphics, 2015
We present a hybrid architecture, inspired by asynchronous BVH construction [1], for ray tracing animated scenes. Our hybrid architecture utilizes heterogeneous hardware resources: dedicated ray-tracing hardware for BVH updates and ray traversal and a CPU for BVH reconstruction. We also present a traversal scheme using a primitive's axis-aligned bounding box (PrimAABB). This scheme reduces ray-primitive intersection tests by reusing existing BVH traversal units and the primAABB data for tree updates; it enables the use of shallow trees to reduce tree build times, tree sizes, and bus bandwidth requirements. Furthermore, we present a cache scheme that exploits consecutive memory access by reusing data in an L1 cache block. We perform cycle-accurate simulations to verify our architecture, and the simulation results indicate that the proposed architecture can achieve real-time Whitted ray tracing animated scenes at 1920×1200 resolution. This result comes from our highperformance hardware architecture and minimized resource requirements for tree updates. Index Terms-Ray tracing, bounding volume hierarchy, dynamic scene, graphics hardware ! 1 INTRODUCTION Recently, a great deal of research has been conducted to achieve ray tracing dynamic scenes at interactive rates [2]. In dynamic scenes, objects can be moved, added or deleted from a scene, or animated with topological changes. Because most ray-tracing systems are based on acceleration data structures, such as kdtrees, bounding volume hierarchies (BVHs), and grids, these acceleration data structures should be effectively updated for dynamic scenes. Many researchers have exploited CPUs [1], [3]-[11], GPUs [12]-[16], MIC (many integrated core) [11], [17], or dedicated raytracing hardware [18]-[20] to achieve this goal. However, most current real-time rendering engines (e.g. game engines) use techniques based on rasterization instead of ray tracing. This means that current ray-tracing systems still do not provide sufficient performance for the real-time rendering of dynamic scenes on commodity hardware. To achieve ray-tracing in dynamic scenes at real-time rates, there are two requirements: to get high-quality effects, the ray traversal performance must be high; and there must be fast acceleration-data-structure updates that do not degrade the tree quality. To achieve these two goals, we present a hybrid ray-tracing architecture based on the BVH. In this
GPU-Assisted Ray Casting of Large Scenes
2006 IEEE Symposium on Interactive Ray Tracing, 2006
We implemented a pipelined rendering system that pre-renders a reduced set of a scene using the raster method built in the graphics hardware. The computation performed by the graphics card is used as an estimate for evaluating the initial traversal points for a ray caster running on the CPU. This procedure replaces the use of complex spatial subdivision structures for primary rays, offloading work that would traditionally be executed by the CPU and leaving additional system memory available for loading extra scene data. The ray traversal algorithm skips even narrow empty spaces, which are usually hard to map using conventional spatial subdivision. We achieved interactive frame rates (3-10 frames/s) running the system on a single computer with conventional hardware.
In this paper I present a way to implement Whitted style ("classic") recursive ray tracing on current generation consumer level GPUs using the OpenGL Shading Language (GLSL) and the Direct3D High Level Shading Language (HLSL). Ray tracing is implemented using a simplified, abstracted stream programming model for the GPU, written in C++.
Temporally Coherent Interactive Ray Tracing
Journal of Graphics Tools, 2002
Although ray tracing has been successfully applied to interactively render large datasets, supersampling pixels will not be practical in interactive applications for some time. Because large datasets tend to have subpixel detail, one-sample-per-pixel ray tracing can produce visually distracting popping and scintillation. We present an algorithm that directs primary rays toward locations rendered in previous frames, thereby increasing temporal coherence. Our method tracks intersection points over time, and these tracked points are used as an oracle to aim rays for the next frame. This is in contrast to traditional image-based rendering techniques which advocate color reuse. We so acquire coherence between frames which reduces temporal artifacts without introducing significant processing overhead or causing unnecessary blur.
Efficient Use of In-Game Ray-Tracing Techniques
Figure 1: Stages of our hybrid ray-tracing implementation. (a) shows a visual representation of primary rays intersections, (b) shows only the visible pixels of ray-traced objects. (c) shows the Sponza scene rasterized using a simple directional light by the using of the traditional graphics pipeline. Finally, (d) shows the final scene representation obtained by merging images (b) and (c). The Sponza scene has 44.404 vertices and 67.462 triangles. The Stanford Bunny has 34.834 vertices and 69.451 triangles. The complete scene has 114.072 vertices and 206.364 triangles. The total number of valid rays is 66.252 rendered at 10 frames per second.
Ray Tracing Animated Scenes using Motion Decomposition
Computer Graphics Forum, 2006
Figure 1: Example images from animations ray traced in realtime. From left to right: HAND, BEN, CHICKEN, COW, and DOLPHIN. The color encodes separated clusters generated by our motion decomposition algorithm. All animations combine flexible non-affine body motion from skinning, and other deformations. They can be ray traced with 5 to 15 frames per second at 1024 2 on a single CPU.