Make your own free website on Tripod.com

Glossary

3DFX

A company that produced the Voodoo Chipset, the first successful consumer 3D chipset for the IBM PC.

Application Programming Interface
(API)

Common name used to describe the interface a programmer uses to access a library. Common 3D APIs include OpenGL, Direct3D, QuickDraw3D, Renderman, Glide, and there are dozens of other lesser known ones. The two most popular real-time 3D APIs these days are OpenGL and Direct3D. Glide enjoyed a dominant but brief popularity on the PC platform in the late 1990s.

See Also: Direct3D, Glide, Open Graphics Library.

Direct3D
(D3D)

Microsoft's proprietary 3D API. It was originally written by RenderMorphics and was acquired by Microsoft in 1995. Direct3D is available only on the Windows series of operating systems. Direct3D has captured the mindshare amongst Windows developers, mostly due to the complete lack of any viable alternatives on the PC platform. Microsoft has been pushing Direct3D over OpenGL for many years, sometimes against the opposing wishes of Windows developers.

Accelerated Graphics Port
(AGP)

A dedicated high-speed bus that allows the graphics controller to move large amoumts of data directly from system memory. Uses a Graphics Address Re-Mapping Table (GART) to provide a physically-contiguous view of scattered pages in system memory for (DMA) transfers.

See Also: Direct Memory Access.

Architecture Review Board
(ARB)

The group of companies (including SGI, IBM, Intel, ATI, Nvidia, Microsoft, and others) responsible for the continued refinement and improvement of the OpenGL specifications. It is largely because of the ARB that OpenGL remains a clean, consistent, portable, vendor-neutral API.

See Also: Open Graphics Library.

Direct Rendering

Direct Rendering lets an OpenGL client write directly to the 3D hardware. This is much faster than Indirect Rendering but it can be very complicated to achieve, especially on multi-user systems like UNIX.

See Also: Indirect Rendering.

Direct Memory Access
(DMA)

A facility of some architectures which allows a peripheral to read and write memory without intervention by the CPU. DMA is a limited form of bus mastering.

See Also: Accelerated Graphics Port.

Direct Rendering Interface
(DRI)

One of the problems with Direct Rendering is that other applications (say the X11 server, or other OpenGL clients) might want to talk to the hardware at the same time. In addition there can be problems with security, multiple users, and several other things caused by the complexity of UNIX. An intricate software design called the Direct Rendering Infrastructure coordinates everything and prevents problems. The DRI used on Linux was designed and implemented by Precision Insight (who were recently bought by VA Linux). The DRI only works on XFree86 4.0 or later.

See Also: Direct Rendering.

First-In, First-Out
(FIFO)

Is an approach to handling program work requests from queues so that the oldest request is handled next.

See Also: Direct Rendering.

Direct Rendering Module
(DRM)

This is a kernel module that gives direct hardware access to DRI clients. Every video card has its own specially customised DRM. The DRM handles security, hardware access, protects the system from instability, etc.

See Also: Direct Rendering Interface.

Full Screen Anti Aliasing
(FSAA)

A technique which oversamples each pixel to achieve a more realistic image.

Glide

A 3D API developed by the 3DFX company. Glide only works with Voodoo based 3D cards and in many ways it is very similar to OpenGL. You can write an entire 3D application using Glide and it should (in theory) run on any Voodoo based 3D card. Glide is now open source.

See Also: 3DFX.

Graphics Library Utilities
(OpenGL)

OpenGL is good but doing some common operations is a regular pain in the proverbial. GLU is a platform independent library that can build spheres, perform collision detection, determine if a point is inside a 3D shape, etc. GLU works on top of OpenGL.

See Also: Open Graphics Library.

Graphics Library Utility Toolkit
(GLUT)

OpenGL is platform independent but certain operations (like creating windows, receiving mouse clicks, resizing windows) are done differently over the many platforms supported by OpenGL. GLUT lets you write a single application that will compile and work on Windows, X11, MacOS, etc. GLUT is fairly limited and so it's more useful for simple demonstration programs rather than full blown applications or games.

See Also: Open Graphics Library.

GLX

X11 is a networked windowing system. Your client and your server might be on different machines. GLX packages up OpenGL commands into network packets, spits them across the X11 network pipe, then unpacks them at the other end. This lets you run accelerated 3D remotely: the client could be a simulation on a mainframe, the display could be your desktop machine in your office. GLX does a number of other X11 related things that couldn't be packaged into OpenGL.

See Also: Indirect Rendering, Open Graphics Library, X11.

Indirect Rendering

When OpenGL commands are packaged up with the GLX library and transported across a network pipe (even if that network pipe is local) it is termed Indirect Rendering.

See Also: Direct Rendering.

Mesa

Brian Paul wrote a free open-source implementation of OpenGL called Mesa. The name has no hidden meaning, it just sounds nice. The original versions of Mesa only did software rendering. Recent versions of Mesa have had accelerated backends for Glide, DRI, etc.

See Also: Open Graphics Library.

Memory-Mapped Input-Output
(MMIO)

Operations that access a region of graphics card memory that has been memory-mapped into the virtual address space, or to operations that access graphics hardware registers via a memory-mapping of the registers into the virtual address space (in contrast to PIO).

Note

Graphics hardware "registers" may actually be pseudo-registers that provide access to the hardware FIFO command queue.

See Also: Programmed Input-Output.

Memory Type Range Register
(MTRR)

On Intel P6 family processors (Pentium Pro, Pentium II and later) the Memory Type Range Registers (MTRRs) may be used to control processor access to memory ranges. This is most useful when you have a video (VGA) card on a PCI or AGP bus. Enabling write-combining allows bus write transfers to be combined into a larger transfer before bursting over the PCI/AGP bus. This can increase performance of image write operations 2.5 times or more.

Open Graphics Library
(OpenGL)

SGI originally developed a graphics library called IrisGL for their high-end 3D hardware. They made some clever changes to make it work on any platform and renamed it OpenGL. Very recently SGI relaxed their restrictions for licensing and also released conformance tests for OpenGL. OpenGL abstracts 3D operations such as projections, lighting, rendering, texturing, matrix operations, etc, making it very easy for developers to produce high quality 3D applications.

Programmed Input-Output
(PIO)

Operations that must use the Intel in and out instructions (or equivalent non-Intel instructions) to access the graphics hardware (in contrast to using memory-mapped graphics hardware registers, which allow for the use of mov instructions).

Note

Graphics hardware "registers" may actually be pseudo-registers that provide access to the hardware FIFO command queue.

See Also: Memory-Mapped Input-Output.

Simple Direct-Media Layer
(SDL)

OpenGL only handles graphics (2D and 3D). Sam Lantinga (who now works at Loki Software Inc) wanted to handle cdroms, audio, mixers, joysticks, keyboards, mpeg playback, and anything else related to multimedia and games. He also wanted to do all this in a platform independent way so he could compile and use the same source code on Windows, MacOS, Linux, etc. The SDL library achieves this. SDL relies heavily on other libraries like Mesa to do the grunt work. You can think of SDL as a more powerful version of GLUT.

See Also: Graphics Library Utility Toolkit.

Scan Line Interleaving
(SLI)

A technique where 2 or more 3D processors are used in parallel. Each processor renders only a fraction of the scanlines in the final image. This lets you achieve much higher framerates in games.

Texture mapping

A graphic design process in which a 2D surface, called a texture map, is "wrapped around" a 3D object. Thus, the 3-D object acquires a surface texture similar to that of the 2-D surface.

Transform & Lighting
(T&L)

This is a technique where the 3D card does even more of the 3D calculations. This eases the load on the host CPU which results in significant speed increases for certain applications (especially games).

Utah-GLX

An early project to integrate accelerated 3D into XFree86 3.3. The primitive architecture of Utah-GLX makes it slower than the DRI but it is much simpler to implement and is also easier to write drivers for. This meant Utah-GLX was available earlier than the DRI and with a greater range of supported 3D cards. Utah-GLX is still the only available option for accelerated 3D under XFree86 3.3 unless you have a Voodoo based card.

See Also: Direct Rendering Interface, GLX.

X11

Eleventh version of the X Window System. The X Window System is a network transparent window system which runs on a wide range of computing and graphics machines. X11 has primitives which are useful for the creation of graphical desktops (eg, Windows, Colors, Displays, Screens). You can almost think of X11 as a 2D graphics library but in practice it does far more than that. X11 is also responsible for delivering a unified stream of events describing the user's interaction with input devices like the keyboard, mouse, touch pads, etc.

XFree86

A free open-source implementation of X11. XFree86 implements drivers for a vast array of popular graphics cards and input devices.

See Also: X11.

Z-buffering

An algorithm used in 3-D graphics to ensure that perspective works the same way in the virtual world as it does in the real one: a solid object in the foreground will block the view of one behind it. It works by testing pixel depth and comparing the current position (z coordinate) with stored data in a buffer (called a z-buffer ) that holds information about each pixel's last postion. The pixel in the closer position to the viewer is the one that will be displayed, just as the person in front of the television is what the viewer sees rather than the screen.

Z-buffering is one of three Visual Surface Determination (VSD) algorithms commonly used for this purpose. The other two, BSP trees and depth sorting, work with polygons and consequently are less effective for portrayal of movement and overlap. Since it works at the pixel level, z-buffering can be demanding in terms of memory and processing time. Nevertheless, its more complex and life-like simulation of real-world object dynamics ensures its continuing popularity as a 3-D graphics development tool.

See Also: X11.