OpenGL Rendering Pipeline
The following diagram shows the approach OpenGL takes to processing data.
-
Geometric data (vertices,lines, and polygons) follow a path through evaluators
and per-vertex operations.
-
Pixel data (pixels,images,bitmaps) are treated differently for part of
process.
-
Both types undergo the same final steps (rasterization and per-fragment
operations) before the final pixel data is written into the framebuffer.
Now you'll see more detail about the key stages in the OpenGL rendering
pipeline.
Display Lists
All data, whether it describes geometry or pixels, can be saved in a display
list for current or later use. (The alternative to retaining data in a
display list is processing the data irnmediately-also known as immediate
mode.) W en a display list is executed, the retained data is sent from
the display list just as if it were sent by the application in immediate
mode. (See Chapter 7, 'Display Lists,' for more information about display
lists.)
Evaluators
All geometric primitives are eventually described by vertices. Parametric
curves and surfaces may be initially described by control points and polynomial
functions called basis functions. Evaluators provide a method to derive
the vertices used to represent the surface from the control points. The
method is a polynomial mapping, which can produce surface normal, texture
coordinates, colors, and spatial coordinate values from the control points.
(See Chapter 12, 'Evaluators and NURBS," to learn more about evaluators.)
Per-Vertex Operations
For vertex data, next is the "per-vertex operations" stage, which converts
the vertices into primitives. Some vertex data (for example, spatial coordinates)
are transformed by 4 x 4 floating-point matrices. Spatial coordinates are
projected from a position in the 3D world to a position on your screen.
(See Chapter 3, 'Viewing,' for details about the transformation matrices.)
If advanced features are enabled, this stage is even busier. If
texturing is used, texture coordinates may be generated and transformed
here. If lighting is enabled, the lighting calculations are performed using
the transformed vertex, surface normal, light source position, material
properties, and other lighting information to produce a color value.
Primitive Assembly
Clipping, a major part of primitive assembly, is the elimination of portions
of geometry which fall outside a half-space, defined by a plane. Point
clipping simply passes or rejects vertices; line or polygon clipping can
add additional vertices depending upon how the line or polygon is clipped.
In some cases, this is followed by perspective division, which makes distant
geometric objects appear smaller than closer objects. Then viewport and
depth (z coordinate) operations are applied. If culling is enabled and
the primitive is a polygon, it then may be rejected by a culling test.
Depending upon the polygon mode, a polygon may be drawn as points or lines.
(See 'Polygon Details' on page 55.) The results of this stage are complete
geometric primitives, which are the transformed and clipped vertices with
related color, depth, and sometimes texture-coordinate values and guidelines
for the rasterization step.
Pixel Operations
While geometric data takes one path through the OpenGL rendering pipeline,
pixel data takes a different route. Pixels from an array in system memory
are first unpacked from one of a variety of formats into the proper
number
of components. Next the data is scaled, biased, and processed by a pixel
map. The results are clamped and then either written into texture memory
or sent to the rasterization step. (See "Imaging Pipeline" On page 296.)
If pixel data is read from the frame buffer, pixel-transfer operations
(scale, bias, mapping, and clamping) are performed. TherL these results
are packed into an appropriate format and returned to an array in system
memory. There are special pixel copy operations to copy data in the framebuffer
to other parts of the framebuffer or to the texture memory. A single pass
is made through the pixel transfer operations before the data is written
to the texture memory or back to the framebuffer.
Texture Assembly
An OpenGL application may wish to apply texture images onto geometric objects
to make them look more realistic. If several texture images are used, it's
wise to put them into texture objects so that you can easily switch among
them. Some OpenGL implementations may have special resources to accelerate
texture performance. There may be specialized, high-performance texture
memory. If this memory is available, the texture objects may be prioritized
to control the use of this limited and valuable resource. (See Chapter
9, 'Texture Mapping.')
Rasterization
Rasterization is the conversion of both geometric and pixel data into fragments.
Each fragment square corresponds to a pixel in the framebuffer. Line and
polygon stipples, line width, point size, shading model, and coverage calculations
to support antialiasing are taken into consideration as vertices are connected
into lines or the interior pixels are calculated for a filled polygon. Color and depth values are assigned
for each fragment square.
Fragment Operations
Before values are actually stored into the framebuffer, a series of operations
are performed that may alter or even throw out fragments. All these operations
can be enabled or disabled. The first operation which may be encountered
is texturing, where a texel (texture element) is generated from texture
memory for each fragment and applied to the fragment. Then fog calculations
may be applied, followed by the scissor test, the alpha test, the stencil
test, and the depth-buffer test (the depth buffer is for hidden-surface
removal). Failing an enabled test may end the continued processing of a
fragment's square. Then, blending, dithering, logical operation, and masking
by a bitmask may be performed. (See Chapter 6, "Blending, Antialiasing,
Fog, and Polygon.Offset" and Chapter 10, "The Framebuffer.") Finally, the
thoroughly processed fragment is drawn into the appropriate buffer, where
it has finally advanced to be a pixel and achieved its final resting place.