A one-dimensional (width only) array of values stored in texture memory.

A two-dimensional (width and height) array of values stored in texture memory.

A three-dimensional (width, height, and depth) array of values stored in texture memory.

An OpenGL offscreen memory buffer that can accumulate the results of multiple rendering operations. This buffer often has more bits per pixel than the other offscreen memory buffers in order to support such accumulation operations.

Attribute variables that can be accessed when a vertex shader is executed, including built-in attribute variables and user-defined attribute variables. (It is allowed to have attribute variables that are defined but never used within a vertex shader.)

Samplers that can be accessed when a program is executed.

The texture unit currently defined as the target of commands that modify texture access state such as the current 1D/2D/3D/cube map texture, texture unit enable/disable, texture environment state, and so on.

Uniform variables that can be accessed when a shader is executed, including built-in uniform variables and user-defined uniform variables. (It is allowed to have uniform variables that are defined but never used within a shader.)

Artifacts caused by insufficient sampling or inadequate representation of high-frequency components in a computer graphics image. These artifacts are also commonly referred to as "jaggies."

The fourth component of a color value (after red, green, and blue). Alpha indicates the opacity of a pixel (1.0 means the pixel is fully opaque; 0.0 means the pixel is fully transparent). Alpha is used in color blending operations.

An OpenGL pipeline stage that discards fragments depending on the outcome of a comparison between the current fragment's alpha value and a constant reference alpha value.

A technique for producing more realistic lighting and shadowing effects that uses a precomputed occlusion (or accessibility) factor to scale the diffuse illumination at each point on the surface of an object.

The distance of a function's maximum or minimum from the mean of the function.

Something with properties that differ when measured in different directions, such as the property of a material (anisotropic reflection) or a characteristic of an algorithm (anisotropic texture filtering). Contrast with ISOTROPIC.

The effort to reduce or eliminate artifacts caused by insufficient sampling or inadequate representation of high-frequency components in a computer graphics image.

A source-level interface provided for use by applications.

An antialiasing technique that considers the area of the primitive being sampled. This method usually produces better results than either point sampling or supersampling, but it can be more expensive to compute.

In the lighting computation, the effect of light intensity diminishing as a function of distance from the light source.

Binding more than one user-defined attribute variable to the same generic vertex attribute index. This binding is allowed only if just one of the aliased attributes is active in the executable program or if no path through the shader consumes more than one attribute of a set of attributes aliased to the same location.

An OpenGL Shading Language variable that is qualified with the attribute keyword. Attribute variables contain the values that an application passes through the OpenGL API by using generic, numbered vertex attributes. With attribute variables, a vertex shader can obtain unique data at every vertex. These variables are read-only and can be defined only in vertex shaders. Attribute variables are used to pass frequently changing data to a shader.

A region of offscreen memory that stores arbitrary or generic data, for example, intermediate results from a multipass rendering algorithm. A framebuffer may have more than one associated auxiliary buffer.

A surface attribute that represents the average direction of the available light that is received at that point on the surface. This value is computed as follows: Cast rays from the point on the surface in the hemisphere indicated by the surface normal and then average all rays that are unoccluded by other parts of the model.

A model for computing the reflection from a surface. The elevation and azimuth angles of the incoming and outgoing energy directions are used to compute the relative amount of energy reflected in the outgoing direction. Measurements of real-world materials can be used in this computation to create a more realistic looking surface. BRDFs can more accurately render materials with anisotropic reflection properties.

See BIDIRECTIONAL REFLECTANCE DISTRIBUTION FUNCTION.

Regions of memory on the graphics accelerator devoted to storing a particular type of data. A color buffer stores color values, a depth buffer stores depth values, etc.

A two-dimensional array of normal perturbation values that can be stored in texture memory.

A rendering technique that simulates the appearance of bumps, wrinkles, or other surface irregularities by perturbing surface normals before lighting calculations are performed.

A subroutine calling convention whereby input parameters are copied into the function at call time and output parameters are copied back to the caller before the function exits.

The tendency of a lens to bend light of different colors by unequal amounts because of differences in the indices of refraction of the constituent wavelengths of the light.

The effect of distributing a light source into its constituent wavelengths, for example, by passing it through a prism.

See CLIPPING COORDINATE SYSTEM.

The process of comparing incoming graphics primitives to one or more reference planes and discarding any portion of primitives that are deemed to be outside those reference planes.

The coordinate system in which view-volume clipping occurs. Graphics primitives are transformed from the eye coordinate system into the clipping coordinate system by the projection matrix.

The OpenGL pipeline stage that adds together the primary color and the secondary color. This stage occurs after texturing to allow a specular highlight that is the color of the light source to be applied on top of the textured surface.

The part of the compiler that performs lexical, syntactical, and semantic analysis of source code and produces a binary representation of the code that is suitable for consumption by subsequent phases of compilation.

A programming language feature for initializing aggregate data types or converting between data types.

A texture map whose primary function is to provide values that determine the behavior of a rendering algorithm rather than provide data for the rendering process.

The weighted average of a function over a specified interval.

See CONVOLUTION KERNEL.

The values that are used for weighting in a convolution operation.

A texture map comprising six 2D textures that correspond to faces on a cube. The faces are identified by their axial direction (±x, ±y, ±z), and the proper face is automatically selected when a texture access is performed.

The process of accessing the proper face of a cube map texture to retrieve the value that will be used in texture application. Cube mapping is one method for performing environment mapping.

The act of discarding graphics primitives according to a particular criterion, such as whether the primitives are back facing with respect to the current viewing position.

A shading algorithm that first identifies the visible surfaces in a scene and then applies a shading effect only to those visible surfaces.

A texture access operation that depends on values obtained from a previous texture-access operation.

An OpenGL offscreen memory buffer that maintains depth values. This buffer stores the depth of the topmost visible graphics primitive at each pixel. In conjunction with the depth test operation, this buffer can perform hidden surface elimination.

A graphics rendering technique that alters the appearance of a graphics primitive according to its distance from the viewer. Depth-cuing is often used to fade the color of distant primitives to the background color to make them appear more distant.

See SHADOW MAP.

An OpenGL pipeline stage that compares the depth associated with the incoming fragment with the depth value retrieved from the framebuffer. If the test fails, the fragment is discarded.

The change in the directions and intensities of a group of waves (e.g., light waves) as they pass by an obstacle or pass through an aperture.

A glass or metal surface with large numbers of small, parallel, equally spaced grooves or slits that produces a diffraction effect.

A sequence of OpenGL commands that is stored in OpenGLmanaged memory for later execution.

A mode of rendering in which OpenGL commands are stored in a display list for execution at a later time rather than being executed when they are specified.

Framebuffer memory that is allocated to maintaining the image displayed on the computer monitor or LCD. Display memory is read many times per second (the refresh rate) and updates the visible display surface.

A graphics rendering technique that involves rendering to a back buffer while displaying a front buffer. When rendering is completed, the two buffers are swapped. In this way, the end user never sees partially complete images, and animation can be smoother and more realistic.

A piece of software that interacts with the native operating system and controls a specific piece of hardware in the system.

A rendering technique that involves saving the scene surrounding an object as one or more specialized texture maps and then, when rendering the object, accessing these texture maps to compute accurate reflections of that environment.

A rectangular 2D texture that can be used as an environment map. The texture spans 360° horizontally and 180° vertically. Significant distortion occurs toward the top and bottom of the texture. Also known as a LATITUDE-LONGITUDE (or LAT-LONG) TEXTURE MAP.

The machine code intended for execution on the vertex processor or the fragment processor.

The coordinate system that is defined to have the eye (viewing) position at the origin. Graphics primitives are transformed by the modelview matrix from the modeling (or object) coordinate system into the eye coordinate system.

see EYE COORDINATE SYSTEM.

The process of calculating a single value according to the values of multiple samples in the neighborhood of that value.

The term used to describe portions of the OpenGL pipeline that are not programmable. These portions of OpenGL operate in a fixed fashion, and the behavior can be altered only when a predefined set of state variables is changed through the OpenGL API.

The term used to describe the application of a single color value to the extent of a primitive (contrast with SMOOTH SHADING).

A rendering technique that simulates atmospheric effects due to particulates such as those contained in clouds and smog. Fog is computed by attenuation of the object color as a function of distance from the viewer.

A geometrically complex object, the complexity of which arises through the repetition of a given form over a range of scales. (Ken Musgrave)

The set of data that is generated by rasterization and that represents the information necessary to update a single framebuffer location. A fragment consists of a window coordinate position and associated data such as color, depth, texture coordinates, and the like.

An OpenGL pipeline stage that defines the operations that occur to a fragment produced by rasterization before the back-end processing stages. For OpenGL fixed functionality, fragment processing operations include texture access, texture application, fog, and color sum. For the OpenGL programmable fragment processor, any type of per-fragment processing may be performed.

A programmable unit that replaces the traditional fixed functionality fragment processing stage of OpenGL. Fragment shaders are executed on the fragment processor.

A program written in the OpenGL Shading Language for execution on the fragment processor. The fragment shader's main function is executed once for each fragment generated by rasterization and can be programmed to perform both traditional operations (texture access, texture application, fog) and nontraditional operations.

The region of graphics memory that stores the results of OpenGL rendering operations. Part of the framebuffer (the front buffer) is visible on the display device, and part of it is not.

An OpenGL pipeline stage containing operations that control or affect the whole framebuffer (e.g., buffer masking operations, buffer clear operations).

The measure of periodicity in a function (i.e., how often the pattern of a function repeats).

The result of transparent materials causing light to be both reflected and refracted, with the amount of light reflected and refracted depending on the viewing angle.

See VIEW FRUSTUM.

An OpenGL pipeline stage that clips primitives to the view frustum.

A point, line, or polygon.

A texture map that controls the reflective characteristics of a surface rather than supply image data for the texturing operation.

TEXTURE BOMBING using character glyphs from a texture map.

A non-photorealistic rendering technique that attempts to duplicate the look of a technical illustration. This technique is also called a low dynamic range artistic tone algorithm.

See SMOOTH SHADING.

The measure of how rapidly a function is changing in a particular direction. Properly, this is a vector (see GRADIENT VECTOR). More commonly, the magnitude of the gradient vector for the function f(x,y) in a particular direction is referred to as the gradient of the function f(x,y) in that direction.

See PERLIN NOISE.

A vector that defines the rate of change of a function in all directions. The gradient vector for the function f(x,y) contains two components: the partial derivative of f with respect to x and the partial derivative of f with respect to y.

Hardware dedicated to the process of rendering and displaying graphics.

The OpenGL data structure that contains the state needed to control the operation of the rendering pipeline.

The sequence of operations that occurs when geometry or image data defined by an application is transformed into something that is stored in the framebuffer. This processing is divided into stages that occur in a specific order. Each stage has defined inputs and outputs and can be precisely described.

The process of illuminating scenes and objects by modeling global illumination as two hemispheres, one representing the color of the sky and the other representing the color of the ground (or shadows). Computing the illumination at any surface point is done by integrating the light from the visible hemisphere at that point.

The process of illuminating scenes and objects with images of light captured from the real world.

A collection of imaging-related functionality that was added to OpenGL as an optional subset in OpenGL 1.2. The imaging subset supports color matrix, convolution, histogram, and various blending operations. Graphics hardware vendors are not required to support this functionality as part of their OpenGL implementation.

A mode of rendering in which graphics commands are executed when they are specified rather than stored in a display list for later execution.

The property of a material that defines the ratio of the speed of light in a vacuum to the speed of light in that material.

Something with properties that are the same along a pair of orthogonal axes from which they are measured (i.e., rotationally invariant). Contrast with ANISOTROPIC.

An animation technique that produces "inbetween" results based on interpolation between two key frames. This technique can save time and effort because the objects in the scene do not need to be painstakingly animated for every frame, only for those frames that provide the key to the overall animation sequence.

An expression identifying an object in memory that can be written to. For example, variables that are writable are l-values. Array indexing and structure member selection are expressions that can result in l-values.

The frequency multiplier (or gap) between successive iterations of a summed noise (fractal) function.

see EQUIRECTANGULAR TEXTURE MAP.

The value that selects a mipmap level from a mipmap texture. Incrementing the level-of-detail by 1 results in the selection of a mipmap level that is half the resolution of the previous one. Thus, increasing the value used for level-of-detail results in the selection of mipmap levels that contain smaller and smaller textures (suitable for use on smaller and smaller objects on the screen).

The process of scanning the input text to produce a sequence of tokens (or terminal symbols) for the syntactical analysis phase that follows. Characters or tokens that are not part of the language can be identified as errors during this process. Sometimes this process is referred to as scanning.

A device or a system that captures an omnidirectional, high dynamic range image of light from a real-world scene.

An omnidirectional, high dynamic range image of light captured from the real world.

A method of filtering that eliminates high frequencies but leaves low frequencies unmodified. Low-pass filters are sometimes called SMOOTHING FILTERS because high frequencies are blurred (smoothed).

A specific texel array within a mipmap texture.

An ordered set of texel arrays representing the same image. Typically, each array has a resolution that is half the previous one in each dimension.

See MODELING COORDINATE SYSTEM.

The matrix that transforms coordinates from the modeling coordinate system into the world coordinate system. In OpenGL, this matrix is not available separately; it is always part of the modelview matrix.

The process of defining a numerical representation of an object that is to be rendered, for instance, defining the Bezier curves that specify a teapot, or the vertex positions, colors, surface normals, and texture coordinates that define a bowling pin.

A coordinate system that is defined in a way that makes it convenient to specify and orient a single object. Also known as the OBJECT COORDINATE SYSTEM or OBJECT SPACE.

The transformation that takes coordinates from the modeling coordinate system into the world coordinate system.

The matrix that transforms coordinates from the modeling coordinate system into the eye coordinate system.

The matrix that transforms coordinates from the modeling coordinate system into the clipping coordinate system.

A function whose fractal dimension varies according to location.

A region of offscreen memory that can perform supersampling by maintaining more than one sample per pixel and automatically averaging the samples to produce the final, antialiased image.

An image processing technique that low-pass filters (smooths) an image by computing the weighted average of pixels in close proximity to one another.

A continuous, irregular function with a defined range that creates complex and interesting patterns.

A class of rendering techniques whose purpose is to achieve something other than the most realistic result possible. Such techniques may strive to achieve a painterly or hand-drawn appearance, the look of a technical illustration, or a cartoonlike appearance. Hatching and Gooch shading are examples of NPR techniques.

A texture map that contains normals rather than image data.

The coordinate space that contains the view volume in an axis-aligned cube with a minimum corner at (1,1,1) and a maximum corner at (1,1,1).

See NON-PHOTOREALISTIC RENDERING.

See MODELING COORDINATE SYSTEM.

See MODELING COORDINATE SYSTEM.

Two frequencies that are related by a ratio of 2:1.

Framebuffer memory that stores things, such as depth buffers and textures, that are never directly visible on the display screen (contrast with DISPLAY MEMORY).

A term applied to a shader written in the OpenGL Shading Language to differentiate from a shader written in another shading language.

The high-level programming language defined to allow application writers to write programs that execute on the programmable processors defined within OpenGL.

The set of function calls added to OpenGL to allow OpenGL shaders to be created, deleted, queried, compiled, linked, and used.

See SYNTACTIC ANALYSIS.

A rendering primitive that consists of a large number of points or short lines that are suitable for rendering a class of objects with ill-defined boundaries (e.g., fire, sparks, liquid sprays).

An OpenGL pipeline stage that occurs after fragment processing and before framebuffer operations. It includes a variety of tests, such as the stencil, alpha, and depth tests, aimed at determining whether the fragment should be used to update the framebuffer.

A noise function that is defined to have a value of 0 for integer input values and whose variability is introduced by defining pseudorandom gradient values at each of those points. Also called GRADIENT NOISE.

The effort to use computer graphics to model, render, and animate a scene in such a way that it is indistinguishable from a photograph or film sequence of the same scene in real life.

A value that will ultimately be used to update the framebuffer (i.e., a color, depth, or stencil value).

An OpenGL pipeline stage that decides whether a fragment can be used to update the framebuffer or whether the targeted framebuffer location belongs to another window or to another OpenGL graphics context.

An OpenGL pipeline stage that writes pixels retrieved from OpenGL into application-controlled memory.

A rectangular array of pixels (i.e., an image).

An OpenGL pipeline stage that processes pixel data while it is being transferred within OpenGL. At this stage, operations can occur for the following: scaling and biasing, lookup table, convolution, histogram, color matrix, and the like.

An OpenGL pipeline stage that reads pixels (i.e., image data) from application-controlled memory and sends them on for further processing by OpenGL.

The process of determining the value at each pixel by sampling the function at just one point. This is the typical behavior of graphics hardware and many graphics algorithms, and it can lead to aliasing artifacts. Contrast with SUPERSAMPLING and AREA SAMPLING.

A screen-aligned quadrilateral that has texture coordinates and that is drawn by rasterizing a single point primitive. Normally, points are drawn as a single pixel or as a round circle. A point sprite can be used to draw an image stored in a texture map at each point position.

A light-dependent texture map that can reconstruct the color of a surface under varying lighting conditions.

An OpenGL pipeline stage that occurs after vertex processing and that assembles individual vertex values into a primitive. The primary function of this stage is to buffer vertex values until enough accumulate to define the desired primitive. Points require one vertex, lines require two, triangles require three, and so on.

In OpenGL parlance, things that can be rendered: points, lines, polygons, bitmaps, and images.

A shader that produces its results primarily by synthesizing rather than by relying heavily on precomputed values.

The process of computing a texture primarily by synthesizing rather than by relying heavily on precomputed values.

The set of executables that result from successful linking of a program object. This program can be installed as part of OpenGL's current state to provide programmable vertex and fragment processing.

An OpenGL-managed data structure that serves as a container object for one or more shader objects. Program objects are used when shaders are linked. Linking a program object results in one or more executables that are part of the program object and that can be installed as part of current state.

The matrix that transforms coordinates from the eye coordinate system to the clipping coordinate system.

The transformation that takes coordinates from the eye coordinate system into the clipping coordinate system.

See POLYNOMIAL TEXTURE MAP.

A periodic function that varies abruptly between two values (i.e., a square wave).

An expression identifying a declared or temporary object in memory that can be readfor example, a variable name is an r-value, but function names are not. Expressions result in r-values.

A piece of OpenGL state that positions bitmap and image write operations.

The process of converting graphics primitives such as points, lines, polygons, bitmaps, and images into fragments.

An OpenGL pipeline stage that contains state to define the region of framebuffer memory that is read during pixel read operations.

The process of converting geometry or image data defined by an application into something that is stored in the framebuffer.

See GRAPHICS PROCESSING PIPELINE.

An opaque data type in the OpenGL Shading Language that stores the information needed to access a particular texture from within a shader.

See LEXICAL ANALYSIS.

Either a hierarchical data structure containing a description of a scene to be rendered or a rendering engine for traversing and rendering such data structures.

An OpenGL pipeline stage that, when enabled, allows drawing operations to occur only within a specific rectangular region that has been defined in window coordinates.

The process of determining whether the input text conforms to the semantic rules defined or implied by a programming language. Semantic errors in the input text can be identified during this phase of compilation.

Source code written in the OpenGL Shading Language that is intended for execution on one of OpenGL's programmable processors.

An OpenGL-managed data structure that stores the source code and the compiled code for a shader written in the OpenGL Shading Language. Shader objects can be compiled, and compiled shader objects can be linked to produce executable code (see PROGRAM OBJECT).

A texture created by rendering a scene from the point of view of a light source. This texture is then used during a final rendering pass to determine the parts of the scene that are in shadow. Also known as a DEPTH MAP.

An algorithm that computes shadows by rendering the scene once for each shadow-causing light source in the scene and once for the final rendering of the scene, including shadows. The perlight rendering passes are rendered from the light source's point of view and create shadow maps. These textures are then accessed on the final pass to determine the parts of the scene that are in shadow.

The term used to describe the application of linearly interpolated color values across the extent of a primitive (contrast with FLAT SHADING). Also called GOURAUD SHADING.

See LOW-PASS FILTERING.

A method for performing environment mapping that simulates the projection of the environment onto a sphere surrounding the object to be rendered. The mapped environment is treated as a 2D texture map and accessed with the polar coordinates of the reflection vector.

An offscreen region of framebuffer memory that can be used with the stencil test to mask regions. A complex shape can be stored in the stencil buffer, and subsequent drawing operations can use the contents of the stencil buffer to determine whether to update each pixel.

An OpenGL pipeline stage that conditionally eliminates a pixel according to the results of a comparison between the value stored in the stencil buffer and a reference value. Applications can specify the action taken when the stencil test fails, the action taken when the stencil test passes and the depth test fails, and the action to be taken when both the stencil test and the depth test pass.

A rendering technique that involves taking two or more point samples per pixel and then filtering these values to determine the value to be used for the pixel. Supersampling does not eliminate aliasing but can reduce it to the point at which it is no longer objectionable.

A coordinate system that assumes that each point on a surface is at (0,0,0) and that the unperturbed surface normal at each point is (0,0,1).

To duplicate or switch around the order of the components of a vector (e.g, to create a value that contains alpha, green, blue, red from one that contains red, green, blue, alpha).

The process of determining whether the structure of an input text is valid according to the grammar that defines the language. Syntax errors in the input text can be identified during this phase of compilation. Sometimes referred to as parsing.

A particular surface-local coordinate system that is defined with a tangent vector as one of the basis vectors.

See TRANSFORMATION AND LIGHTING.

Aliasing artifacts that are caused by insufficient sampling in the time domain or inadequate representation of objects that are in motion.

A single pixel in a texture map.

The process of reading from a texture map in texture memory, including the filtering that occurs, the level-of-detail calculation for mipmap textures, and so on.

The process of using the value read from texture memory to compute the color of a fragment. OpenGL's fixed functionality has fixed formulas for this process, but with programmability, this operation has become much more general.

The process of applying irregularly spaced decorative elements (stars, polka dots, character glyphs, etc.) to an object's surface. Decorative elements can be computed procedurally or obtained from a texture map. They can also be randomly scaled and rotated to add further interest.

The combination of texture access and texture application. Traditionally, this mapping involves reading image data from a texture map stored in texture memory and using it as the color for the primitive being rendered. With programmability, this operation has become much more general.

A region of memory on the graphics accelerator that is used for storing textures.

The OpenGL-managed data structure that contains information that describes a texture map, including the texels that define the texture, the wrapping behavior, the filtering method, and so on.

An OpenGL abstraction for the graphics hardware that performs texture access and texture application. Since version 1.2, OpenGL has allowed the possibility of more than one texture unit, thus allowing access to more than one texture at a time.

The process of converting vertex positions from object coordinates into window coordinates, and for converting vertex colors into colors that are displayable on the screen, taking into account the effects of simulated light sources.

A variation of Perlin noise that sums noise functions of different frequencies. These frequencies include an absolute value function to introduce discontinuities to the function in order to give the appearance of turbulent flow.

An OpenGL Shading Language variable that is qualified with the uniform keyword. The values for these variables are provided by the application or through OpenGL state. They are read-only from within a shader and may be accessed from either vertex shaders or fragment shaders. They pass data that changes relatively infrequently.

A method of sharpening an image by subtracting a blurred version of the image from itself.

An OpenGL operation that compares graphics primitives to user-specified clipping planes in eye space and discards everything that is deemed to be outside the intersection of those clipping planes.

A noise function that is defined as follows: Assign pseudorandom values in a defined range (e.g., [0,1] or [1,1]) to each integer input value and then smoothly interpolate between those values.

An OpenGL Shading Language variable that is qualified with the varying keyword. These variables are defined at each vertex and interpolated across a graphics primitive to produce a perspective-correct value at each fragment. They must be declared in both the vertex shader and the fragment shader with the same type. They are the output values from vertex shaders and the input values for fragment shaders.

A point in three-dimensional space.

Values that are associated with a vertex. OpenGL defines both standard and generic vertex attributes. Standard attributes include vertex position, color, normal, and texture coordinates. Generic vertex attributes can be defined to be arbitrary data values that are passed to OpenGL for each vertex.

An OpenGL pipeline stage that defines the operations that occur to each vertex from the time the vertex is provided to OpenGL until the primitive assembly stage. For OpenGL fixed functionality, this processing includes transformation, lighting, texture coordinate generation, and other operations. For the OpenGL programmable vertex processor, any type of per-vertex processing may be performed.

A programmable unit that replaces the traditional fixed functionality vertex processing stage of OpenGL. Vertex shaders are executed on the vertex processor.

A program written in the OpenGL Shading Language that executes on the vertex processor. The vertex shader's main function is executed once for each vertex provided to OpenGL and can be programmed to perform both traditional operations (transformation, lighting) and nontraditional operations.

The view volume after it has been warped by the perspective division calculation.

The volume in the clipping coordinate system whose coordinates x, y, z, and w all satisfy the conditions that w x w, w y w, and w z w. Any portion of a geometric primitive that extends beyond this volume will be clipped.

The matrix that transforms coordinates from the world coordinate system into the eye coordinate system. In OpenGL, this matrix is not available separately; it is always part of the modelview matrix.

The transformation that takes coordinates from the world coordinate system into the eye coordinate system.

The transformation that takes coordinates from the normalized device coordinate system into the window coordinate system.

The coordinate system used to identify pixels within a window on the display device. In this coordinate system, x values range from 0 to the width of the window minus 1, and y values range from 0 to the height of the window minus 1. OpenGL defines the pixel with window coordinates (0,0) to be the pixel at the lower-left corner of the window.

A coordinate system that is defined in a way that is convenient for the placement and orientation of all of the objects in a scene.

See WORLD COORDINATE SYSTEM.