The render cache and the edge-and-point image (EPI) are alternative point-based rendering techniques that combine interactive performance with expensive, high quality shading for complex scenes. They use sparse sampling and intelligent reconstruction to enable fast framerates and to decouple shading from the display update. We present a hybrid CPU/GPU multi-pass system that accelerates these techniques by utilizing programmable graphics processing units (GPUs) to achieve better framerates while freeing the CPU for other uses such as high-quality shading (including global illumination). Because the render cache and EPI differ from the traditional graphics pipeline in interesting ways, we encountered several challenges in using the GPU effectively. We discuss our optimizations to achieve good performance, limitations with the current generation hardware, as well as possibilities for future improvements.

Figure 1: Comparison of different upsampling schemes in a fully dynamic scene with complex shading (indirect light and ambient occlusion). Pixel processing is becoming increasingly expensive for real-time applications due to the complexity of today’s shaders and highresolution framebuffers. However, most shading results are spatially or temporally coherent, which allows for sparse sampling and reuse of neighboring pixel values. This paper proposes a simple framework for spatio-temporal upsampling on modern GPUs. In contrast to previous work, which focuses either on temporal or spatial processing on the GPU, we exploit coherence in both. Our algorithm combines adaptive motion-compensated filtering over time and geometry-aware upsampling in image space. It is robust with respect to high-frequency temporal changes, and achieves substantial performance improvements by limiting the number of recomputed samples per frame. At the same time, we increase the quality of spatial upsampling by recovering missing information from previous frames. This temporal strategy also allows us to ensure that the image converges to a higher quality result. 1

Ray tracing acceleration techniques most often consider only static scenes, neglecting the processing time needed to build the acceleration data structure. With the development of interactive ray tracing systems, this reconstruction time becomes a serious bottleneck if concerned with dynamic scenes. In this paper, we describe two strategies for efficient updating of bounding volume hierarchies (BVH) for scenarios with arbitrarily moving objects. The first exploits spatial locality in the object distribution for faster reinsertion of the moved objects. The second allows insertion and deletion of objects at almost constant time by using a hybrid system, which combines benefits from both spatial subdivision and BVHs. Depending on the number of moving objects, our algorithms adjust a dynamic BVH six to one hundred times faster than it would take to rebuild the complete hierarchy, while rendering times of the resulting hierarchy remain almost untouched.

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.

Ray traced images of geometrically and optically highly complex natural environments: All scenes contain massive amounts of geometry (more than 1.5 billion triangles). Caching samples on-the-fly in world-space spatial index structures that are already present for efficient ray tracing allows for efficiently reusing samples without any precomputation, and thus significantly increasing image quality as well as rendering performance in both offline and online applications. Ray tracing is known for its photorealistic image quality and logarithmic scalability with scene size. In particular, ray tracing is considered output sensitive and only weakly dependent on scene complexity, because only (indirectly) visible parts of the scene are considered in the computations. However, ray tracing is still tightly coupled to the complexity of the visible parts of the scene, including their geometric complexity, which might require high oversampling to avoid spatial and temporal aliasing. Additionally, photorealistic images often require highly complex and costly shading and lighting computations that can dramatically increase the cost of each ray. We propose a novel world-space sample cache that leverages spatial index structures already present for ray tracing for temporarily storing the results of expensive visibility, shading, and illumination computations. By creating and adaptively updating the cache during rendering, no preprocessing is required. Reusing these samples in later frames minimizes these costly computations, and allows for significantly increasing image quality as well as rendering performance in both offline and interactive applications.

We present a novel 3D scanning system with the potential for interactive acquisition and visualization of dynamic scenes. Our system uses a spatiotemporally adaptive sampling strategy, and can take advantage of multiple simultaneous scanning devices operating at different resolutions. We also employ a level set framework for reconstructing potentially dynamic scenes from multiple concurrent streams of range data. In our framework, implicit surfaces are reconstructed periodically from new samples on a coarse grid, creating a sequence of reconstructions from disjoint sample sets that is used to estimate motion in the scene. A high-resolution reconstruction proceeds alongside, where the surface is evolved by a convective flow that guides it towards the sample set. We employ a spatially-varying distance metric based on our motion estimate that adaptively controls the contribution of older samples to the final reconstruction.

A non-isotropic hybrid image/model based gaze-contingent rendering technique utilizing ray casting on a GPU is discussed. Empirical evidence derived from human subject experiments indicates an inverse relationship between a peripherally degraded scene’s high-resolution inset size and mean search time, a trend consis-tent with existing image-based and model-based techniques. In addition, the data suggest that maintaining a target’s silhouette edges decreases search times when compared to targets with degraded edges. Benefits of the hybrid technique include simplicity of design and parallelizability, both conducive to GPU implementation.

This paper introduces a framebuffer level of detail algorithm for controlling the pixel workload in an interactive rendering application. Our basic strategy is to evaluate the shading in a low resolution buffer and, in a second rendering pass, resample this buffer at the desired screen resolution. The size of the lower resolution buffer provides a trade-off between rendering time and the level of detail in the final shading. In order to reduce approximation error we use a feature-preserving reconstruction technique that more faithfully approximates the shading near depth and normal discontinuities. We also demonstrate how intermediate components of the shading can be selectively resized to provide finer-grained control over resource allocation. Finally, we introduce a simple control mechanism that continuously adjusts the amount of resizing necessary to maintain a target framerate. These techniques do not require any preprocessing, are straightforward to implement on modern GPUs, and are shown to provide significant performance gains for several pixel-bound scenes. Categories and Subject Descriptors (according to ACM CCS): I.3.3 [Computer Graphics]: Picture/Image Generation 1. Introduction and Related

Abstract We report on a light-field display based virtual environment enabling multiple naked-eye users to perceive detailed multi-gigavoxel volumetric models as floating in space, responsive to their actions, and delivering different information in different areas of the workspace. Our contributions include a set of specialized interactive illustrative techniques able to provide different contextual information in different areas of the display, as well as an out-of-core CUDA based raycasting engine with a number of improvements over current GPU volume raycasters. The possibilities of the system are demonstrated by the multi-user interactive exploration of 64GVoxels datasets on a 35MPixel light field display driven by a cluster of PCs. 1

Several optimization results produced with our system. Each image compares (top) an input pixel shader to (bottom) a version modified to cache and reuse some partial shading computations over consecutive frames. Our system automatically selects the intermediate values to be reused and the rate at which cached entries are refreshed so as to maximize performance improvement while minimizing (inset) the visual error injected into the final shading. We present a framework and supporting algorithms to automate the use of data reprojection as a general tool for optimizing procedural shaders. Although the general strategy of caching and reusing expensive intermediate shading calculations across consecutive frames has previously been shown to provide an effective trade-off between speed and accuracy, the critical choices of what to reuse and at what rate to explicitly refresh cached entries have always been left to a designer. The fact that these decisions require a deep understanding of a procedure’s semantic structure makes it challenging to select optimal candidates among possibly hundreds of alternatives. Our automated approach relies on parametric models of the way possible caching decisions affect the shader’s performance and visual fidelity. These models are trained using a sample rendering session and drive an interactive profiler in which the user can explore the error/performance trade-offs associated with incorporating temporal reprojection. We evaluate the proposed models and selection algorithm with a prototype system used to optimize several complex shaders; in each case we observed a significant performance improvement. We also compare our approach to current alternatives. 1