Abstract: Interactive Computer Graphicsis the only introduction to computer graphics text for undergraduates that fully integrates OpenGL and emphasizes application-based programming. Graphics Systems and Models; Graphics Programming; Input and Interaction; Geometric Objects and Transformations; Viewing; Shading; From Vertices to Fragments; Discrete Techniques; Programmable Shaders; Modeling; Curves and Surfaces; Advanced Rendering; Sample Programs; Spaces; Matrices; Synopsis of OpenGL Functions. MARKET: For all readers interested in computer animation and graphics using OpenGL.

Abstract: Most existing visualization applications use 3D geometry as their basic rendering primitive. As users demand more complex data sets, the memory requirements for retrieving and storing large 3D models are becoming excessive. In addition, the current 3D rendering hardware is facing a large memory bus bandwidth bottleneck at the processor to graphics pipeline interface. Rendering 1 million triangles with 24 bytes per triangle at 30 Hz requires as much as 720 MB/sec memory bus bandwidth. This transfer rate is well beyond the current low-cost graphics systems. A solution is to compress the static 3D geometry as an off-line pre-process. Then, only the compressed geometry needs to be stored in main memory and sent down to the graphics pipeline for real-time decompression and rendering. The author presents several new techniques for compression of 3D geometry that produce 2 to 3 times better compression ratios than existing methods. They first introduce several algorithms for the efficient encoding of the original geometry as generalized triangle meshes. This encoding allows most of the mesh vertices to be reused when forming new triangles. Their second contribution allows various parts of a geometric model to be compressed with different precision depending on the level of details present. Together, the meshifying algorithms and the variable compression method achieve compression ratios of 30 and 37 to one over ASCII encoded formats and 10 and 15 to one over binary encoded triangle strips. The experimental results show a dramatically lowered memory bandwidth required for real-time visualization of complex data sets.

Abstract: A 3D graphics accelerator operates in parallel with a host central processing unit (CPU) Software executing on the host CPU performs transformation and lighting operations on 3D-object primitives such as triangles, and generates gradients across the triangle for red, green, blue, Z-depth, alpha, fog, and specular color components The gradients for texture attributes are also generated and sent to the graphics accelerator Both the graphics accelerator and the CPU software perform triangle edge and span walking in synchronization to each other The CPU software walks the triangle to interpolate non-texture color and depth attributes, while the graphics accelerator walks the triangle to interpolate texture attributes The graphics accelerator performs a non-linear perspective correction and reads a texture pixel from a texture map The texture pixel is combined with a color pixel that is received from the CPU software interpolation of non-texture attributes Once the texture pixel from the graphics accelerator and the color pixel from the CPU software are sent to a blender in the graphics accelerator, both continue to interpolate the next pixel in the horizontal-line span, or move to a pixel in the next span Both the CPU software and the graphics accelerator interpolate the same pixel at the same time Using both the CPU and the graphics accelerator improves performance since both operate in parallel on the same pixel at the critical interpolation bottleneck

Abstract: This paper presents a computer graphics algorithm useful for rapidly generating image data for full parallax spatial displayssuch as full parallax holographic stereograms. Other techniques such as custom-designed ray-tracing packages and image-based rendering techniques have significant disadvantages for rapid display production. In contrast, the method described hereuses scanline-based computer graphics techniques. The described implementation uses the widely available OpenGLTM graph-ics library and takes advantage of acceleration by computer graphics hardware subsystems. The time required to render theimage data of a moderately-sized scene for a single holographic exposure is less than one second using desktop computer sys-tems. This method is compatible with both one-step and master-transfer holographic recording geometries. Details of the algo-rithm are included.Keywords: full parallax, computer graphics, holographic stereogram, holography. 1. INTRODUCTION In the field of computer-generated holographic stereography, improvements in holographic printer design and image genera-tion methods have recently turned full parallax displays from a rare novelty to a viable technology. A growing number ofresearch groups are experimenting with full parallax stereograms in both the master-transfer and one-step geometries. Theseexperiments have led to an increasing demand for an efficient yet flexible way to render image sequences for full parallax dis-plays.

Abstract: With the development of virtual reality systems and multi-modal simulations, soundtrack generation is becoming an important issue in computer graphics. In the context of computer generated animation, many more parameters than the sole object geometry as well as specific events can be used to generate, control and render a soundtrack that fits the object motions. Producing a convincing soundtrack involves the rendering of the interactions of sound with the dynamic environment : in particular sound reflections and sound absorption due to partial occlusions, usually implying an unacceptable computational cost. We present an integrated approach to sound and image rendering in a computer animation context, which allows the animator to recreate the process of sound recording, while ``physical effects" are automatically computed. Moreover, our sound rendering process efficiently combines a sound reflection model and an attenuation model due to scattering/diffraction by partial occluders, through the use of graphics hardware allowing interactive computation rates.

Abstract: Currently graphics devices that offer both high performance and high quality interactive rendering have been priced at a level that places them out of the reach of the broad number of users that constitutes the massmarket. Because of the cost constraints placed on graphics devices designed for the massmarket, they often trade off image quality in order to get reasonable rendering rates with minimum use of hardware. This approach is not leading to a rapid adoption of true 3D graphics technology for the broadest number of users. The goal of the Talisman initiative is to make 3D graphics truly ubiquitous. This requires that both high performance and high quality interactive rendering be made available at mass-market price points. This means that trading off image quality, as a means to obtain high performance rendering is unacceptable. In this paper it will be shown that high quality rendering is a natural extension of the highperformance rendering architecture embodied in Talisman.

Abstract: A graphics system includes a graphics processor for rendering graphics primitives with a list of display parameters. A host processor generates a display list which includes a XY address for rendering the graphics primitives. A graphics processor which includes an arbitration logic device enables the graphics processor to temporarily arbitrate shared resources to dissimilar graphics drawing engines. The arbitration logic allows data from the dissimilar drawing engines to be prioritized, depending on the configuration of the underlying computer system, for accessing shared resources.

Abstract: Levels of detail (LODs) are used in interactive computer graphics to avoid overload of the rendering hardware with too many polygons. While conventional methods use a small set of discrete LODs, we introduce a new class of polygonal simplification: Smooth LODs. A very large number of small details encoded in a data stream allows a progressive refinement of the object from a very coarse approximation to the original high quality representation. Advantages of the new approach include progressive transmission and encoding suitable for networked applications, interactive selection of any desired quality, and compression of the data by incremental and redundancy free encoding.

Abstract: The OpcnGL Graphics System provides a well-specified, widelyaccepted dataflow for 3D graphics and imaging. OpenGL is an UTclrirechaa; nn OpenGL-capable computer is a hardware manifestation or ir,~plenrentution of that architecture. The Onyx2 InfiniteReality nnd 02 workstations exemplify two very different implementntions of OpenGL. The hvo designs respond to different cost, performance, and capability goals. Common practice is to describe a graphics hardware implementntion bnscd on how the hardware itself operates. However, this pnper discusses hvo OpenGL hardware implementations based on how they embody the OpenGL architecture. An important thread throughout is how OpenGL implementations can be designed not merely based on gmphics price-performance considerations, but nlso with considemtion of larger system issues such as memory architecture, compression, and video processing. Just as OpenGL is influenced by wider system concerns, OpenGL itself can provide a clarifying influence on system capabilities not conventionally thought of as graphics-related. CR Categories: 1.3.1 [Computer Graphics]: Hardware Architecture; 1.3.6 [Computer Graphics]: Methodology and TechniquesStandards

Abstract: This thesis describes a computer graphics method for efficiently rendering images of static geometric scene databases from multiple viewpoints. Three-dimensional displays such as parallax panogramagrams, lenticular panoramagrams, and holographic stereograms require samples of image data captured from a large number of regularly spaced camera images in order to produce a three-dimensional image. Computer graphics algorithms that render these images sequentially are inefficient because they do not take advantage of the perspective coherence of the scene. A new algorithm, multiple viewpoint rendering (MVR), is described which produces an equivalent set of images one to two orders of magnitude faster than previous approaches by considering the image set as a single spatio-perspective volume. MVR uses a computer graphics camera geometry based on a common model of parallax-based three-dimensional displays. MVR can be implemented using variations of traditional computer graphics algorithms and accelerated using standard computer graphics hardware systems. Details of the algorithm design and implementation are given, including geometric transformation, shading, texture mapping and reflection mapping. Performance of a hardware-based prototype implementation and comparison of MVR-rendered and conventionally rendered images are included. Applications of MVR to holographic video and other display systems, to three-dimensional image compression, and to other camera geometries are also given. (Copies available exclusively from MIT Libraries, Rm. 14-0551, Cambridge, MA 02139-4307. Ph. 617-253-5668; Fax 617-253-1690).

Abstract: Collision detection between complex objects using rasterizing graphics hardware provides a rich ground of exploration for speeding up the interference detection algorithms and computing points of collision. We show that despite the limitations imposed by the current graphics rendering hardware, it is still possible to perform collision detection at rendering rates using only conventional graphics hardware without any enhancements.

Abstract: A printer includes an input unit for inputting color page description information, creation means for creating intermediate information for recording by analyzing color page description information which has been input, an execution unit for executing fast hardware rendering with a hardware for the intermediate information, and a switch for switching the fast hardware rendering into a software rendering in the case of a high grade color logical drawing which cannot be supported by the hardware.

Abstract: A graphics system includes a graphics processor for rendering graphics primitives with a list of display parameters. A host processor generates a display list which includes a XY address for rendering the graphics primitives. A graphics processor which includes an address tracking logic circuit tracks the rendering primitive to determine the minimum and maximum XY addresses of the rendered primitive. By tracking of the XY address, the graphics processor is able to internally cache only modified portions of the rendered primitive thereby improving the graphics processor's access cycle to the modified data. Accordingly, the graphics processor's memory bandwidth requirements is reduced.

Abstract: Because most existing multi resolution methods are slow, a common approach is to pregenerate a few key models of the object at different resolutions. During run time, the object's distance from the viewer determines which model to use for rendering. Although this approach is simple, it suffers from the sudden change in resolution as the object moves across the threshold distance. In addition, the model used to represent an object at a particular frame is not optimized for the given dynamic viewing and animation parameters. The quadtree type of methods for arranging the surface model may allow adaptive multi resolution modeling in a simple way and it reduces the sudden change of resolution from the object level to the node level. However, the square shape of the node, together with the four-time increment in size for representing surfaces, limits the types of surfaces that it can handle without creating excessive nodes. We present a real time adaptive multi resolution method for models of arbitrary topology.

Abstract: A scalable, three-dimensional (3D) graphics subsystem. The graphics subsystem includes a plurality of graphics modules each including a rendering module and a dedicated memory. In one embodiment, the rendering modules of the graphics modules are coupled together, possibly through a routing device, such that each rendering module views the memory space, formed by all dedicated memory, as one continuous shared memory.

Abstract: A method an system provide that image processing operations and graphics processing are both performed by a graphics rendering system. The texture memory and a texture filter of the graphics rendering system are used to perform look-up table operations as well as multiply and accumulate operations typically associated with image processing.

Abstract: D graphics transform 3D models into 2D images by simulating the physics of light propagation from the lighting sources, through the objects, and eventually to the eyes. Although specialized graphics hardware engines have been proposed and implemented in the past, and a heated in- terest in PC-class 3D graphics cards is currently emerging, detailed descriptions and analysis of 3D graphics workloads which graphics hardware design can be based on are almost non-existent. This work takes the first step towards a compre- hensive 3D graphics workload characterization by reporting the results of an empirical study us- ing an instrumented software polygonal renderer tested on a wide variety of static 3D graphics models with sufficiently sophisticated geometric and texture properties.

Abstract: An optimized, superscalar microprocessor architecture for supporting graphics operations in addition to the standard microprocessor integer and floating point operations. A number of specialized graphics instructions and accompanying hardware for executing them are disclosed to optimize the execution of graphics instruction with minimal additional hardware for a general purpose CPU.

Abstract: Recent advances in hardware and software have made it possible to teach a three-climensional graphics class for computer science and engineering students on almost any platform. Such a class can be very different from traditional first courses in computer graphics. This paper presents a top-down approach to such a class based on the OpenGL Appl icat ion Programmers Interface. Introduction To the typical senior in computer science or engineering, an elective class in computer graphics appears to present an opportunity to explore the wonders of computer-generated imagery and to learn to design their own applications. Unfortunately, the reality often has been somewhat disappointing. Although there are a variety of reasons for our inability to have provided such classes in the past, recent developments in hardware and software now make it possible to teach a true three-dimensional class in almost any college environment. This presentation starts from the point of view that the reasons that defeated us in the past no longer exist. However, the nature of present hardware and software forces us to reorient a typical senior-level class. This new class can be far more exciting than previous graphics classes.This paper describes a class that uses OpenGL and its associated architecture.A sequence of typical programming assignments will be discussed and the presentation will show examples of student projects. Although most of what was just stated may seem obvious to those who have been teaching three-dimensional graphics, the fact remains that most beginning classes still do not follow this approach.The goal of this presentation is to convince instructors of traditional first classes that this approach is both feasible and effective. Why Should We Teach a Three-dimensional Class? There have been three fundamental approaches to teaching computer graphics to seniors and beginning graduate students in computer science and engineering. In the first approach, the class surveys the field. Little or no programming is involved. Such a course is easy to support because it requires very little hardware or software and places a minor burden on an instructor who might not be an expert in the field.Three-dimensional concepts are covered, but typically the students do not program a three-dimensional application. In the second approach, the bot tom-up approach, students start by learning to draw lines and simple two-dimensional curves, and explore issues such as clipping and rasterization.Typically, the students build simple raster packages but at best just touch on threedimensional concepts.Again such a course has been easy to suppo~ The third approach is to start in three dimensions and not worry about issues such as rasterization and clipping until late in the class. Until recently, such a course has been more difficult to support but we shall argue below that such is no longer the case. There is an analogy made by John Kemeny between automobiles and computer literacy that can be used to explain why the third approach should be preferred. You don't need to know how a car works (the bottom-up approach) to drive it. You can know nothing about driving a car and hire a chauffeur to drive you around (the survey approach). But if you really want to see the world and control your destiny, you should learn to drive. If that is the case, then why has the communi ty not fo l lowed this th i rd approach? Why Can't We Teach a Graphics Class in Three Dimensions? Many educators would like to emphasize threedimensional graphics in their classes but have felt stymied by the lack of suitable hardware and software. However, we have reached the point where PCs have capabilities that far exceed the graphics workstations of a few years ago, and much of the software that used to run only on high-end workstations now runs on PCs. In addition, the cost of hardware and software no longer is a problem for most universities. Another set of objections have been raised by instructors who teach graphics classes but are not experts in the field.These people may represent a majority of the instructors for the first class. Learning a software system such as PHIGS and getting it running has been a daunting task. However, OpenGL provides an alternative that is both easy to learn and easy to obtain for virtually all environments. Within the graphics community, there are (still) many who feel that a three-dimensional graphics class should be built on a solid foundation that encompasses two-dimensional concepts. There are t w o problems wi th this approach. One is that such a class often never gets to three-dimensional graphics, or deals with three-dimensional concepts in a cursory manner, leaving the students disappointed in the class. Second, two-dimensional concepts do not extend very well to modern three-dimensional core topics such as shading. Here we contend that a top-down approach using OpenGL allows the instructor to start wi th threedimensions but leads naturally to a later discussion of two-dimensional topics such as scan conversion. Why Not RayTracing? Once an instructor decides to pursue the three-dimensional top-down approach, there are two viable approaches: ray tracing and a pipeline renderer. The ray tracing approach is attractive because it allows the instructor to use a minimum amount of software if students are to build their own ray tracers and it follows a physical approach. However, ray tracers do not allow real-time rendering and thus interaction is not part of such classes. In addition, ray tracers are very difficult to extend to other than very simple primitives. Regardless of whether rendering is done in hardware or software, most graphics workstations and PCs use pipeline renderers. Until recently, much of the software that used these renderers was too expensive or complex to use in a first class.The availability of OpenGL has changed this picture dramatically. Implementations are available for virtually all workstations and PCs.There are also a number of free implementations available. I shall show that the OpenGL Application Programmer's Interface (API) is easy to program and OpenGL's well defined architecture allows a coherent presentation of implementation issues. A Top-Down Approach The course described here is top-down. Students start programming non-trivial threedimensional applications wi th the first few weeks of the class and are doing shading applications by the middle of the semester. One of the characteristics of a top-down approach is that we can start with a discussion of image formation by a variety of methods including cameras, the human visual system and computers.The pipeline model used by OpenGL fits well with this approach as students see that two-dimensional graphics is a special case of three-dimensional graphics and also see the imaging process as involving a sequence of transformations. Hence, although the first two projects could be done exclusively with a twodimensional system, by starting in three dimensions, students learn about or thographic 54 August 1997 Computer Graphics

Abstract: A graphics system includes a graphics processor for rendering graphics primitives with a list of display parameters. A host processor generates a display list which includes an XY address for rendering the graphics primitives. A graphics processor, which includes a bypass logic circuit, enables the graphics processor to temporarily store display list commands in an internal storage device while previously fetched display list data is being processed. The bypass logic circuit allows the graphics processor to bypass the internal storage device and write fetched command directly to an execution unit in the graphics processor. By having the bypass capabilities, the graphics processor is able to optimize the internal storing of commands in the display list in the internal storage unit.

Abstract: A graphics system includes a graphics processor (100) for rendering graphics primitives with a list of display parameters. A host processor generates a display list which includes an XY address for rendering the graphics primitives. A graphics processor (100) which includes internal fetch and store static random access memory (SRAM) devices (160) for storing pixel fetched from an external memory device (85) and processed in the graphics processor (100) respectively. The graphics processor (100) also includes selective pixel data fillers for writing either X or Y position pixel data to the internal SRAM devices (160). By selectively storing either X or Y position pixel data, the graphics processor (100) is able to perform bit-block data transfers (blts) of pixel data to the internal SRAM (160) thereby efficiently utilizing the local bandwidth of the internal SRAM (160).

Abstract: This paper reports on the remote use of MIMD parallel machines for compute-intensive visualisation tasks. As an alternative to dedicated rendering hardware, a system using conventional desktop machines connected to a visualisation server permits sharing of the resource between several users, and/or sites. The design of a parallel rendering system should consider not only how to achieve efficient parallel performance, but how to minimise response time, that is, the time taken from the specification of the viewing parameters to the display of the completed image. Progressive refinement and latency hiding techniques are proposed as a method of reducing the latency of a distributed rendering system. In distributed rendering, integrating the transmission of the image with the rendering process allows the latency introduced by the network to be hidden. Timing data are presented demonstrating the scalability of the parallel algorithm and its interactive use over LAN networks.

Abstract: We have developed a Web based application to accelerate the visualization of VRML scenes located in a remote server. This application enables the user to extract only the parts of a scene that are of actual interest. The extracted parts represent one or more sub trees of the hierarchical structure of the VRML scene, and only these parts will be rendered and visualized in the local computer. By reducing the complexity (size) of the remote scene, less data are transmitted from the remote server and the rendering process becomes faster in the local computer. The application is written in Java and is executed as an applet embedded in an HTML page.

Abstract: A graphics system includes a graphics processor for rendering graphics primitives with a list of display parameters. A host processor generates a display list which includes a XY address for rendering the graphics primitives. A graphics processor which includes internal fetch and store static random access memory (SRAM)devices for storing pixel fetched from an external memory device and processed in the graphics processor respectively. The graphics processor also includes a pixel data striping control logic which determines whether fetch and store requests by the graphics processor crosses an X boundary in the internal SRAM devices. If a fetch or store request crosses an X boundary, the memory control logic stripes the access into separate blocks of pixel data for each access which are then simultaneously accessed during a single data request cycle. By striping pixel data accessed, the graphics processor is able to execute a single pixel dat request without crossing a X boundary even if the original pixel data being accessed spans multiple tiles in the memory device.

Abstract: Image processing is usually associated with pattern recognition and is rather treated as a subject outside of the computer graphics interest. Basically, computer graphics algorithms are used for the visualization of scenes or models described using some abstract notation, while image processing is used in the opposite way – i.e. when finding an abstract description of the analysed pattern. This paper proposes to use the image processing approach for rendering optical effects in computer graphics algorithms. Efficient techniques for rendering various weather conditions are very important for the development of flight and driving simulators. Under heavy rain drivers and pilots are very disturbed by the raindrops and the water film falling on the windshield. This paper proposes an efficient technique for rendering optical effects caused by the rain on the windshield, by adaptive iterative picture filtering. The advantage of the image processing algorithm described in this paper is that it can be easily implemented in a pipeline. The extensions based on the proposed algorithm can be added to the existing rendering systems as final stages of the visualization pipeline. Proposed algorithm can be used for the real-time generation of realistic and artistic optical effects in, for example, visual simulators, virtual reality and multi-media applications.

Abstract: Time critical rendering (TCR) has recently attracted much attention as an important framework for creating immersive virtual environments. TCR trades time indulgent pursuit of high quality rendering for direct control over the timing of rendering according to the variable frame rates required for participants' interactions, so that more responsive interactivity can be achieved to keep him/her immersed in a virtual environment. The paper proposes a highly effective TCR approach to the level of detail control of textures used in image based virtual reality systems. Specifically, an adaptive texture mapping strategy based on a human behavior model is presented, where both the psychological and ergonomic aspects of interior space evaluation are taken into account to achieve more reasonable image qualities and frame rates than the conventional viewing distance based texture mapping. The feasibility of the new strategy is proven through preliminary space navigation experiments using a simple virtual showroom.

Abstract: As the resolution of simulation models increases, scientific visualization algorithms which take advantage of the large memory and parallelism of massively parallel processors (MPPs) are becoming increasingly important. For large applications, rendering on an MPP tends to be preferable to rendering on a graphics workstation, due to the MPP's abundant resources: memory, disk and numerous processors. The challenge is developing algorithms that can exploit these resources while minimizing overheads, typically communication costs. This paper describes recent efforts in parallel rendering for polygonal primitives as well as parallel volumetric techniques. It presents rendering algorithms, developed for MPPs, for polygonal, spherical and volumetric data. The polygon algorithm uses a data-parallel approach, whereas the sphere and volume rendering use a MIMD approach. Implementations for these algorithms are presented for a Thinking Machines Corp. CM-5 and a Cray Research Inc. T3D.

Abstract: Direct volume rendering algorithms are too computationally expensive to offer interactive frame rates when rendering large 3D medical datasets on standard workstations. This article presents an image space parallelization of an image order volume rendering algorithm aimed at shared memory multiprocessors. This parallel implementation of direct volume rendering can significantly speed up rendering times and visualize 3D datasets with speeds of several frames per second. The algorithm was implemented and evaluated on Convex SPP Exemplar and SGI Challenge multiprocessors.