Free PDF Ebooks Files @AcrobatPlanet.Com

This thesis describes useful methods and techniques for designing scalable hybrid parallel rendering architectures for 3D computer graphics. Various techniques for utilizing parallelism in a pipelined system are analyzed. During the Ph.D. study a prototype 3D graphics architecture named Hybris has been developed. Hybris is a prototype rendering architecture which can be tailored to many specific 3D graphics applications and implemented in various ways. Parallel software implementations for both single and multi-processor Windows 2000 systems have been demonstrated. Working hardware/software codesign implementations of Hybris for standard-cell based ASIC (simulated) and FPGA technologies have been demonstrated, using manual co-synthesis for translation of a Virtual Prototyping architecture specification written in C into both optimized C source for software and into to a synthesizable VHDL specification for hardware implementation. A flexible VRML 97 3D scene graph engine with a Java interface and C++ interface has been implemented to allow flexible integration of the rendering technology into Java and C++ applications. A 3D medical visualization workstation prototype (3D-Med) is examined as a case study and an application of the Hybris graphics architecture.

The inspiration for this thesis is a desire to make it possible to do something useful with interactive 3D computer graphics. In this case the driving application is 3D medical visualization. Three dimensional scanning generates huge amounts of data. Visualizing these datasets requires graphics systems capable of processing the data. Interactive visualization raises the performance requirements for these graphics systems even higher.

Historically computer graphics has always been a very computationally demanding task resulting in great limitations on the achievable realism. That has changed much lately with the arrival of fast graphics processors for the PC. These PC based graphics processors primarily rely on texture mapping to achieve aesthetically pleasing interactive 3D computer graphics. Texture mapping is the process of applying two-dimensional images to three dimensional geometric objects in order to achieve an illusion of high complexity, suitable for computer games. Driven by the steady increase in computational power, greater attention on the geometric detail of three dimensional objects becomes possible.

The goal of this dissertation is to examine how we may improve the performance of graphics processors to allow greater geometric detail without sacrificing interactivity. In particular the focus is on computer graphics rendering algorithms and techniques for providing scalability in computer graphics architectures. The need for scalability comes from the desire to design and build an interactive 3D graphics system with the ability to handle very large datasets. Such a large dataset, possibly containing millions of polygons, cannot easily be handled by normal graphics workstations and PCs. This thesis will focus on the techniques and algorithms required to work with large datasets. Small datasets such as those found in common computer games are trivially handled by current graphics processors. A large dataset may be reduced by decimation to build a smaller dataset approxi-mating the original dataset, which would make it possible to view it on a standard graphics processor, but it would also result in a loss of detail. Scaling the performance of a computer graphics system to facilitate rendering of the large datasets without sacrificing detail is a better approach.

The process of generating an image in computer graphics is called rendering [63], figure 1.1 shows an example of how an object, the 3D model of The Bunny1, is rendered on the screen using perspective projection, simulating how a real camera works. Rendering a dataset such as the Bunny is relatively straightforward using a sequential polygon renderer to render its 69,451 triangles. The triangles form a triangle mesh connecting 35,947 vertices. A simple sequential renderer will break the mesh into 69,451 individual triangles, resulting in a vertex count of 208,353 i.e. nearly 6 times as many as needed. This illustrates why a renderer must be carefully implemented in order to take advantage of special properties of the input data.

Contents
Preface
Contents
1 Introduction

1.1 Parallel rendering – the next step
1.2 Contribution of this thesis
1.3 Thesis chapter overview

2 Parallel Rendering and Scalability

2.1 Scalable 3D graphics architectures
2.1.1 General purpose parallel computing system architectures
2.1.2 Scalability of current PC-based 3D graphics processors
2.1.3 Summary

2.2 Parallel renderingconcepts

2.2.1 Coherence
2.2.2 Parallelism in rendering

2.3 Parallel rendering as a sorting problem

2.3.1 Sort-first
2.3.2 Sort-middle
2.3.3 Sort-last
2.3.4 Hybridsorting

2.4 Bucket sorting

2.4.1 Bounding box bucket sorting overlap
2.4.2 Exact bucket sorting overlap

2.5 Chapter summary

3 Designing a Scalable Graphics Architecture

3.1 Understanding the problem
3.2 Development of the Hybris rendering architecture
3.2.1 Clipping
3.2.2 Fast tile boundary clipping
3.2.3 Fast floating point to fixed-point conversion
3.2.4 Back-face culling
3.2.5 Hierarchicalback-faceculling
3.2.6 Pixel add ressingroundingrules
3.2.7 Sub-pixel triangle culling
3.2.8 Sub-pixel shading correction
3.2.9 An alternative: Point rendering
3.2.10 Half-plane edge functions
3.2.11 Packet data format for atriangle node

3.3 Objectpartitioning

3.3.1 Trianglestrips
3.3.2 Indexedtrianglemeshes
3.3.3 Triangle meshpartitioningwithMeTiS

3.4 Partitioned object-parallel renderer front-end
3.5 Triangle setup and bucket sorting
3.6 Tile-based image-parallel renderer back-end

3.6.1 Pipelinestages
3.6.2 Load balancing the back-end rasterization pipeline
3.6.3 Parallel tile rendering
3.6.4 Image composition of tiles
3.6.5 Interleaved pixel parallel back-end rasterization pipeline
3.6.6 Anti-aliasing for the tile renderer

3.7 Texture mapping
3.8 Chapter summary

4 Codesign for Hardware and Software Implementations

4.1 Designmethodology
4.1.1 Codesign using C language for architectural design
4.1.2 Using C language for hardware description

4.2 Standard physical interfaces

4.2.1 AGP–Afastinterfaceforgraphics
4.2.2 PCI

4.3 Implementing the Hybris graphics architecture

4.3.1 Single CPU software implementation
4.3.2 Multiple CPU parallel software implementation

4.4 ASIC implementation
4.5 FPGA implementation

4.5.1 PCIbandwidth
4.5.2 VGA video out put
4.5.3 Physical properties

4.6 Performance figures for the implementations
4.7 Prospects for future HW/SW implementations
4.8 Chapter summary

5 Interfaces and Applications

5.1 Virtual Reality
5.2 3Dapplicationinterfaces
5.2.1 Immediate-modegraphicsinterface
5.2.2 Retained-modegraphicsinterface

5.3 The Hybris VRML engine
5.4 Introduction to visualization

5.4.1 Direct volume rendering
5.4.2 Surface model extraction
5.5 The 3D-Med medical visualization workstation
5.6 Chapter summary

6 Conclusion

6.1 Summary
6.2 Futurework

Bibliography

Download
PDF Ebook Design for Scalability in 3D Computer Graphics Architectures