Towards a High Quality Real-Time Graphics Pipeline

Modern graphics hardware pipelines create photorealistic images with high geometric complexity in real time. The quality is constantly improving and advanced techniques from feature film visual effects, such as high dynamic range images and support for higher-order surface primitives, have recently been adopted. Visual effect techniques have large computational costs and significant memory bandwidth usage. In this thesis, we identify three problem areas and propose new algorithms that increase the performance of a set of computer graphics techniques. Our main focus is on efficient algorithms for the real-time graphics pipeline, but parts of our research are equally applicable to offline rendering. Our first focus is texture compression, which is a technique to reduce the memory bandwidth usage. The core idea is to store images in small compressed blocks which are sent over the memory bus and are decompressed on-the-fly when accessed. We present compression algorithms for two types of texture formats. High dynamic range images capture environment lighting with luminance differences over a wide intensity range. Normal maps store perturbation vectors for local surface normals, and give the illusion of high geometric surface detail. Our compression formats are tailored to these texture types and have compression ratios of 6:1, high visual fidelity, and low-cost decompression logic. Our second focus is tessellation culling. Culling is a commonly used technique in computer graphics for removing work that does not contribute to the final image, such as completely hidden geometry. By discarding rendering primitives from further processing, substantial arithmetic computations and memory bandwidth can be saved. Modern graphics processing units include flexible tessellation stages, where rendering primitives are subdivided for increased geometric detail. Images with highly detailed models can be synthesized, but the incurred cost is significant. We have devised a simple remapping technique that allowsfor better tessellation distribution in screen space. Furthermore, we present programmable tessellation culling, where bounding volumes for displaced geometry are computed and used to conservatively test if a primitive can be discarded before tessellation. We introduce a general tessellation culling framework, and an optimized algorithm for rendering of displaced Bézier patches, which is expected to be a common use case for graphics hardware tessellation. Our third and final focus is forward-looking, and relates to efficient algorithms for stochastic rasterization, a rendering technique where camera effects such as depth of field and motion blur can be faithfully simulated. We extend a graphics pipeline with stochastic rasterization in spatio-temporal space and show that stochastic motion blur can be rendered with rather modest pipeline modifications. Furthermore, backface culling algorithms for motion blur and depth of field rendering are presented, which are directly applicable to stochastic rasterization. Hopefully, our work in this field brings us closer to high quality real-time stochastic rendering

Analysis domain model for shared virtual environments

The field of shared virtual environments, which also encompasses online games and social 3D environments, has a system landscape consisting of multiple solutions that share great functional overlap. However, there is little system interoperability between the different solutions. A shared virtual environment has an associated problem domain that is highly complex raising difficult challenges to the development process, starting with the architectural design of the underlying system. This paper has two main contributions. The first contribution is a broad domain analysis of shared virtual environments, which enables developers to have a better understanding of the whole rather than the part(s). The second contribution is a reference domain model for discussing and describing solutions - the Analysis Domain Model

Techniques for an image space occlusion culling engine

In this work we present several techniques applied to implement an Image Space Software Occlusion Culling Engine to increase the speed of rendering general dynamic scenes with high depth complexity. This conservative culling method is based on a tiled Occlusion Map that is updated only when needed, deferring and even avoiding the expensive per pixel rasterization process. We show how the tiles become a useful way to increase the speed of visibility tests. Finally we describe how different parts of the engine were parallelized using OpenMP directives and SIMD instructions.Eje: Workshop Computación gráfica, imágenes y visualización (WCGIV)Red de Universidades con Carreras en Informática (RedUNCI

Rendering on a Budget: a Framework for Time-Critical Rendering

Abstract We present a technique for optimizing the rendering of highdepth complexity scenes. Prioritized-Layered Projection (PLP) does this by rendering an estimation of the visible set for each frame. The novelty in our work lies in the fact that we do not explicitly compute visible sets. Instead, our work is based on computing on demand a priority order for the polygons that maximizes the likelihood of rendering visible polygons before occluded ones for any given scene. Given a fixed budget, e.g. time or number of triangles, our rendering algorithm makes sure to render geometry respecting the computed priority. There are two main steps to our technique: (1) an occupancy-based tessellation of space; and (2) a soliditybased traversal algorithm. PLP works by first computing an occupancy-based tessellation of space, which tends to have more cells where there are more geometric primitives. In this spatial tessellation, each cell is assigned a solidity value, which is directly proportional to its likelihood of occluding other cells. In its simplest form, a cell's solidity value is directly proportional to the number of polygons contained within it. During our traversal algorithm cells are marked for projection, and the geometric primitives contained within them actually rendered. The traversal algorithm makes use of the cells' solidity, and other view-dependent information to determine the ordering in which to project cells. By carefully tailoring the traversal algorithm to the occupancy-based tessellation, we can achieve very good frame rates with low preprocessing and rendering costs. In this paper, we describe our technique and its implementation in detail. Also, we provide experimental evidence of its performance. We also briefly discuss extensions of our algorithm

Development of design tools for the evaluation of complex CAD models

The goal of this thesis is to invent means to enable 3D-models, created in SOLIDWORKS CAD-software, to be explored in a low-cost head-mounted display device Oculus Rift. Such a design tool would make possible to study 3D CAD-models in Virtual Reality with a very low cost and share design information for people who are not so familiar with CAD-models. As a result this can lower the product development effort for new products enabling, lower working time and improve both the quality of the final product and customer satisfaction. CAD-models as well as exported graphics format from SOLIDWORKS can’t directly be imported to Oculus Rift device. Therefore transformation pipeline need to be invented between the SOLIDWORKS and Oculus Rift. There are some options for this and their issues are studied in this thesis. As a best option it was found to use a conversion plugin tool to SOLIDWORKS which convert CAD-models to FBX-format. This format can be imported to Unity game engine software which is supported by Oculus Rift device. Graphics file conversion process in known to be imperfect. Therefore conversion of three SOLIDWORKS CAD-models have been analyzed; a Crane, a Pipe system, and a Hydraulic cylinder. This testing gave a good overview of possibilities and limitations of the graphics pipeline. It was found that ordinary CAD-models can be transferred to Oculus Rift without problems. However, there are some special features in CAD models which cause problems for in graphics file conversion

Automatic Creation of Physics Components for Procedurally Generated Trees

The field of procedural generation is becoming increasingly widespread as a tool for generating content in video games and virtual environments. Procedural generation creates content (such as 3D models) automatically, saving large amounts of time and money, as no human interaction is required. One area where procedural generation excels is the creation of trees, which is most commonly achieved using L-systems. The problem with these generated trees is that they are static and do not have any associated animations or dynamic behaviour. Our research addresses this problem by presenting a technique for adding physics components to trees created by L-systems, so that they can be simulated using a real-time physics engine, making them react dynamically, and realistically, to their environment. The algorithm works by creating a physics skeleton for the tree that can be used to approximate real tree behaviour. In order to improve the computational performance of our system, we also present some level-of-detail schemes aimed at real-time physics simulations. These schemes are not suitable for all cases, especially those which require a high level of realism, but can improve performance. We test both the computational performance of our system, including it's ability to operate in real-time, as well as the realism shown in the dynamics of the produced trees. The results indicate that our trees are very realistic and an improvement over those found in modern video games. However they also show that our system is not suitable for real-time use as it stands. We believe that research into further optimizations and culling techniques could change this, and recommend a number of avenues for future research in this regard

Techniques for an image space occlusion culling engine

In this work we present several techniques applied to implement an Image Space Software Occlusion Culling Engine to increase the speed of rendering general dynamic scenes with high depth complexity. This conservative culling method is based on a tiled Occlusion Map that is updated only when needed, deferring and even avoiding the expensive per pixel rasterization process. We show how the tiles become a useful way to increase the speed of visibility tests. Finally we describe how different parts of the engine were parallelized using OpenMP directives and SIMD instructions.Eje: Workshop Computación gráfica, imágenes y visualización (WCGIV)Red de Universidades con Carreras en Informática (RedUNCI

Towards the Holodeck: fully immersive virtual reality visualisation of scientific and engineering data

In this paper, we describe the development and operating principles of an immersive virtual reality (VR) visualisation environment that is designed around the use of consumer VR headsets in an existing wide area motion capture suite. We present two case studies in the application areas of visualisation of scientific and engineering data. Each of these case studies utilise a different render engine, namely a custom engine for one case and a commercial game engine for the other. The advantages and appropriateness of each approach are discussed along with suggestions for future work