Fast GPU Ray Tracing of Dynamic Meshes using Geometry Images (original) (raw)
Related papers
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.
Whitted ray-tracing for dynamic scenes using a ray-space hierarchy on the GPU
2007
In this paper, we present a new algorithm for interactive rendering of animated scenes with Whitted Ray-Tracing, running on the GPU. We focus our attention on the secondary rays (the rays generated by one or more bounces on specular objects), and use the GPU rasterizer for primary rays. Our algorithm is based on a ray-space hierarchy, allowing us to handle truly dynamic scenes without the need to rebuild or update the scene hierarchy. The rayspace hierarchy is entirely built on the GPU for every frame, using a very fast process. Traversing the ray-space hierarchy is also done on the GPU; one of the benefits of using a ray-space hierarchy is that we have a single shader, and a fixed number of passes. After traversing each level of the hierarchy, we prune empty branches using a stream reduction method. We present two different stream reduction methods, a fast one using a hierarchical algorithm, and an easy one using the Geometry shaders. Our algorithm results in interactive rendering with specular reflections and shadows for moderately complex scenes (∼ 700K triangles), handles any kind of dynamic or unstructured scenes without any pre-processing, and scales well with both the scene complexity and the image resolution.
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-optimized Ray-tracing for Constructive Solid Geometry Scenes
2016
A novel GPU-optimized CSG ray tracing approach is proposed that is fast and accurate and achieves real-time frame rates for complex CSG models. The algorithm is suitable for primitives defined by tessellation either analytically, has no limitations on the number of CSG primitives and produces the image in single pass. We also propose two-pass procedure for transforming the input tree into spatially coherent and well-balanced form. With these optimizations, the algorithm becomes compute-bound and scales well with additional GPU power (in contrast to multi-pass CSG algorithms). Through various experiments, we show that our solution allows interactive rendering of scenes with more than a million CSG primitives on consumer graphics cards, and as far as we know, this is the fastest general CSG algorithm.
Ray Tracing Acceleration using Displacement Fields on GPU
2016
Ray Tracing is a rendering method for the presentation of three dimensional images on two dimensional displays. One of the greatest challenges of ray tracing is efficient execution, since many times the method is dismissed as being too computationally expensive. In the current work we present the application of a novel method to accelerate the most intensive part of the computation of secondary-rays (reflection, refraction and shadow rays) the ray-primitive intersection tests. The main idea behind this acceleration technique is the use of four-dimensional fields (displacement fields) for each object that describe the distance from an augmented bounding sphere to the actual object surface, in every direction, for all positional samples on the sphere. Ray tracing is accelerated by replacing the often numerous distance-sorted ray-polygon hit queries, by a simple and of constant time displacement field indexing mechanism. Furthermore the GPU implementation of the method allows the explo...
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++.
Fast Compression of Meshes for GPU Ray-Tracing
WSCG 2013, 2013
We present a novel and expedite way to compress triangles meshes, fans and strips for ray-tracing on a GPU. Our approach improves on the state of the art by allowing the lossless compression of all connectivity information without changing the mesh configuration, while using linear time and space with the number of primitives. Furthermore, the algorithm can be run on a stream processor and any compressed primitive can be indexed in constant time, thus allowing fast random-access to geometry data to support ray-tracing on a GPU. Furthermore, both triangle and quad meshes compress particularly well, as do many type-specialized mesh structures where all primitives have an equal number of vertexes. Our results show that the compression algorithm allows storing and ray-tracing meshes with tens of millions of triangles on commodity GPUs with only 1GB of memory.
IEEE Software, 2011
The Ray Tracing rendering algorithm can produce high-fidelity images of 3-D scenes, including shadow effects, as well as reflections and transparencies. This is currently done at a processing speed of at most 30 frames per second. Therefore, actual implementations of the algorithm are not yet suitable for interactive real-time rendering, which is required in games and virtual reality based applications. Fortunately, the algorithm allows for massive parallelization of its computations. In this paper, we present a parallel architecture for ray tracing based on a uniform spatial subdivision of the scene and exploiting an embedded computation of ray-triangle intersections. This approach allows for a significant acceleration of intersection computations, as well as, a reduction of the total number of the required intersections checks. Furthermore, it allows for these checks to be performed in parallel and in advance for each ray. In this paper we discuss and analyze an ASIP-based implementation using FPGAs and a GPGPU-based parallel implementation of the proposed architecture. The performance of both implementations are reported and compared.
Non-Homogeneous Grids for CPU-GPU Ray Tracing
Ray tracing is among the most resource consuming methods for realistic image generation. Over the years, different acceleration structures have been proposed to reduce ray-object intersection queries since these dominate execution time. Regular grids are one of the most popular structures due to their simplicity and effectiveness. However, regular grid implementations are plagued by two major issues: underwhelming performance on irregular scenes with unbalanced triangle density and high memory consumption due to the many empty cells in sparsely populated scenes, typical of many game scenarios. We present a novel hybrid solution based on non-homogeneous rectilinear grids to improve ray tracing performance on uneven scene distributions. Additionally, we use hashing to get rid of empty cells. Non-homogeneous grids feature moveable split planes along the three axes unlike regular grids where split planes must be equidistant. Our approach performs serial construction tasks such as compression in the CPU and offloads the remaining data parallel tasks to the GPU. Using this acceleration structure we are able to render a wide range of scenes at high frame rates on commodity graphics hardware, from irregular density low polygon count models to regular density high polygon count scanned scenes with rapid construction times and a small memory footprint. For some test cases, our approach nearly doubles the frame rate of a regular grid at a similar resolution, while featuring low build times.
GPU-Based Data Structure for a Parallel Ray Tracing Illumination Algorithm
2011 Brazilian Symposium on Games and Digital Entertainment, 2011
Ray tracing is a largely employed technique for generating computer images with high fidelity and realism. However, this technique is very costly, mainly because of the intersection calculations made by the algorithm. Still, ray tracing is a highly parallelizable algorithm, since the calculations for a single light ray are independent from the others. This way, the implementation of the ray tracing on the GPU is a natural process. Data structures can be employed for reducing the processing load of the ray tracing algorithm, minimizing the number of intersection calculations. In recent works, these structures are being ported to the GPU, so they can be used to accelerate various parallel algorithms. In this work, we proposed a GPU ray tracing implementation using an octree as acceleration structure. Every single step of the algorithm runs in parallel on the GPU, so the communication bottleneck between the GPU and the CPU is eliminated. This work also proposes the study of which is the best way to represent the octree on the GPU, by comparing two different approaches.