---

Glossary

This glossary contains terms that are used specifically for the Apple implementation of OpenGL and a few terms that are common in graphics programming. For definitions of additional OpenGL terms, see OpenGL Programming Guide, by the OpenGL Architecture Review Board.

• AGL (Apple Graphics Library) framework  

  The Apple framework for using OpenGL graphics in Mac OS X applications written in the Carbon environment.



• aliased  

  Graphics whose edges appear jagged; can be remedied by performing anti-aliasing operations.



• anti-aliasing  

  In graphics, a technique used to smooth and soften the jagged (or aliased) edges that are sometimes apparent when graphical objects such as text, line art, and images are drawn.



• ARB  

  The OpenGL Architecture Review Board, which is the group that oversees the OpenGL specification and extensions to it.



• attach  

  An operation that establishes a connection between two existing objects. Compare with bind.



• bind  

  An operation that creates a new object and then establishes a connection between that object and a rendering context.



• bitmap  

  A rectangular array of bits.



• bitplane  

  A rectangular array of pixels.



• buffer  

  A block of memory dedicated to storing a specific kind of data, such as depth values, green color values, stencil index values, color index values, and so forth.



• CGL (Core OpenGL) framework  

  The Apple framework for using OpenGL graphics in Mac OS X applications (Cocoa or Carbon) that need low-level access to OpenGL.



• clipping  

  An operation that identifies the area of drawing. Anything not in the clipping region is not drawn.



• clip coordinates  

  The coordinate system used for view-volume clipping. Clip coordinates are applied after applying the projection matrix and prior to perspective division.



• color-lookup table  

  A table of values used to map color indexes into actual color values.



• completeness  

  A state that indicates whether a framebuffer object meets all the requirements for drawing.



• context  

  A set of OpenGL state variables that affect how drawing is performed for a drawable object attached to that context. Also called a rendering context.



• culling  

  Eliminating parts of a scene that can't be seen by the observer.



• current context  

  The rendering context to which OpenGL routes commands issued by your application.



• current matrix  

  A matrix used by OpenGL to transform coordinates in one system to those of another system, such as the modelview matrix, the perspective matrix, and the texture matrix. GL shading language allows user-defined matrices.



• depth  

  In OpenGL, refers to the z coordinate and specifies how far a pixel lies from the observer.



• depth buffer  

  A block of memory used to store a depth value for each pixel. The depth buffer is used to determine whether or not a pixel can be seen by the observer. Those that are hidden are typically removed.



• display list  

  A list of OpenGL commands that have an associated name and that are uploaded to the GPU, preprocessed, and then executed at a later time. Display lists are often used for computing-intensive commands.



• double buffering  

  The practice of using a front and back color buffer to achieve smooth animation. The back buffer is not displayed, but swapped with the front buffer.



• drawable object  

  In Mac OS X, an object allocated outside of OpenGL that can serve as an OpenGL framebuffer. A drawable object can be any of the following: a window, a view, a pixel buffer, offscreen memory, or a full-screen graphics device. See also framebuffer object



• extension  

  A feature of OpenGL that's not part of the OpenGL core API and therefore not guaranteed to be supported by every implementation of OpenGL. The naming conventions used for extensions indicate how widely accepted the extension is. The name of an extension supported only by a specific company includes an abbreviation of the company name. If more then one company adopts the extension, the extension name is changed to include EXT instead of a company abbreviation. If the OpenGL Architecture Review Board approves an extension, the extension name changes to include ARB instead of EXT or a company abbreviation.



• eye coordinates  

  The coordinate system with the observer at the origin. Eye coordinates are produced by the modelview matrix and passed to the projection matrix.



• fence  

  A token used by the GL_APPLE_fence extension to determine whether a given command has completed or not.



• filtering  

  A process that modifies an image by combining pixels or texels.



• fog  

  An effect achieved by fading colors to a background color based on the distance from the observer. Fog provides depth cues to the observer.



• fragment  

  The color and depth values for a single pixel; can also include texture coordinate values. A fragment is the result of rasterizing primitives.



• framebuffer  

  The collection of buffers associated with a window or a rendering context.



• framebuffer attachable image  

  The rendering destination for a framebuffer object.



• framebuffer object  

  An OpenGL extension that allows rendering to a destination other than the usual OpenGL buffers or destinations provided by the windowing system. A framebuffer object (FBO) contains state information for the OpenGL framebuffer and its set of images. A framebuffer object is similar to a drawable object, except that a drawable object is a window-system specific object whereas a framebuffer object is a window-agnostic object. The context that's bound to a framebuffer object can be bound to a window-system-provided drawable object for the purpose of displaying the content associated with the framebuffer object.



• frustum  

  Defines the region of space that is seen by the observer and that is warped by perspective division.



• FSAA (full scene anti-aliasing)  

  A technique that takes multiple samples at a pixel and combines them with coverage values to arrive at a final fragment.



• gamma correction  

  A function that changes color intensity values to correct for the nonlinear response of the eye or of a display.



• GLU  

  Graphics library utilities.



• GL  

  Graphics library.



• GLUT  

  Graphics library utilities toolkit, which is independent of the window system. In Mac OS X, GLUT is implemented on top of Cocoa.



• GLX  

  An OpenGL extension that supports using OpenGL within a window provided by the X Window system.



• image  

  A rectangular array of pixels.



• immediate mode  

  The practice of OpenGL executing commands at the time an application issues them. To prevent commands from being issued immediately, an application can use a display list.



• interleaved data  

  Arrays of dissimilar data that are grouped together, such as vertex data and texture coordinates. Interleaving can speed data retrieval.



• mipmaps  

  A set of texture maps, provided at various resolutions, whose purpose is to minimize artifacts that can occur when a texture is applied to a geometric primitive whose onscreen resolution doesn't match the source texture map. Mipmapping derives from the latin phrase multum in parvo, which means "many things in a small place."



• modelview matrix  

  A 4 X 4 matrix used by OpenGL to transforms points, lines, polygons, and positions from object coordinates to eye coordinates.



• mutex  

  A mutual exclusion object in a multithreaded application.



• NURBS (non-uniform rational B-spline)  

  A methodology use to specify parametric curves and surfaces.



• packing  

  Converting pixel color components from a buffer into the format needed by an application.



• pbuffer  

  See pixel buffer.



• pixel  

  A picture element; the smallest element that the graphics hardware can display on the screen. A pixel is made up of all the bits at the location x, y, in all the bitplanes in the framebuffer.



• pixel buffer  

  A type of drawable object that allows the use of offscreen buffers as sources for OpenGL texturing. Pixel buffers, introduced in Mac OS X v10.3, allow hardware-accelerated rendering to a texture.



• pixel depth  

  The number of bits per pixel in a pixel image.



• pixel format  

  A format used to store pixel data in memory. The format describes the pixel components (that is, red, blue, green, alpha), the number and order of components, and other relevant information, such as whether a pixel contains stencil and depth values.



• primitives  

  The simplest elements in OpenGL—points, lines, polygons, bitmaps, and images.



• projection matrix  

  A matrix that OpenGL uses to transform points, lines, polygons, and positions from eye coordinates to clip coordinates.



• rasterization  

  The process of converting vertex and pixel data to fragments, each of which corresponds to a pixel in the framebuffer.



• renderbuffer  

  A rendering destination for a 2D pixel image, used for generalized offscreen rendering, as defined in the OpenGL specification for the GL_EXT_framebuffer_object extension.



• renderer  

  A combination of hardware and/or software that OpenGL uses to create an image from a view and a model. The hardware portion of a renderer is associated with a particular display device and supports specific capabilities, such as the ability to support a certain color depth or buffering mode. A renderer that uses only software is called a software renderer and is typically used as a fallback.



• rendering context  

  A container for state information.



• rendering pipeline  

  The order of operations used by OpenGL to transform pixel and vertex data to an image in the framebuffer.



• render-to-texture  

  An operation that draws content directly to a texture target.



• RGBA  

  Red, green, blue, and alpha color components.



• shader  

  A program that computes surface properties.



• shading language  

  A high-level language, accessible in C, used to produce advanced imaging effects. The Apple implementation of OpenGL supports ARB_shading_language_100.



• stencil buffer  

  Memory used specifically for stencil testing. A stencil test is typically used to identify masking regions, identify solid geometry that needs to be capped, and to overlap translucent polygons.



• surface  

  The internal representation of a single buffer that OpenGL actually draws to and reads from. For windowed drawable objects, this surface is what the Mac OS X window server uses to composite OpenGL content on the desktop.



• tearing  

  A visual anomaly caused when part of the current frame overwrites previous frame data in the framebuffer before the current frame is fully rendered on the screen.



• tessellation  

  An operation that reduces a surface to a mesh of polygons or a curve to a sequence of lines.



• texel  

  A texture element used to specify the color to apply to a fragment.



• texture  

  Image data used to modify the color of rasterized fragments; can be one-, two-, three- dimensional or be a cube map.



• texture mapping  

  The process of applying a texture to a primitive.



• texture matrix  

  A 4 x 4 matrix that OpenGL uses to transform texture coordinates to the coordinates that are used for interpolation and texture lookup.



• texture object  

  An opaque data structure used to store all data related to a texture. A texture object can include such things as an image, a mipmap, and texture parameters (width, height, internal format, resolution, wrapping modes, and so forth).



• vertex  

  A three-dimensional point. A set of vertices specify the geometry of a shape. Vertices can have a number of additional attributes such as colors, and texture coordinates. See vertex array.



• vertex array  

  A data structure that stores a block of data that specifies such things as vertex coordinates, texture coordinates, surface normals, RGBA colors, color indices, and edge flags.



• virtual screen  

  A combination of hardware, renderer, and pixel format that OpenGL selects as suitable for an imaging task. When the current virtual screen changes, the current renderer typically changes.

---