- accumulation buffer
Memory (bitplanes) that is used to accumulate a series of images generated in the color buffer. Using the accumulation buffer may significantly improve the quality of the image, but also take correspondingly longer to render. The accumulation buffer is used for effects such as depth of field, motion blur, and full-scene antialiasing.

- aliasing
A rendering technique that assigns to pixels the color of the primitive being rendered, regardless of whether that primitive covers all or only a portion of the pixel's area. This results in jagged edges, or jaggies.

- alpha
A fourth color component. The alpha component is never displayed directly and is typically used to control color blending. By convention, OpenGL alpha corresponds to the notion of opacity rather than transparency, meaning that an alpha value of 1.0 implies complete opacity, and an alpha value of 0.0 complete transparency.

- ambient
Ambient light is nondirectional and distributed uniformly throughout space. Ambient light falling upon a surface approaches from all directions. The light is reflected from the object independent of surface location and orientation with equal intensity in all directions.

- animation
Generating repeated renderings of a scene, with smoothly changing viewpoint and/or object positions, quickly enough so that the illusion of motion is achieved. OpenGL animation is almost always done using double-buffering.

- antialiasing
A rendering technique that assigns pixel colors based on the fraction of the pixel's area that's covered by the primitive being rendered. Antialiased rendering reduces or eliminates the jaggies that result from aliased rendering.

- application-specific clipping
Clipping of primitives against planes in eye coordinates; the planes are specified by the application using

`glClipPlane()`.- attribute group
A set of related state variables, which OpenGL can save or restore together at one time.

- back faces
See faces.

- bit
Binary digit. A state variable having only two possible values: 0 or 1. Binary numbers are constructions of one or more bits.

- bitmap
A rectangular array of bits. Also, the primitive rendered by the

`glBitmap()`command, which uses its*bitmap*parameter as a mask.- bitplane
A rectangular array of bits mapped one-to-one with pixels. The framebuffer is a stack of bitplanes.

- blending
Reduction of two color components to one component, usually as a linear interpolation between the two components.

- buffer
A group of bitplanes that store a single component (such as depth or green) or a single index (such as the color index or the stencil index). Sometimes the red, green, blue, and alpha buffers together are referred to as the color buffer, rather than the color buffers.

- C
God's programming language.

- C++
The object-oriented programming language of a pagan deity.

- client
The computer from which OpenGL commands are issued. The computer that issues OpenGL commands can be connected via a network to a different computer that executes the commands, or commands can be issued and executed on the same computer. See also server.

- client memory
The main memory (where program variables are stored) of the client computer.

- clip coordinates
The coordinate system that follows transformation by the projection matrix and precedes perspective division. View-volume clipping is done in clip coordinates, but application-specific clipping is not.

- clipping
Elimination of the portion of a geometric primitive that's outside the half-space defined by a clipping plane. Points are simply rejected if outside. The portion of a line or of a polygon that's outside the half-space is eliminated, and additional vertices are generated as necessary to complete the primitive within the clipping half-space. Geometric primitives and the current raster position (when specified) are always clipped against the six half-spaces defined by the left, right, bottom, top, near, and far planes of the view volume. Applications can specify optional application-specific clipping planes to be applied in eye coordinates.

- color index
A single value that represents a color by name, rather than by value. OpenGL color indices are treated as continuous values (for example, floating-point numbers), while operations such as interpolation and dithering are performed on them. Color indices stored in the framebuffer are always integer values, however. Floating-point indices are converted to integers by rounding to the nearest integer value.

- color-index mode
An OpenGL context is in color-index mode if its color buffers store color indices rather than red, green, blue, and alpha color components.

- color map
A table of index-to-RGB mappings that's accessed by the display hardware. Each color index is read from the color buffer, converted to an RGB triple by lookup in the color map, and sent to the monitor.

- components
Single, continuous (for example, floating-point) values that represent intensities or quantities. Usually, a component value of zero represents the minimum value or intensity, and a component value of one represents the maximum value or intensity, though other ranges are sometimes used. Because component values are interpreted in a normalized range, they are specified independent of actual resolution. For example, the RGB triple (1, 1, 1) is white, regardless of whether the color buffers store 4, 8, or 12 bits each.

Out-of-range components are typically clamped to the normalized range, not truncated or otherwise interpreted. For example, the RGB triple (1.4, 1.5, 0.9) is clamped to (1.0, 1.0, 0.9) before it's used to update the color buffer. Red, green, blue, alpha, and depth are always treated as components, never as indices.

- concave
Not convex.

- context
A complete set of OpenGL state variables. Note that framebuffer contents are not part of OpenGL state, but that the configuration of the framebuffer is.

- convex
A polygon is convex if no straight line in the plane of the polygon intersects the polygon more than twice.

- convex hull
The smallest convex region enclosing a specified group of points. In two dimensions, the convex hull is found conceptually by stretching a rubber band around the points so that all of the points lie within the band.

- coordinate system
In

*n*-dimensional space, a set of*n*linearly independent vectors anchored to a point (called the origin). A group of coordinates specifies a point in space (or a vector from the origin) by indicating how far to travel along each vector to reach the point (or tip of the vector).- culling
The process of eliminating a front face or back face of a polygon so that it isn't drawn.

- current matrix
A matrix that transforms coordinates in one coordinate system to coordinates of another system. There are three current matrices in OpenGL: the modelview matrix transforms object coordinates (coordinates specified by the programmer) to eye coordinates; the perspective matrix transforms eye coordinates to clip coordinates; the texture matrix transforms specified or generated texture coordinates as described by the matrix. Each current matrix is the top element on a stack of matrices. Each of the three stacks can be manipulated with OpenGL matrix-manipulation commands.

- current raster position
A window coordinate position that specifies the placement of an image primitive when it's rasterized. The current raster position and other current raster parameters are updated when

`glRasterPos()`is called.- decal
A method of calculating color values during texture application, where the texture colors replace the fragment colors or, if alpha blending is enabled, the texture colors are blended with the fragment colors, using only the alpha value.

- depth
Generally refers to the

*z*window coordinate.- depth buffer
Memory that stores the depth value at every pixel. To perform hidden-surface removal, the depth buffer records the depth value of the object that lies closest to the observer at every pixel. The depth value of every new fragment uses the recorded value for depth comparison and must pass the comparison test before being rendered.

- depth-cuing
A rendering technique that assigns color based on distance from the viewpoint.

- diffuse
Diffuse lighting and reflection accounts for the directionality of a light source. The intensity of light striking a surface varies with the angle between the orientation of the object and the direction of the light source. A diffuse material scatters that light evenly in all directions.

- directional light source
- display list
A named list of OpenGL commands. Display lists are always stored on the server, so display lists can be used to reduce network traffic in client-server environments. The contents of a display list may be preprocessed and might therefore execute more efficiently than the same set of OpenGL commands executed in immediate mode. Such preprocessing is especially important for computing intensive commands such as NURBS or polygon tessellation.

- dithering
A technique for increasing the perceived range of colors in an image at the cost of spatial resolution. Adjacent pixels are assigned differing color values; when viewed from a distance, these colors seem to blend into a single intermediate color. The technique is similar to the halftoning used in black-and-white publications to achieve shades of gray.

- double-buffering
OpenGL contexts with both front and back color buffers are double-buffered. Smooth animation is accomplished by rendering into only the back buffer (which isn't displayed), then causing the front and back buffers to be swapped. See

`glutSwapBuffers()`in Appendix D.- edge flag
A Boolean value at a vertex which marks whether that vertex precedes a boundary edge.

`glEdgeFlag*()`may be used to mark an edge as not on the boundary. When a polygon is drawn in GL_LINE mode, only boundary edges are drawn.- element
A single component or index.

- emission
The color of an object which is self-illuminating or self-radiating. The intensity of an emissive material is not attributed to any external light source.

- evaluated
The OpenGL process of generating object-coordinate vertices and parameters from previously specified Bézier equations.

- execute
An OpenGL command is executed when it's called in immediate mode or when the display list that it's a part of is called.

- eye coordinates
The coordinate system that follows transformation by the modelview matrix and precedes transformation by the projection matrix. Lighting and application-specific clipping are done in eye coordinates.

- faces
The sides of a polygon. Each polygon has two faces: a front face and a back face. Only one face or the other is ever visible in the window. Whether the back or front face is visible is effectively determined after the polygon is projected onto the window. After this projection, if the polygon's edges are directed clockwise, one of the faces is visible; if directed counterclockwise, the other face is visible. Whether clockwise corresponds to front or back (and counterclockwise corresponds to back or front) is determined by the OpenGL programmer.

- flat shading
Refers to a primitive colored with a single, constant color across its extent, rather than smoothly interpolated colors across the primitive. See Gouraud shading.

- fog
A rendering technique that can be used to simulate atmospheric effects such as haze, fog, and smog by fading object colors to a background color based on distance from the viewer. Fog also aids in the perception of distance from the viewer, giving a depth cue.

- fonts
Groups of graphical character representations generally used to display strings of text. The characters may be roman letters, mathematical symbols, Asian ideograms, Egyptian hieroglyphics, and so on.

- fragment
Fragments are generated by the rasterization of primitives. Each fragment corresponds to a single pixel and includes color, depth, and sometimes texture-coordinate values.

- framebuffer
All the buffers of a given window or context. Sometimes includes all the pixel memory of the graphics hardware accelerator.

- front faces
See faces.

- frustum
The view volume warped by perspective division.

- gamma correction
A function applied to colors stored in the framebuffer to correct for the nonlinear response of the eye (and sometimes of the monitor) to linear changes in color-intensity values.

- geometric model
The object-coordinate vertices and parameters that describe an object. Note that OpenGL doesn't define a syntax for geometric models, but rather a syntax and semantics for the rendering of geometric models.

- geometric object
See geometric model.

- geometric primitive
A point, a line, or a polygon.

- Gouraud shading
Smooth interpolation of colors across a polygon or line segment. Colors are assigned at vertices and linearly interpolated across the primitive to produce a relatively smooth variation in color. Also called smooth shading.

- group
Each pixel of an image in client memory is represented by a group of one, two, three, or four elements. Thus, in the context of a client memory image, a group and a pixel are the same thing.

- half-spaces
A plane divides space into two half-spaces.

- hidden-line removal
A technique to determine which portions of a wireframe object should be visible. The lines that comprise the wireframe are considered to be edges of opaque surfaces, which may obscure other edges that are farther away from the viewer.

- hidden-surface removal
A technique to determine which portions of an opaque, shaded object should be visible and which portions should be obscured. A test of the depth coordinate, using the depth buffer for storage, is a common method of hidden-surface removal.

- homogeneous coordinates
A set of

*n*+1 coordinates used to represent points in*n*-dimensional projective space. Points in projective space can be thought of as points in euclidean space together with some points at infinity. The coordinates are homogeneous because a scaling of each of the coordinates by the same nonzero constant doesn't alter the point to which the coordinates refer. Homogeneous coordinates are useful in the calculations of projective geometry, and thus in computer graphics, where scenes must be projected onto a window.- image
A rectangular array of pixels, either in client memory or in the framebuffer.

- image primitive
A bitmap or an image.

- immediate mode
Execution of OpenGL commands when they're called, rather than from a display list. No immediate-mode bit exists; the mode in immediate mode refers to use of OpenGL, rather than to a specific bit of OpenGL state.

- index
A single value that's interpreted as an absolute value, rather than as a normalized value in a specified range (as is a component). Color indices are the names of colors, which are dereferenced by the display hardware using the color map. Indices are typically masked rather than clamped when out of range. For example, the index 0xf7 is masked to 0x7 when written to a 4-bit buffer (color or stencil). Color indices and stencil indices are always treated as indices, never as components.

- indices
Preferred plural of index. (The choice between the plural forms indices or indexes—as well as matrices or matrixes and vertices or vertexes—has engendered much debate between the authors and principal reviewers of this guide. The authors' compromise solution is to use the -ices form but to state clearly for the record that the use of indice [

*sic*], matrice [*sic*], and vertice [*sic*] for the singular forms is an abomination.)- infinite light source
A directional source of illumination. The radiating light from an infinite light source strikes all objects as parallel rays.

- interpolation
Calculation of values (such as color or depth) for interior pixels, given the values at the boundaries (such as at the vertices of a polygon or a line).

- IRIS GL
Silicon Graphics proprietary graphics library, developed from 1982 through 1992. OpenGL was designed with IRIS GL as a starting point.

- IRIS Inventor
See Open Inventor.

- jaggies
Artifacts of aliased rendering. The edges of primitives that are rendered with aliasing are jagged rather than smooth. A near-horizontal aliased line, for example, is rendered as a set of horizontal lines on adjacent pixel rows rather than as a smooth, continuous line.

- jittering
A pseudo-random displacement (shaking) of the objects in a scene, used in conjunction with the accumulation buffer to achieve special effects.

- lighting
The process of computing the color of a vertex based on current lights, material properties, and lighting-model modes.

- line
A straight region of finite width between two vertices. (Unlike mathematical lines, OpenGL lines have finite width and length.) Each segment of a strip of lines is itself a line.

- local light source
A source of illumination which has an exact position. The radiating light from a local light source emanates from that position. Other names for a local light source are point light source or positional light source. A spotlight is a special kind of local light source.

- logical operation
Boolean mathematical operations between the incoming fragment's RGBA color or color-index values and the RGBA color or color-index values already stored at the corresponding location in the framebuffer. Examples of logical operations include AND, OR, XOR, NAND, and INVERT.

- luminance
The perceived brightness of a surface. Often refers to a weighted average of red, green, and blue color values that gives the perceived brightness of the combination.

- matrices
Preferred plural of matrix. See indices.

- matrix
A two-dimensional array of values. OpenGL matrices are all 4×4, though when stored in client memory they're treated as 1×16 single-dimension arrays.

- modelview matrix
The 4×4 matrix that transforms points, lines, polygons, and raster positions from object coordinates to eye coordinates.

- modulate
A method of calculating color values during texture application, where the texture and the fragment colors are combined.

- monitor
The device that displays the image in the framebuffer.

- motion blurring
A technique that uses the accumulation buffer to simulate what appears on film when you take a picture of a moving object or when you move the camera while taking a picture of a stationary object. In animations without motion blur, moving objects can appear jerky.

- network
A connection between two or more computers that allows each to transfer data to and from the others.

- nonconvex
A polygon is nonconvex if there exists a line in the plane of the polygon that intersects the polygon more than twice.

- normal
A three-component plane equation that defines the angular orientation, but not position, of a plane or surface.

- normalized
To normalize a normal vector, divide each of the components by the square root of the sum of their squares. Then, if the normal is thought of as a vector from the origin to the point (

*nx', ny', nz'*), this vector has unit length.factor = sqrt(nx

^{2}+ ny^{2}+ nz^{2})nx' = nx / factor

ny' = ny / factor

nz' = nz / factor

- normal vectors
See normal.

- NURBS
Non-Uniform Rational B-Spline. A common way to specify parametric curves and surfaces. (See GLU NURBS routines in Chapter 12.)

- object
An object-coordinate model that's rendered as a collection of primitives.

- object coordinates
Coordinate system prior to any OpenGL transformation.

- Open Inventor
An object-oriented 3D toolkit, built on top of OpenGL, based on a 3D scene database and user interaction components. It includes objects such as cubes, polygons, text, materials, cameras, lights, trackballs and handle boxes.

- orthographic
Nonperspective projection, as in some engineering drawings, with no foreshortening.

- parameters
Values passed as arguments to OpenGL commands. Sometimes parameters are passed by reference to an OpenGL command.

- perspective division
The division of

*x*,*y*, and*z*by*w*, carried out in clip coordinates.- pixel
Picture element. The bits at location (

*x, y*) of all the bitplanes in the framebuffer constitute the single pixel (*x, y*). In an image in client memory, a pixel is one group of elements. In OpenGL window coordinates, each pixel corresponds to a 1.0×1.0 screen area. The coordinates of the lower-left corner of the pixel are*x,y*are (*x, y*), and of the upper-right corner are (*x*+1,*y*+1).- point
An exact location in space, which is rendered as a finite-diameter dot.

- point light source
See local light source.

- polygon
A near-planar surface bounded by edges specified by vertices. Each triangle of a triangle mesh is a polygon, as is each quadrilateral of a quadrilateral mesh. The rectangle specified by

`glRect*()`is also a polygon.- positional light source
See local light source.

- primitive
A point, a line, a polygon, a bitmap, or an image. (Note: Not just a point, a line, or a polygon!)

- projection matrix
The 4×4 matrix that transforms points, lines, polygons, and raster positions from eye coordinates to clip coordinates.

- proxy texture
A placeholder for a texture image, which is used to determine if there are enough resources to support a texture image of a given size and internal format resolution.

- quadrilateral
A polygon with four edges.

- rasterized
Converted a projected point, line, or polygon, or the pixels of a bitmap or image, to fragments, each corresponding to a pixel in the framebuffer. Note that all primitives are rasterized, not just points, lines, and polygons.

- rectangle
A quadrilateral whose alternate edges are parallel to each other in object coordinates. Polygons specified with

`glRect*()`are always rectangles; other quadrilaterals might be rectangles.- rendering
Conversion of primitives specified in object coordinates to an image in the framebuffer. Rendering is the primary operation of OpenGL—it's what OpenGL does.

- resident texture
A texture image that is cached in special, high-performance texture memory. If an OpenGL implementation does not have special, high-performance texture memory, then all texture images are deemed resident textures.

- RGBA
Red, Green, Blue, Alpha.

- RGBA mode
An OpenGL context is in RGBA mode if its color buffers store red, green, blue, and alpha color components, rather than color indices.

- server
The computer on which OpenGL commands are executed. This might differ from the computer from which commands are issued. See client.

- shading
The process of interpolating color within the interior of a polygon, or between the vertices of a line, during rasterization.

- shininess
The exponent associated with specular reflection and lighting. Shininess controls the degree with which the specular highlight decays.

- single-buffering
OpenGL contexts that don't have back color buffers are single-buffered. You can use these contexts for animation, but take care to avoid visually disturbing flashes when rendering.

- singular matrix
A matrix that has no inverse. Geometrically, such a matrix represents a transformation that collapses points along at least one line to a single point.

- specular
Specular lighting and reflection incorporates reflection off shiny objects and the position of the viewer. Maximum specular reflectance occurs when the angle between the viewer and the direction of the reflected light is zero. A specular material scatters light with greatest intensity in the direction of the reflection, and its brightness decays, based upon the exponential value shininess.

- spotlight
A special type of local light source that has a direction (where it points to) as well as a position. A spotlight simulates a cone of light, which may have a fall-off in intensity, based upon distance from the center of the cone.

- stencil buffer
Memory (bitplanes) that is used for additional per-fragment testing, along with the depth buffer. The stencil test may be used for masking regions, capping solid geometry, and overlapping translucent polygons.

- stereo
Enhanced three-dimensional perception of a rendered image by computing separate images for each eye. Stereo requires special hardware, such as two synchronized monitors or special glasses to alternate viewed frames for each eye. Some implementations of OpenGL support stereo by having both left and right buffers for color data.

- stipple
A one- or two-dimensional binary pattern that defeats the generation of fragments where its value is zero. Line stipples are one-dimensional and are applied relative to the start of a line. Polygon stipples are two-dimensional and are applied with a fixed orientation to the window.

- tessellation
Reduction of a portion of an analytic surface to a mesh of polygons, or of a portion of an analytic curve to a sequence of lines.

- texel
A texture element. A texel is obtained from texture memory and represents the color of the texture to be applied to a corresponding fragment.

- textures
One- or two-dimensional images that are used to modify the color of fragments produced by rasterization.

- texture mapping
The process of applying an image (the texture) to a primitive. Texture mapping is often used to add realism to a scene. For example, you can apply a picture of a building facade to a polygon representing a wall.

- texture matrix
The 4×4 matrix that transforms texture coordinates from the coordinates in which they're specified to the coordinates that are used for interpolation and texture lookup.

- texture object
A named cache that stores texture data, such as the image array, associated mipmaps, and associated texture parameter values: width, height, border width, internal format, resolution of components, minification and magnification filters, wrapping modes, border color, and texture priority.

- transformations
The warping of spaces. In OpenGL, transformations are limited to projective transformations that include anything that can be represented by a 4×4 matrix. Such transformations include rotations, translations, (nonuniform) scalings along the coordinate axes, perspective transformations, and combinations of these.

- triangle
A polygon with three edges. Triangles are always convex.

- vertex
A point in three-dimensional space.

- vertex array
Where a block of vertex data (vertex coordinates, texture coordinates, surface normals, RGBA colors, color indices, and edge flags) may be stored in an array and then used to specify multiple geometric primitives through the execution of a single OpenGL command.

- vertices
Preferred plural of vertex. See indices.

- viewpoint
The origin of either the eye- or the clip-coordinate system, depending on context. (For example, when discussing lighting, the viewpoint is the origin of the eye-coordinate system. When discussing projection, the viewpoint is the origin of the clip-coordinate system.) With a typical projection matrix, the eye-coordinate and clip-coordinate origins are at the same location.

- view volume
The volume in clip coordinates whose coordinates satisfy the three conditions

-w ≤ x ≤ w

-w ≤ y ≤ w

-w ≤ z ≤ w

Geometric primitives that extend outside this volume are clipped.

- VRML
VRML stands for Virtual Reality Modeling Language, which is (according to the VRML Mission Statement) “a universal description language for multi-participant simulations.” VRML is specifically designed to allow people to navigate through three-dimensional worlds thatare placed on the World Wide Web. The first versions of VRML are subsets of the Open Inventor file format with additions to allow hyperlinking to the Web (to URLs—Universal Resource Locators).

- window
A subregion of the framebuffer, usually rectangular, whose pixels all have the same buffer configuration. An OpenGL context renders to a single window at a time.

- window-aligned
When referring to line segments or polygon edges, implies that these are parallel to the window boundaries. (In OpenGL, the window is rectangular, with horizontal and vertical edges). When referring to a polygon pattern, implies that the pattern is fixed relative to the window origin.

- window coordinates
The coordinate system of a window. It's important to distinguish between the names of pixels, which are discrete, and the window-coordinate system, which is continuous. For example, the pixel at the lower-left corner of a window is pixel (0, 0); the window coordinates of the center of this pixel are (0.5, 0.5,

*z*). Note that window coordinates include a depth, or*z*, component, and that this component is continuous as well.- wireframe
A representation of an object that contains line segments only. Typically, the line segments indicate polygon edges.

- working set
On machines with special hardware that increases texture performance, this is the group of texture objects that are currently resident. The performance of textures within the working set outperforms the textures outside the working set.

- X Window System
A window system used by many of the machines on which OpenGL is implemented. GLX is the name of the OpenGL extension to the X Window System. (See Appendix C.)