Abstract: Modern graphics co-processors (GPUs) can produce high fidelity images several orders of magnitude faster than general purpose CPUs, and this performance expectation is rapidly becoming ubiquitous in personal computers. Despite this, GPU virtualization is a nascent field of research. This paper introduces a taxonomy of strategies for GPU virtualization and describes in detail the specific GPU virtualization architecture developed for VMware's hosted products (VMware Workstation and VMware Fusion).We analyze the performance of our GPU virtualization with a combination of applications and microbenchmarks. We also compare against software rendering, the GPU virtualization in Parallels Desktop 3.0, and the native GPU. We find that taking advantage of hardware acceleration significantly closes the gap between pure emulation and native, but that different implementations and host graphics stacks show distinct variation. The microbenchmarks show that our architecture amplifies the overheads in the traditional graphics API bottlenecks: draw calls, downloading buffers, and batch sizes.Our virtual GPU architecture runs modern graphics-intensive games and applications at interactive frame rates while preserving virtual machine portability. The applications we tested achieve from 86% to 12% of native rates and 43 to 18 frames per second with VMware Fusion 2.0.

Abstract: Continuing improvements in CPU and GPU performances as well as increasing multi-core processor and cluster-based parallelism demand for flexible and scalable parallel rendering solutions that can exploit multipipe hardware accelerated graphics. In fact, to achieve interactive visualization, scalable rendering systems are essential to cope with the rapid growth of data sets. However, parallel rendering systems are non-trivial to develop and often only application specific implementations have been proposed. The task of developing a scalable parallel rendering framework is even more difficult if it should be generic to support various types of data and visualization applications, and at the same time work efficiently on a cluster with distributed graphics cards. In this paper we introduce a novel system called Equalizer, a toolkit for scalable parallel rendering based on OpenGL which provides an application programming interface (API) to develop scalable graphics applications for a wide range of systems ranging from large distributed visualization clusters and multi-processor multipipe graphics systems to single-processor single-pipe desktop machines. We describe the system architecture, the basic API, discuss its advantages over previous approaches, present example configurations and usage scenarios as well as scalability results.

Abstract: Graphics processing units (GPUs) for years have been dedicated mostly to real time rendering. Recently leading GPU manufactures have extended their research area and decided to support also graphics computing. In this paper, we describe an impact of new GPU features on development process of an efficient finite difference time domain (FDTD) implementation.

Abstract: We present a new GPU-based rendering system for ray casting of multiple volumes. Our approach supports a large number of volumes, complex translucent and concave polyhedral objects as well as CSG intersections of volumes and geometry in any combination. The system (including the rasterization stage) is implemented entirely in CUDA, which allows full control of the memory hierarchy, in particular access to high bandwidth and low latency shared memory. High depth complexity, which is problematic for conventional approaches based on depth peeling, can be handled successfully. As far as we know, our approach is the first framework for multivolume rendering which provides interactive frame rates when concurrently rendering more than 50 arbitrarily overlapping volumes on current graphics hardware.

Abstract: High quality image synthesis is a long-standing goal in computer graphics. Complex lighting, reflection, shadow and global illumination effects can be rendered with modern image synthesis algorithms, but those methods are focused on offline computation of a single image. They are far from interactive, and the image must be recomputed from scratch when any aspect of the scene changes. On the other hand, real-time rendering often fixes the object geometry and other attributes, such as relighting a static image for lighting design. In these cases, the final image or rendering is a linear combination of basis images or radiance distributions due to individual lights. We can therefore precompute offline solutions to each individual light or lighting basis function, combining them efficiently for real-time image synthesis. Precomputation-based relighting and radiance transfer has a long history with a spurt of renewed interest, including adoption in commercial video games, due to recent mathematical developments and hardware advances. In this survey, we describe the mathematical foundations, history, current research and future directions for precomputation-based rendering.

Abstract: One of the challenging advents in Computer Science in recent years was the fast evolution of parallel processors, specially the GPU – graphics processing unit GPUs today play a major role in many computational environments, most notably those regarding real-time graphics applications, such as games The digital game industry is one of the main driving forces behind GPUs, it persistently elevates the state-of-art in Computer Graphics, pushing outstanding realistic scenes to interactive levels The evolution of photo realistic scenes consequently demands better graphics cards from the hardware industry Over the last decade, the hardware has not only become a hundred times more powerful, but has also become increasingly customizable allowing programmers to alter some of previously fixed functionalities This tutorial is an introduction to GPU programming using the OpenGL Shading Language – GLSL It comprises an overview of graphics concepts and a walk-through the graphics card rendering pipeline A thorough understanding of the graphics pipeline is extremely important when designing a program in GPU, known as a shader Throughout this tutorial, the exposition of the GLSL language and GPU programming details are followed closely by examples ranging from very simple to more practical applications It is aimed at an audience with no or little knowledge on the subject

Abstract: Graphics rendering in a virtual machine system is accelerated by utilizing host graphics hardware. In one embodiment, the virtual machine system includes a server that hosts a plurality of virtual machines. The server includes one or more graphics processing units. Each graphics processing unit can be allocated to multiple virtual machines to render images. A hypervisor that runs on the server is extended to include a redirection module, which receives a rendering request from a virtual machine and redirects the rendering request to a graphics driver. The graphics driver can commands an allocated portion of a graphics processing unit to render an image on the server.

Abstract: Graphics processing units supporting tessellation of curved surfaces with displacement mapping exist today. Still, to our knowledge, culling only occurs after tessellation, that is, after the base primitives have been tessellated into triangles. We introduce an algorithm for automatically computing tight positional and normal bounds on the fly for a base primitive. These bounds are derived from an arbitrary vertex shader program, which may include a curved surface evaluation and different types of displacements, for example. The obtained bounds are used for backface, view frustum, and occlusion culling before tessellation. For highly tessellated scenes, we show that up to 80p of the vertex shader instructions can be avoided, which implies an “instruction speedup” of 5×. Our technique can also be used for offline software rendering.

Abstract: A system and method for providing an Application Programming Interface (API) that allows users to write complex graphics and visualization applications with little knowledge of how to parallelize or distribute the application across a graphics cluster. The interface enables users to develop an application program using a common programming paradigm (e.g., scene graph) in a manner that accommodates handling parallel rendering tasks and rendering environments. The visualization applications written by developers take better advantage of the aggregate resources of a cluster. The programming model provided by APT function calls handles scene-graph(s) data in a manner such that the scene and data management are decoupled from the rendering, compositing, and display. As a result, the system and method is not beholden to one particular graphics rendering API (e.g. OpenGL, Direct X, etc.) and provides the ability to switch between these APIs even during runtime.

Abstract: This disclosure describes techniques for removing vertex points during two dimensional (2D) graphics rendering using three-dimensional (3D) graphics hardware. In accordance with the described techniques one or more vertex points may be removed during 2D graphics rendering using 3D graphics hardware. For example, the techniques may remove redundant vertex points in the display coordinate space by discarding vertex points that have the substantially same positional coordinates in the display coordinate space as a previous vertex point. Alternatively or additionally, the techniques may remove excess vertex points that lie in a straight line. Removing the redundant vertex points or vertex points that lie in a straight line allow for more efficient utilization of the hardware resources of the GPU and increase the speed at which the GPU renders the image for display.

Abstract: With the use of advanced computer graphics rendering software, computer generated images have become difficult to be visually differentiated from natural images captured using digital cameras. The need for automatically distinguishing computer generated images from natural images is becoming significantly important for image forensic techniques. In this paper, a novel approach is proposed to differentiate the two image categories. An alpha-stable distribution model is built to characterize the wavelet decomposition coefficients of natural images. The suitability of the model is then illustrated. The fractional lower order moments in the image wavelet domain are extracted and evaluated with the Support Vector Machine classifier. The experimental results show that the proposed method performs better than the previous higher-order statistical approaches.

Abstract: Computer graphics identification has gained importance in digital era as it relates to image forgery detection and enhancement of high photorealistic rendering software. In this paper, statistical moments of 1-D and 2-D characteristic functions are employed to derive image features that can well capture the statistical differences between computer graphics and photographic images. YCbCr color system is selected because it has shown better performance in computer graphics classification than RGB color system and it has been adopted by the most popularly used JPEG images. Furthermore, only Y and Cb color channels are used in feature extraction due to our study showing features derived from Cb and Cr are so highly correlated that no need to use features extracted from both Cb and Cr components, which substantially reduces computational complexity. Concretely, in each selected color component, features are extracted from each image in both image pixel 2-D array and JPEG 2-D array (an 2-D array consisting of the magnitude of JPEG coefficients), their prediction-error 2-D arrays, and all of their three-level wavelet subbands, referred to as various 2-D arrays generated from a given image in this paper. The rationale behind using prediction-error image is to reduce the influence caused by image content. To generate image features from 1-D characteristic functions, the various 2-D arrays of a given image are the inputs, yielding 156 features in total. For the feature generated from 2-D characteristic functions, only JPEG 2-D array and its prediction-error 2-D array are the inputs, one-unit-apart 2-D histograms of the JPEG 2-D array along the horizontal, vertical and diagonal directions are utilized to generate 2-D characteristic functions, from which the marginal moments are generated to form 234 features. Together, the process then results in 390 features per color channel, and 780 features in total Finally, Boosting Feature Selection (BFS) is used to greatly reduce the dimensionality of features while boosts the machine learning based classification performance to fairly high.

Abstract: The available rendering performance on current computers increases constantly, primarily by employing parallel algorithms using the newest many-core hardware, as for example multi-core CPUs or GPUs. This development enables faster rasterization, as well as conspicuously faster software-based real-time ray tracing. Despite the tremendous progress in rendering power, there are and always will be applications in classical computer graphics and Virtual Reality, which require distributed configurations employing multiple machines for both rendering and display. In this paper we address this problem and use NMM, a distributed multimedia middleware, to build a powerful and flexible rendering framework. Our framework is highly modular, and can be easily reconfigured --- even at runtime --- to meet the changing demands of applications built on top of it. We show that the flexibility of our approach comes at a negligible cost in comparison to a specialized and highly-optimized implementation of distributed rendering.

Abstract: We present a client-server framework for network distribution and real-time point-based rendering of large 3D models on commodity graphics platforms. Model inspection, based on a one-touch interface, is enriched by a bidirectional hyperlink system which provides access to multiple layers of multimedia contents linking different parts of the 3D model many information sources. In addition to view and light control, users can perform simple 3D operations like angle, distance and area measurements on the 3D model. An authoring tool derived from the basic client allows users to add multimedia content to the model description. Our rendering method is based on a coarse grained multiresolution structure, where each node contains thousands of point samples. At runtime, a view-dependent refinement process incrementally updates the current GPU-cached model representation from local or remote out-of-core data. Vertex and fragment shaders are used for high quality elliptical sample drawing and a variety of shading effects. The system is demonstrated with examples that range from documentation and inspection of small artifacts to exploration of large sites, in both a museum and a large scale distribution setting.

Abstract: Visualizing dynamic participating media in particle form by fully solving equations from the light transport theory is a computationally very expensive process. In this paper,we presenta computational pipeline for particle volume rendering that is easily accelerated by the currentGPU. To fully harness its massively parallel computing power, we transform input particles into a volumetric density field using a GPU-assisted, adaptive density estimation technique that iteratively adapts the smoothing length for local grid cells. Then, the volume data is visualized efficiently based on the volume photon mapping method where our GPU techniques further improve the rendering quality offered by previous implementations while performing rendering computation in acceptable time. It is demonstrated that high quality volume renderings can be easily produced from large particle datasets in time frames of a few seconds to less than a minute.

Abstract: The latest generation of graphics hardware provides direct access to multisample anti-aliasing (MSAA) rendering data. By taking advantage of these existing pixel subsample values, an intelligent reconstruction filter can be computed using programmable GPU shader units. This paper describes an adaptive anti-aliasing (AA) filter for real-time rendering on the GPU. Improved quality is achieved by using information from neighboring pixel samples to compute both an approximation of the gradient of primitive edges and the final pixel color.

Abstract: Methods and systems for rendering three dimensional graphical data by intercepting a three dimensional graphics stream comprising three dimensional graphics commands generated by an application executing on a first computing machine, and then analyzing the characteristics associated with a remoting system to determine a location for rendering three dimensional data from the three dimensional graphics commands. The remoting system may comprise at least the first computing machine having a graphics rendering component, a second computing machine having a graphics rendering component and a network. Based on the analysis, a rendering location is determined and the application is induced to reinitialize a context for determining where to render three dimensional data. The three dimensional data is then rendered from the three dimensional graphics commands at the rendering location.

Abstract: A circuit arrangement, program product and circuit arrangement render stereoscopic images in a multithreaded rendering software pipeline using first and second rendering channels respectively configured to render left and right views for the stereoscopic image. Separate transformations are applied to received vertex data to generate transformed vertex data for use by each of the first and second rendering channels in rendering the left and right views for the stereoscopic image.

Abstract: In the field of rendering a three dimensional model into a two dimensional graphical representation, the resources available to a general purpose computer can be used to efficiently render the scene. The high speed/low computer resource with which the rendering is performed results from utilizing different inputs to the rendering engine and from the manner in which the rendering engine handles these inputs.

Abstract: This paper describes a robust, modular, complete GPU architecture—the Tile-Load-Map (TLM)—designed for the real-time visualization of wide textured terrains created with arbitrary meshes. It extends and completes our previous succinct paper Amara et al. (ISVC 2007, Part 1, Lecture Notes in Computer Science, vol. 4841, pp. 586–597, Springer, Berlin, 2007) by giving further technical and implementation details. It provides new solutions to problems that had been left unresolved, in the context of a joint use of OpenGL and CUDA, optimized on the G80 graphics chip. We explain the crucial components of the shaders, and emphasize the progress we have proposed, while resolving some difficulties. We show that this texturing architecture is well suited to current challenges, and takes into account most of the distinctive aspects of terrain rendering. Finally, we demonstrate how the design of the TLM facilitates the integration of geomatic input-data into procedural selection/rendering tasks on the GPU, and immediate applications to amplification.

Abstract: This paper presents an approach to real-time rendering of non-planar projections with a single center and straight projection rays. Its goal is to provide optimal and consistent image quality. It operates entirely in object space to remove the need for image resampling. In contrast to most other object-space approaches, it does not evaluate non-linear functions on the GPU, but approximates the projection itself by a set of perspective projection pieces. Within each piece, graphics hardware can provide optimal image quality. The result is a coherent and crisp rendering. Procedural textures and stylization effects greatly benefit from our method as they usually rely on screen-space operations. The real-time implementation runs entirely on GPU. It replicates input primitives on demand and renders them into all relevant projection pieces. The method is independent of the input mesh density and is not restricted to static meshes. Thus, it is well suited for interactive applications. We demonstrate it for an analytic and a freely designed projection.

Abstract: This paper describes a system for structure-and-motion estimation for real-time navigation and obstacle avoidance. We demonstrate a technique to increase the efficiency of the 5-point solution to the relative pose problem. This is achieved by a novel sampling scheme, where we add a distance constraint on the sampled points inside the RANSAC loop, before calculating the 5-point solution. Our setup uses the KLT tracker to establish point correspondences across time in live video. We also demonstrate how an early outlier rejection in the tracker improves performance in scenes with plenty of occlusions. This outlier rejection scheme is well suited to implementation on graphics hardware. We evaluate the proposed algorithms using real camera sequences with fine-tuned bundle adjusted data as ground truth. To strenghten our results we also evaluate using sequences generated by a state-of-the-art rendering software. On average we are able to reduce the number of RANSAC iterations by half and thereby double the speed.

Abstract: Advances in real-time graphics research and the increasing power of mainstream GPUs has generated an explosion of innovative algorithms suitable for rendering complex virtual worlds at interactive rates. Every year, the latest video games display a vast variety of sophisticated algorithms that power ground-breaking 3D rendering and push the visual boundaries and interactive experience of rich environments.This course covers a series of topics on the best practices and techniques prevalent in state-of-the-art rendering in several award-winning games, and describes innovative and practical 3D rendering research breaktrhoughs that will be used in the games of tomorrow. The course is designed for technical practitioners and developers of graphics engines for visualization, games, or effects rendering. Presented techniques are applicable in real-time and off-line domains. Attendees will acquire a number of highly optimized algorithms in various areas of real-time rendering.

Abstract: Many computer applications incorporate and support animation (e.g., interactive user interfaces). Unfortunately, it may be challenging for computer applications and rendering systems to render animation frames at a smooth and consistent rate while conserving system resources. Accordingly, a technique for controlling animation rendering frame rate of an application is disclosed herein. An animation rendering update interval of an animation timer may be adjusted based upon a rendering system state (e.g., a rate of compositing visual layouts from animation frames) of a rendering system and/or an application state (e.g., a rate at which an application renders frames) of an application. Adjusting the animation rendering update interval allows the animation timer to adjust the frequency of performing rendering callback notifications (work requests to an application to render animation frames) to an application based upon rendering system performance and application performance.

Abstract: Scientific visualization, computer animation and virtual reality are three hotspots of modern computer graphics, and 3D realistic real-time rendering is the core technique of them. It is applied widely in cartoon, games, films, virtual reality and engineering domain. OpenGL is the current international standard of 3D image. This paper discussed the implementing methods for the representation of 3D terrain realistic scenes based on OpenGL, such as the digital terrain model mapping, the blend of water and terrain data, the blend of thematic information and terrain data. The experiences of using OpenGL to generate highly realistic images with realistic real-time rendering techniques were summarized. A visualization system for 3D terrain scenes was developed to demonstrate the effectiveness and efficiency of OpenGL as an interfacing tool for realistic real-time image rendering of 3D terrain scenes, and the results fit the anticipant goals well.

Abstract: One embodiment provides a system that facilitates the execution of a web application. During operation, the system loads a native code module that includes a scenegraph renderer into a secure runtime environment. Next, the system uses the scenegraph renderer to create a scenegraph from a graphics model associated with the web application and generate a set of rendering commands from the scenegraph. The system then writes the rendering commands to a command buffer and reads the rendering commands from the command buffer. Finally, the system uses the rendering commands to render, for the web application, an image corresponding to the graphics model by executing the rendering commands using a graphics-processing unit (GPU).

Abstract: Recently, sort-middle triangle rasterization, implemented as software on a manycore GPU with vector units (Larabee), has been proposed as an alternative to hardware rasterization. The main reasoning is, that only a fraction of the time per frame is spent sorting and rasterizing triangles. However is this still a valid argument in the context of geometry amplification when the number of primitives increases quickly? A REYES like approach, sorting parametric patches instead, could avoid many of the problems with tiny triangles. To demonstrate that software rasterization with geometry amplification can work in real-time, we implement a tile based sort-middle rasterizer in CUDA and analyze its behavior: First we adaptively subdivide rational bicubic B´ezier patches. Then we sort those into buckets, and for each bucket we dice, grid-shade, and rasterize the micropolygons into the corresponding tile using on-chip caches. Despite being limited by the amount of available shared memory, the number of registers and the lack of an L3 cache, we manage to rasterize 1600×1200 images, containing 200k sub-patches, at 10-12 fps on an nVidia GTX 280. This is about 3x to 5x slower than a hybrid approach subdividing with CUDA and using the HW rasterizer. We hide cracks caused by adaptive subdivision using a flatness metric in combination with rasterizing B´ezier convex hulls. Using a k-buffer with a fuzzy z-test we can render transparent objects despite the overlap our approach creates. Further, we introduce the notion of true back patch culling, allowing us to simplify crack hiding and sampling.

Abstract: This paper introduces a novel system for interactive modeling and designing of arbitrary BRDFs. The system is able to deal with BRDFs defined in a variety of forms, such as analytical models, measured data or data obtained by simulation. The system also allows designing BRDFs from scratch using a combination of different analytical lobes. Using the programmable graphics hardware, it then performs interactive display of the designed BRDF, and its rendering on objects lit by complex illumination. The system also allows the fitting of an input BRDF defined in any form to our analytical lobe combination, so that it can be efficiently evaluated with GPU based rendering. The idea behind this work is to make available a general system for designing, fitting and rendering BRDFs, that is intuitive and interactive in nature. We plan to use this as a tool for simulation and modeling of complex physically-based BRDFs, and thus provide access to a larger variety of material models to the rendering community.