Abstract—In many applications, volumetric data sets are examined by displaying isosurfaces, surfaces where the data, or some function of the data, takes on a given value. Interactive applications typically use local lighting models to render such surfaces. This work introduces a method to precompute or lazily compute global illumination to improve interactive isosurface renderings. The precomputed illumination resides in a separate volume and includes direct light, shadows, and interreflections. Using this volume, interactive globally illuminated renderings of isosurfaces become feasible while still allowing dynamic manipulation of lighting, viewpoint and isovalue.

In this paper we present a ray tracing based method for accelerated global illumination computation in scenes with low-frequency glossy BRDFs. The method is based on sparse sampling, caching, and interpolating radiance on glossy surfaces. In particular we extend the irradiance caching scheme proposed by Ward et al. [1] to cache and interpolate directional incoming radiance instead of irradiance. The incoming radiance at a point is represented by a vector of coefficients with respect to a spherical or hemispherical basis. The surfaces suitable for interpolation are selected automatically according to the roughness of their BRDF. We also propose a novel method for computing translational radiance gradient at a point.

This paper presents a GPU-based method for interactive global illumination that integrates complex effects such as multi-bounce indirect lighting, glossy reflections, caustics, and arbitrary specular paths. Our method builds upon scattered data sampling and interpolation on the GPU. We start with raytraced shading points and partition them into coherent shading clusters using adaptive seeding followed by k-means. At each cluster center we apply final gather to evaluate its incident irradiance using GPU-based photon mapping. We approximate the entire photon tree as a compact illumination cut, thus reducing the final gather cost for each ray. The sampled irradiance values are then interpolated at all shading points to produce rendering. Our method exploits the spatial coherence of illumination to reduce sampling cost. We sample sparsely and the distribution of sample points conforms with the underlying illumination changes. Therefore our method is both fast and preserves high rendering quality. Although the same property has been exploited by previous caching and adaptive sampling methods, these methods typically require sequential computation of sample points, making them ill-suited for the GPU. In contrast, we select sample points adaptively in a single pass, enabling parallel computation. As a result, our algorithm runs entirely on the GPU, achieving interactive rates for scenes with complex illumination effects.

Parallelising ray tracing with a data parallel approach allows rendering of arbitrarily large models, but the inherent load imbalances may lead to severe inefficiencies. To compensate for the uneven load distribution, demand-driven tasks may be split off and scheduled to processors that are less busy. We propose a hybrid scheduling algorithm which brings tasks and data together according to coherence between rays. Coherent tasks are scheduled demand driven and the remainder is executed data parallel. This method removes the worst hot-spots from the data parallel component and reschedules those as demand driven tasks, thereby evening out the workload. Processing power, communication and memory are three resources which should be evenly used. Our current implementation is assessed against these requirements. Related issues, such as the distribution of the workload over space and the resulting requirements for the distribution objects over the processors, are investigated as well. Final...

Real-time pixel shading techniques have become increasingly complex, and consume an ever larger share of the graphics processing budget in applications such as games. This has driven the development of optimization techniques that either attempt to simplify pixel shaders, or to cull their evaluation when possible. In this paper, we follow an alternative strategy: reducing the number of shading computations by exploiting spatio-temporal coherence. We describe a simple and inexpensive method that uses the graphics hardware to cache and track surface information through time. The Real-Time Reprojection Cache stores surface information in screen space, thereby avoiding complex data-structures and bus traffic. When a new frame is rendered, reverse mapping by reprojection gives each new pixel access to information computed during the previous frame. Using this idea, we show how to modify a variety of realtime rendering techniques to efficiently exploit spatio-temporal coherence. We present examples that vary as widely as stereoscopic rendering, motion blur, depth of field, shadow mapping, and environment-mapped bump mapping. Since the overhead of a reprojection cache lookup is small in comparison to the required perpixel processing, the cached algorithms show significant cost and/or quality improvements over their plain counterparts, at virtually no extra implementation overhead.

We present a data structure, called a ray interpolant tree, orRI-tree, which stores a discrete set of directed lines in 3-space, each represented as a point in 4-space. Each directed line is associated with some small number of continuous geometric attributes. We show how this data structure can be used for answering interpolation queries, in which we are given an arbitrary ray in 3-space and wish to interpolate the attributes of neighboring rays in the data structure. We illustrate the practical value of the RI-tree in two applications from computer graphics: ray tracing and volume visualization. In particular, given objects defined by smooth curved surfaces, the RI-tree can produce high-quality renderings significantly faster than standard methods. We also investigate a number of tradeoffs between the space and time used by the data structure and the accuracy of the interpolation results.

In computer graphics, bright patterns of light focused onto matte surfaces are called "caustics". We present a method for rendering dynamic scenes with moving caustics at interactive rates. This technique requires some simplifying assumptions about caustic behavior allowing us to consider it a local spatial property which we sample in a pre-processing stage. Storing the caustic locally limits caustic rendering to a simple lookup. We examine a number of ways to represent this data, allowing us to trade between accuracy, storage, run time, and precomputation time.

Abstract not found

Improvements in hardware have recently made interactive ray tracing practical for some applications. However, when the scene complexity or rendering algorithm cost is high, the frame rate is too low in practice. Researchers have attempted to solve this problem by caching results from ray tracing and using these results in multiple frames via reprojection. However, the reprojection can become too slow when the number of samples that are reused is high, so previous systems have been limited to small images or a sparse set of computed pixels. To overcome this problem we introduce techniques to perform this reprojection in a scalable fashion on multiple processors.

In this paper we present two new algorithms to progressively preview an image accounting for global illumination effects while it is being rendered. These algorithms are based on a partition of the image plane using a conductance map, able to represent strong boundaries---the properties vary significantly on either side of each boundary. The eye radiances are then computed at well chosen points of the resulting triangulation, using some homogeneity measure to steer the adaptive sampling scheme. The proposed algorithms are efficient and easy to implement.