Search

With the emergence of 3D graphics/arts assets commerce on the Internet, to protect their intellectual property and to restrict their usage have become a new design challenge. This paper presents a novel protection model for commercial graphics data by integrating digital rights management into the graphics processing unit and creating a digital rights enabled graphics processing system to defend against piracy of entertainment software and copyrighted graphics arts. In accordance with the presented model, graphics content providers distribute encrypted 3D graphics data along with their certified licenses. During rendering, when encrypted graphics data, e.g. geometry or textures, are fetched by a digital rights enabled graphics processing system, it will be decrypted. The graphics processing system also ensures that graphics data such as geometry, textures or shaders are bound only in accordance with the binding constraints designated in the licenses. Special API extensions for media/software developers are also proposed to enable our protection model. We evaluated the proposed hardware system based on cycle-based GPU simulator with configuration in line with realistic implementation and open source video game Quake 3D.

The graphics processor (GPU) on today's commodity video cards has evolved into an extremely powerful and flexible processor. Modern graphics architectures provide tremendous memory bandwidth and computational horsepower, with dozens of fully programmable shading units that support vector operations and IEEE floating point precision. High-level languages have emerged for graphics hardware, making this computational power accessible. GPGPU stands for "General-Purpose Computation on GPUs". GPGPU researchers have achieved over an order of magnitude speedup over modern CPUs on some non-graphics problems.This course provides detailed coverage of general-purpose computation on graphics hardware. We emphasize core computational building blocks, ranging from linear algebra to database queries, and review the tools, perils, and strategies in GPU programming. We present analysis of GPU performance characteristics, and use this analysis to provide insight into how to build efficient GPGPU algorithms. Finally we present a set of case studies on general-purpose applications of graphics hardware.

Author(s): Kniss, Joe M.; Lefohn, Aaron; Strzodka, Robert; Sengupta, Shubhabrata; Owens, John D. | Abstract: We implement an interactive 3D painting application that stores paint in an octree-like GPU-based adaptive data structure. Interactive painting of complex or unparameterized surfaces is an important problem in the digital film community. Many models used in production environments are either difficult to parameterize or are unparameterized implicit surfaces. We address this problem with a system that allows interactive 3D painting of complex, unparameterized models. The included movie demonstrates interactive painting of a 817k polygon model with effective paint resolutions varying between 64^3 to 2048^3. Our implementation differs from previous work in two important ways: first, it uses an adaptive data structure implemented entirely on the GPU, and second, it enables interactive performance with high quality by supporting quadlinear (mipmapped) filtering and fast, constant-time data accesses.

It has become increasingly difficult to drive a modern highperformance graphics accelerator at full speed with a serial immediate-mode graphics interface. To resolve this problem, retainedmode constructs have been integrated into graphics interfaces. While retained-mode constructs provide a good solution in many cases, at times they provide an undesirable interface model for the application programmer, and in some cases they do not solve the performance problem. In order to resolve some of these cases, we present a parallel graphics interface that may be used in conjunction with the existing API as a new paradigm for highperformance graphics applications. The parallel API extends existing ideas found in OpenGL and X11 that allow multiple graphics contexts to simultaneously draw into the same image. Through the introduction of synchronization primitives, the parallel API allows parallel traversal of an explicitly ordered scene. We give code examples which demonstrate how the API can be used to expose parallelism while retaining many of the desirable features of serial immediate-mode programming. The viability of the API is demonstrated by the performance of our implementation which achieves scalable performance on a 24 processor system. CR

In this paper we introduce a new compressed representation for the connectivity of a triangle mesh. We present local compression and decompression algorithms which are fast enough for real time applications. The achieved space compression rates keep pace with the best rates reported for any known global compression algorithm. These nice properties have great benefits for several important applications. Naturally, the technique can be used to compress triangle meshes without significant delay before they are stored on external devices or transmitted over a network. The presented decompression algorithm is very simple allowing a possible hardware realization of the decompression algorithm which could significantly increase the rendering speed of pipelined graphics hardware. CR Categories: I.3.1 [Computer Graphics]: Hardware Architecture; I.3.3 [Computer Graphics]: Picture/Image Generation— Display algorithms

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.

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

FBRAM, a new form of dynamic random access memory that greatly accelerates the rendering of Z-buffered primitives, is presented. Two key concepts make this acceleration possible. The first is to convert the read-modify-write Z-buffer compare and RGBa blend into a single write only operation. The second is to support two levels of rectangularly shaped pixel caches internal to the memory chip. The result is a 10 megabit part that, for 3D graphics, performs read-modify-write cycles ten times faster than conventional 60 ns VRAMs. A four-way interleaved 100MHz FBRAM frame buffer can Z-buffer up to 400 million pixels per second. Working FBRAM prototypes have been fabricated.

The design principles that were applied in the design of the integer-RISC machine, are applied to the design of the Reduced Instruction Set Graphics Processor. The processor instruction is defined after critical evaluation of the common graphics operations. Single cycle operation (in a pure RISC style) are performed through instructions for primitive graphics as well as general purpose computations. This processor is envisioned to become the CPU of choice for the ergonomic applications that rely heavily on graphics capabilities for user interface bandwidth improvement. The motivation for integrating graphics with general-purpose computations stems from the performance enhancement acheived due to increased integration levels, and the program portability offered by a single processor based systems.

The XEROX Star 8010 Information System features an integrated text and graphics editor. The Star hardware consists of a processor, a large bit-mapped display, a keyboard and a pointing device. Star's basic graphic elements are points, lines, rectangles, triangles, graphics frames, text frames and bar charts. The internal representation is in terms of idealized objects that are displayed or printed at resolutions determined by the output device. This paper describes the design and implementation of a graphics editor using an object-oriented technique based on a Star-wide subclassing method called the Trait Mechanism.

This paper describes the architecture of the micro-programmed processor which is the heart of the Adage GP/400 interactive graphics system, and discusses some of the factors which influenced its design.

The development of our graphics environment over the past year has been directed towards demonstrating the concept of broadcast teletext service, where pages of graphics and text are received in the home over existing television channels. We have developed a graphics editor, Radix, which uses an underlying Core graphics package to create teletext-compatible images. Radix is also used to display these images at arbitrary resolutions by scaling the graphics primitives, selecting the corresponding sizes of fonts and bitmaps, and then precisely adjusting the output video signal. The combination of powerful display hardware and a robust set of software tools has allowed us to rapidly prototype potential teletext features, and to provide these accurate simulations of teletext pages at any resolution. While this general graphics environment does impose some inefficiencies in running graphics applications, they are far outweighed by the ability to quickly respond to changing requirements.

A computer graphics system with refresh and storage displays, flat-bed plotter, digitizer and film recorder is described. The software structure comprises a device-independent, front-end graphics package and a driver program for each device. Two and three-dimensional vectors, hardware and software characters, transformations and windowing, picture segmentation, element and segment attributes, and input from interactive tools, such as a light-pen, are supported. The extent to which the system is used by different research groups shows that this is a very cost-effective way to provide computer graphics facilities.

In this paper we present a conceptual model of raster graphics systems which integrates, at a suitable level of abstraction, the major features found in both contemporary and anticipated graphics systems. These features are the refresh buffer; the image creation (scan-conversion) system; the single address-space architecture which integrates the address space of the refresh buffer with those of the image creation system and the associated general-purpose computer; the RasterOp or BitBlt instructions found in some single address-space architectures; the video look-up table, and refresh buffer to screen transformations. Also included are the major components from the conceptual model of vector graphics systems which are embodied in the ACM/SIGGGRAPH/GSPC Core System. Using the conceptual model as a base, we proceed to sketch out the capabilities we have defined in a substantial addition to the Core System. The capabilities are currently being implemented as part of the George Washington University Core System.

The design and implementation of a basic graphics system for a heterogeneous network environment is described. The design has been influenced by the SIGGRAPH Core System, GKS, and proposals being considered by the ANSI Technical Committee on Computer Graphics Programming Languages. It permits hierarchical object definition, direct and indirect attribute specification, screen window management and complex styles of interaction. Important parts of the implementation include a device-independent database for graphical objects, a workstation driver which produces device code, and a device kernel which manages the display list. Problems relating to device independence and network partitioning are discussed.

Stand alone graphic systems and time-shared graphics provide different benefits to a user. The same is true of refresh graphics and storage displays. An operating system is described which supports these combined modes through the integration of graphics into the operating system. Realization of the role of the system, generality, and flexibility were the major factors in the development of the system. The result is a computer graphic system providing high-level interactive graphics at a relatively low cost.

Los Alamos Scientific Laboratory (LASL) has implemented a graphics system designed to support one user interface for all graphics devices in all operating environments at LASL. The Common Graphics System (CGS) will support Level One of the graphics standard proposed by the ACM/SIGGRAPH Graphic Standards Planning Committee. CGS is available in six operating environments of two different word lengths and supports four types of graphics devices. It can generate a pseudodevice file that may be postprocessed and edited for a particular graphics device, or it can generate device-specific graphics output directly. Program overlaying and dynamic buffer sharing are also supported. CGS is structured to isolate operating system dependencies and graphics device dependencies. It is written in the RATFOR (RATional FORtran) language, which supports control flow statements and macro expansion. CGS is maintained as a single source program from which each version can be extracted automatically.

Computer graphics displays in the neurosciences are classified into three categories: anatomical structures, physiological waveforms, and statistical summaries. The capabilities required in a line drawing system to present neuroscience displays are smooth rotation and translation of 3D structures, simple line rejection, orthographic projection, and flexible interactive hard copy capable of drawing dots. The general purpose computer is available to refresh the CRT. A simple graphics processor with the necessary capabilities is defined and its unique features are discussed.

This paper responds to the 1977 Core Graphics System of SIGGRAPH's Graphic Standards Planning Committee (GSPC). The authors are interested in low-level device-independent graphics for applications doing data representation and annotation. The level structure and bias in the Core System toward display list processor graphics are criticized. Specific issues discussed include display contexts, attributes, current position, 3-dimensional graphics, area filling, and graphics input.

GRAF80 is a small scale graphics system designed to demonstrate some of the capabilities offered by microprocessor-assisted graphics. As such, it employs both hardware and software techniques. The system implements in a microprocessor a subset of the features of the SIGGRAPH-ACM CORE (1) graphics package, including picture segmentation and a subset of the output primitives and primitive attributes.

S (pronounced SIGMA denoting Simulation Graphical Modeling and Analysis) is an interactive graphics approach to building, testing, and experimenting with discrete event simulation models on personal computers. S is written in C but is self-contained and does not need a compiler or special graphics software. S is an extension of the simulation teaching system report in [2].The version of S described here requires an IBM PC compatible computer (AT preferred) with at least 420K of free memory, a floppy disk drive, an EGA or equivalent monitor with the corresponding graphics card, and a mouse.

An interactive graphics space allocation system is described with which a designer at the console of an IBM 2250 can generate and edit preliminary building layouts.