Abstract: Interactive volume rendering in its standard formulation has become an increasingly important tool in many application domains. In recent years several advanced volumetric illumination techniques to be used in interactive scenarios have been proposed. These techniques claim to have perceptual benefits as well as being capable of producing more realistic volume rendered images. Naturally, they cover a wide spectrum of illumination effects, including varying shading and scattering effects. In this survey, we review and classify the existing techniques for advanced volumetric illumination. The classification will be conducted based on their technical realization, their performance behaviour as well as their perceptual capabilities. Based on the limitations revealed in this review, we will define future challenges in the area of interactive advanced volumetric illumination.

Abstract: Recent years have seen increasing attention and significant progress in many-light rendering, a class of methods for efficient computation of global illumination. The many-light formulation offers a unified mathematical framework for the problem reducing the full lighting transport simulation to the calculation of the direct illumination from many virtual light sources. These methods are unrivaled in their scalability: they are able to produce plausible images in a fraction of a second but also converge to the full solution over time. In this state-of-the-art report, we give an easy-to-follow, introductory tutorial of the many-light theory; provide a comprehensive, unified survey of the topic with a comparison of the main algorithms; discuss limitations regarding materials and light transport phenomena and present a vision to motivate and guide future research. We will cover both the fundamental concepts as well as improvements, extensions and applications of many-light rendering.

Abstract: Great advancements in commodity graphics hardware have favoured graphics processing unit GPU-based volume rendering as the main adopted solution for interactive exploration of rectilinear scalar volumes on commodity platforms. Nevertheless, long data transfer times and GPU memory size limitations are often the main limiting factors, especially for massive, time-varying or multi-volume visualization, as well as for networked visualization on the emerging mobile devices. To address this issue, a variety of level-of-detail LOD data representations and compression techniques have been introduced. In order to improve capabilities and performance over the entire storage, distribution and rendering pipeline, the encoding/decoding process is typically highly asymmetric, and systems should ideally compress at data production time and decompress on demand at rendering time. Compression and LOD pre-computation does not have to adhere to real-time constraints and can be performed off-line for high-quality results. In contrast, adaptive real-time rendering from compressed representations requires fast, transient and spatially independent decompression. In this report, we review the existing compressed GPU volume rendering approaches, covering sampling grid layouts, compact representation models, compression techniques, GPU rendering architectures and fast decoding techniques.

Abstract: Redundancy is at the heart of graphical applications. In fact, generating an animation typically involves the succession of extremely similar images. In terms of rendering these images, this behavior translates into the creation of many fragment programs with the exact same input data. We have measured this fragment redundancy for a set of commercial Android applications, and found that more than 40% of the fragments used in a frame have been already computed in a prior frame.In this paper we try to exploit this redundancy, using fragment memoization. Unfortunately, this is not an easy task as most of the redundancy exists across frames, rendering most HW based schemes unfeasible. We thus first take a step back and try to analyze the temporal locality of the redundant fragments, their complexity, and the number of inputs typically seen in fragment programs. The result of our analysis is a task level memoization scheme, that easily outperforms the current state-of-the-art in low power GPUsMore specifically, our experimental results show that our scheme is able to remove 59.7% of the redundant fragment computations on average. This materializes to a significant speedup of 17.6% on average, while also improving the overall energy efficiency by 8.9% on average.

Abstract: For a long time, GPUs have primarily been optimized to render more and more triangles with increasingly flexible shading. However, scene data itself has typically been generated on the CPU and then uploaded to GPU memory. Therefore, widely used techniques that generate geometry at render time on demand for the rendering of smooth and displaced surfaces were not applicable to interactive applications. As a result of recent advances in graphics hardware, in particular the GPU tessellation unit’s ability to overcome this limitation, complex geometry can now be generated within the GPU’s rendering pipeline on the fly. GPU hardware tessellation enables the generation of smooth parametric surfaces or application of displacement mapping in real-time applications. However, many well-established approaches in offline rendering are not directly transferable, due to the limited tessellation patterns or the parallel execution model of the tessellation stage. In this state of the art report, we provide an overview of recent work and challenges in this topic by summarizing, discussing and comparing methods for the rendering of smooth and highly detailed surfaces in real-time.

Abstract: In this paper we introduce a novel approach for stereoscopic rendering of virtual environments with a wide Field-of-View (FoV) up to 360°. Handling such a wide FoV implies the use of non-planar projections and generates specific problems such as for rasterization and clipping of primitives. We propose a novel pre-clip stage specifically adapted to geometric approaches for which problems occur with polygons spanning across the projection discontinuities. Our approach integrates seamlessly with immersive virtual reality systems as it is compatible with stereoscopy, head-tracking, and multi-surface projections. The benchmarking of our approach with different hardware setups could show that it is well compliant with real-time constraint, and capable of displaying a wide range of FoVs. Thus, our geometric approach could be used in various VR applications in which the user needs to extend the FoV and apprehend more visual information.

Abstract: We present a massively parallel vector graphics rendering pipeline that is divided into two components. The preprocessing component builds a novel adaptive acceleration data structure, the shortcut tree. Tree construction is efficient and parallel at the segment level, enabling dynamic vector graphics. The tree allows efficient random access to the color of individual samples, so the graphics can be warped for special effects. The rendering component processes all samples and pixels in parallel. It was optimized for wide antialiasing filters and a large number of samples per pixel to generate sharp, noise-free images. Our sample scheduler allows pixels with overlapping antialiasing filters to share samples. It groups together samples that can be computed with the same vector operations using little memory or bandwidth. The pipeline is feature-rich, supporting multiple layers of filled paths, each defined by curved outlines (with linear, rational quadratic, and integral cubic Bezier segments), clipped against other paths, and painted with semi-transparent colors, gradients, or textures. We demonstrate renderings of complex vector graphics in state-of-the-art quality and performance. Finally, we provide full source-code for our implementation as well as the input data used in the paper.

Abstract: Contemporary mobile platforms use mobile GPUs for graphics-intensive applications, and deploy proprietary Dynamic Voltage Frequency Scaling (DVFS) policies in an attempt to save energy without sacrificing quality. However, there have been no previous systematic studies to correlate the performance, power, and energy efficiency of mobile GPUs based on diverse graphics workloads to enable more efficient mobile platform DVFS policies for energy savings. For the first time we present a study of mobile GPU graphics workload characterization for DVFS design considering user experience and energy efficiency on a real smart-phone. We develop micro-benchmarks that stress specific stages of the graphics pipeline separately, and study the relationship between varying graphics workloads and resulting energy and performance of different mobile graphics pipeline stages. We use these results to outline opportunities for more efficient, integrated DVFS policies across the mobile GPU, memory and CPU hardware components for saving energy without sacrificing user experience. Our experimental results on the Nexus 4 smartphone show that it is important to characterize GPU hardware and graphics workloads accurately in order to achieve increased energy efficiency without degradation in graphics performance for better user experience. We believe that our observations and results will enable more energy-efficient DVFS algorithms for mobile graphics rendering in the face of rapidly changing mobile GPU architectures.

Abstract: We describe the design of an interactive rendering system for particle-based fluid simulations comprising hundreds of millions of particles per time step. We present a novel binary voxel representation for particle positions in combination with random jitter to drastically reduce memory and bandwidth requirements. To avoid a time-consuming preprocess and restrict the workload to what is seen, the construction of this representation is embedded into front-to-back GPU ray-casting. For high speed rendering, we ray-cast spheres and extend on total-variation-based image de-noising models to smooth the fluid surface according to data specific boundary conditions. The regular voxel structure permits highly efficient ray-sphere intersection testing as well as classification of foam particles at runtime on the GPU. Foam particles are rendered volumetrically by reconstructing densities from the binary representation on-the-fly. The particular design of our system allows scrubbing through high-resolution animated fluids at interactive rates.

Abstract: Graphics resources are shared among a plurality of virtual machines (VMs) running on a host. In one embodiment, a request to create a graphics resource is received from a first VM, the request including a graphics object ID corresponding to the graphics resource to be created. A resource key is generated based on content of the graphics resource and an association is maintained between the graphics object ID and the resource key. If an identical graphics resource does not currently reside in the host graphics memory, a command is sent to the host GPU driver to store the graphics resource in the host graphics memory, but when an identical graphics resource resides in the host graphics memory, the graphics resource is not stored in the host graphics memory. Instead, the identical graphics resource is shared by the first VM and at least one other VM.

Abstract: This paper presents an analytical model for parallel volume rendering of large datasets using GPU-based clusters. The model is focused on the parallel volume rendering and compositing stages and predicts their performance requiring only a few input parameters. We also present vl3, a novel parallel volume rendering framework for visualization of large datasets. Its performance is evaluated on a GPU-based cluster, weak and strong scaling are studied, and model predictions are validated with experimental results on up to 128 GPUs.

Abstract: University of Stuttgart educators have updated three computer science courses to incorporate forward-compatible OpenGL. To help students, they developed an educational framework that abstracts some of modern OpenGL's difficult aspects.

Abstract: Direct volume visualization is an important method in many areas, including computational fluid dynamics and medicine. Achieving interactive rates for direct volume rendering of large unstructured volumetric grids is a challenging problem, but parallelizing direct volume rendering algorithms can help achieve this goal. Using Compute Unified Device Architecture (CUDA), we propose a GPU-based volume rendering algorithm that itself is based on a cell projection-based ray-casting algorithm designed for CPU implementations. We also propose a multicore parallelized version of the cell-projection algorithm using OpenMP. In both algorithms, we favor image quality over rendering speed. Our algorithm has a low memory footprint, allowing us to render large datasets. Our algorithm supports progressive rendering. We compared the GPU implementation with the serial and multicore implementations. We observed significant speed-ups that, together with progressive rendering, enables reaching interactive rates for large datasets.

Abstract: Real-time sound rendering applications are memory-intensive and computation-intensive. To speed up computation and extend the simulated area, a real-time sound rendering system based on the hardware-oriented finite difference time domain algorithm (HO-FDTD) and time-sharing architecture is proposed and implemented by the field programmable gate array (FPGA) in this study. Compared with the traditional rendering system with parallel architecture, the proposed system extends by about 37 times in the simulated area because data are stored in the on-chip block memories instead of the D flip-flops. The hardware system becomes stable after 400 time steps in the impulse response. To render a three-minute Beethoven classical music clip, the hardware system carries it out in real-time while the software simulation takes about 63 min in a computer with 4 GB RAM and an AMD Phenom 9500 Quad-core processor running on 2.2 GHz.

Abstract: We present an efficient approach to greatly reduce memory usage and to achieve high rendering performance for massive 3D CAD models Our work is based on the observation that these models often contain many instances of the same geometries Using a shape matching algorithm, we identify these instances and estimate the optimal affine transformation between them The resulting sets of unique geometries only require a fraction of the memory used by the original 3D model This compact representation can be rendered efficiently using hardware-accelerated geometry instancing As another benefit, this allows for interactive rendering of highly dynamic scenes of up to a million moving objects Our proposal assumes no knowledge about the scene, and thus can be applied to other kinds of massive 3D models with similar properties

Abstract: Collaborative creation workflows are calling for softer protection mechanisms than conventional encryption. Geometry-preserving encryption relates to protection techniques for 3D objects that alter the visual representation of the object after rendering but preserves some geometrical primitives, e.g. the bounding box. The advantage of this approach is the ability of legacy renderers to readily display composite scenes that contain both protected and unprotected objects. In this paper, we introduce a collection of geometry-preserving encryption algorithms, whose visual impact can be adjusted with a tuning parameter, and then report on the influence of the deformation on the actual rendering time of the object. Experimental results clearly highlight that special care needs to be taken in order to preserve interactivity, that is a de facto requirement for collaborative creation.

Abstract: Teach Your Students How to Create a Graphics Application Introduction to Computer Graphics: A Practical Learning Approach guides students in developing their own interactive graphics application. The authors show step by step how to implement computer graphics concepts and theory using the EnvyMyCar (NVMC) framework as a consistent example throughout the text. They use the WebGL graphics API to develop NVMC, a simple, interactive car racing game. Each chapter focuses on a particular computer graphics aspect, such as 3D modeling and lighting. The authors help students understand how to handle 3D geometric transformations, texturing, complex lighting effects, and more. This practical approach leads students to draw the elements and effects needed to ultimately create a visually pleasing car racing game. The code is available at www.envymycarbook.com

Abstract: In this paper, we present guacamole, a novel open source software framework for developing virtual-reality applications. It features a lightweight scene graph combined with a versatile deferred shading pipeline. In our deferred renderer, the geometry processing is decoupled from subsequent shading stages. This allows us to use the same flexible materials for various geometry types. Materials consist of multiple programmable shading stages and user-defined attributes. In contrast to other deferred shading implementations, our renderer automatically infers and generates the necessary buffer configurations and shader programs. We demonstrate the extensibility of our pipeline by showing how we added rendering support for non-polygonal data such as trimmed NURBS and volume data. Furthermore, guacamole features many state-of-the-art post-processing effects such as ambient occlusion or volumetric light. Our framework is also capable of rendering on multiple GPUs for the support of multi-screen displays and multi-user applications.

Abstract: We propose a new application of stochastic point-based rendering, which was recently proposed for implicit surfaces, to large-scale laser-scanned 3D point data. Specifically, we propose a scheme to apply the rendering to transparent and fused visualization of recent large and complex laser-scanned data from cultural assets. Our scheme uses 3D points that are directly acquired using a laser scanner as the rendering primitives. For laser-scanned data that consist of more than 107 or 108 3D points, the pre-processing stage takes only a few minutes, and the rendering stage is executable at interactive frame rates. We do not encounter rendering artifacts originating from the indefiniteness of depth-sorted orders of rendering primitives. Fused visualization with various visual assistants is also possible. We demonstrate the effectiveness of our scheme by visualizing a campus building and a culturally important festival float.

Abstract: Hybrid rendering combines the speed of raster-based rendering with the photorealism of ray trace rendering in order to achieve both speed and visual quality for interactive applications. Since ray tracing images is a demanding task, a hybrid renderer must use ray tracing carefully in order to maintain an acceptable frame rate. Fixed solutions, where only shadows or reflexive objects are ray traced not only cannot guarantee real time, but can represent a waste of processing, if the final result minimally differs from a raster only result. In our work, we present a method to improve hybrid rendering by analysing the scene in real time and decide what should be ray traced, in order to provide the best visual experience within acceptable frame rates.

Abstract: Methods and audio processing units for generating an object based audio program including conditional rendering metadata corresponding to at least one object channel of the program, where the conditional rendering metadata is indicative of at least one rendering constraint, based on playback speaker array configuration, which applies to each corresponding object channel, and methods for rendering audio content determined by such a program, including by rendering content of at least one audio channel of the program in a manner compliant with each applicable rendering constraint in response to at least some of the conditional rendering metadata. Rendering of a selected mix of content of the program may provide an immersive experience.

Abstract: Energy and power efficiency are becoming important topics within the graphics community. In this paper, we present a simple, straightforward method for measuring per-frame energy consumption of real-time graphics workloads. The method is non-invasive, meaning that source code is not needed, which makes it possible to measure on a much wider range of applications. We also discuss certain behaviors of the measured platforms that can affect energy measurements, e.g., what happens when calling glFinish(), which ensures that all issued graphics commands are finished executing. Measurements are done both on a smartphone and on CPUs with integrated graphics processors.

Abstract: Direct point-based rendering is a popular method in scientific visualization, since the number of point-based datasets increased dramatically in the past few years. At the same time, rendering of point primitives is becoming less efficient as the data size increases. Point splatting, volume-based rendering, or is surface extraction are well-known approaches that can be utilized. Unfortunately, high visual accuracy is often sacrificed. Furthermore, unstructured sparse point-based data is more difficult to visualize, since no surface geometry and topology can be implicitly defined. This paper introduces a novel hybrid visualization method that utilizes point-based and volume-based rendering of sparse point-based data. The visualization is done entirely with a custom rendering pipeline by using GPGPU, which provides accelerated rendering. The method achieves real-time visualization, while retaining high visual accuracy, as shown on cosmological dark matter SPH-based dataset.

Abstract: Compression techniques for dynamically-generated graphics resources are described. In one embodiment, for example, an apparatus may comprise logic, at least a portion of which is in hardware, the logic to determine one or more usage characteristics of a dynamically-generated graphics resource, determine whether to compress the dynamically-generated graphics resource based on the one or more usage characteristics, and in response to a determination to compress the dynamically-generated graphics resource, select a compression procedure based on a graphics quality threshold for the dynamically-generated graphics resource. Other embodiments are described and claimed.

Abstract: A gaming device for playing a video game. The gaming device executes game software to output rendering commands representing a virtual world of the video game and has a local rendering module for processing the rendering commands to generate an image data stream of the virtual world. The gaming device has a remote rendering controller for generating second rendering commands for processing by a remote rendering module to generate a rendered graphics output also depicting the virtual world.

Abstract: Systems and methods are presented for allowing multiple users to collaboratively edit 3-D assets in real-time, using a distributed 3-D editing/rendering software application. The software application may include a lightweight, browser-based user interface that is able to run on computing devices with relatively little memory and processing power. The software application may further include a progressive rendering engine.

Abstract: Although mobile devices have now become an important computing platform, however most of them still lack hardware accelerated graphics. Therefore, interactive 3D rendering on these devices is a difficult task. This paper describes different approaches for 3D rendering on mobile devices and the associated challenges. It then investigates different solutions to resolve these problems and proposes a framework that uses Image Based Rendering (IBR) technique to render interactive 3D graphics on mobile devices. Further, the performance of proposed framework is compared with Geometry Based Rendering (GBR). The experimental results show that the proposed framework performs better than the geometry-based techniques in terms of rendering time, visual quality and memory requirements. The results also show that the rendering time of the proposed framework is independent of the scene complexity. The experiments are performed in Java Platform Micro Edition (JavaME) environment with Sun JavaME Phone emulator.

Abstract: This paper presents the last advances in Glob3 Mobile, a multi-platform graphics engine for Virtual Globes oriented to any kind of user. More specifically, the document focuses on the possibilities that programmable graphic pipelines have to offer regarding the rendering of many kinds of geospatial symbology. This paper explains a few key aspects about what shading programs are, and their benefits compared to the fixed rendering pipeline paradigm. It is also discussed how to manage the programs running on GPU in an user-friendly way, and the architecture that allows to perform this management keeping a high performance during the rendering.

Abstract: Get Started Quickly with DirectX 3D Programming: No 3D Experience Needed This step-by-step text demystifies modern graphics programming so you can quickly start writing professional code with DirectX and HLSL. Expert graphics instructor Paul Varcholik starts with the basics: a tour of the Direct3D graphics pipeline, a 3D math primer, and an introduction to the best tools and support libraries. Next, youll discover shader authoring with HLSL. Youll implement basic lighting models, including ambient lighting, diffuse lighting, and specular highlighting. Youll write shaders to support point lights, spotlights, environment mapping, fog, color blending, normal mapping, and more. Then youll employ C++ and the Direct3D API to develop a robust, extensible rendering engine. Youll learn about virtual cameras, loading and rendering 3D models, mouse and keyboard input, and youll create a flexible effect and material system to integrate your shaders. Finally, youll extend your graphics knowledge with more advanced material, including post-processing techniques for color filtering, Gaussian blurring, bloom, and distortion mapping. Youll develop shaders for casting shadows, work with geometry and tessellation shaders, and implement a complete skeletal animation system for importing and rendering animated models. You dont need any experience with 3D graphics or the associated math: Everythings taught hands-on, and all graphics-specific code is fully explained. Coverage includes The Direct3D API and graphics pipeline A 3D math primer: vectors, matrices, coordinate systems, transformations, and the DirectX Math library Free and low-cost tools for authoring, debugging, and profiling shaders Extensive treatment of HLSL shader authoring Development of a C++ rendering engine Cameras, 3D models, materials, and lighting Post-processing effects Device input, component-based architecture, and software services Shadow mapping, depth maps, and projective texture mapping Skeletal animation Geometry and tessellation shaders Survey of rendering optimization, global illumination, compute shaders, deferred shading, and data-driven engine architecture