The OpenGL Graphics System: A Specification

2.15. VERTEX SHADERS 71
2.14.9 Final Color Processing
For an RGBA color, each color component (which lies in [0, 1]) is converted
(by rounding to nearest) to a fixed-point value with m bits. We assume that
the fixed-point representation used represents each value k/(2 m − 1), where
k ∈ {0, 1, . . . , 2 m − 1}, as k (e.g. 1.0 is represented in binary as a string of
all ones). m must be at least as large as the number of bits in the corresponding
component of the framebuffer. m must be at least 2 for A if the framebuffer does
not contain an A component, or if there is only 1 bit of A in the framebuffer. A
color index is converted (by rounding to nearest) to a fixed-point value with at least
as many bits as there are in the color index portion of the framebuffer.
Because a number of the form k/(2 m − 1) may not be represented exactly as
a limited-precision floating-point quantity, we place a further requirement on the
fixed-point conversion of RGBA components. Suppose that lighting is disabled, the
color associated with a vertex has not been clipped, and one of Colorub, Colorus,
or Colorui was used to specify that color. When these conditions are satisfied, an
RGBA component must convert to a value that matches the component as specified
in the Color command: if m is less than the number of bits b with which the
component was specified, then the converted value must equal the most significant
m bits of the specified value; otherwise, the most significant b bits of the converted
value must equal the specified value.
2.15 Vertex Shaders
The sequence of operations described in sections 2.11 through 2.14 is a fixedfunction
method for processing vertex data. Applications can more generally describe
the operations that occur on vertex values and their associated data by using
a vertex shader.
A vertex shader is an array of strings containing source code for the operations
that are meant to occur on each vertex that is processed. The language used for
vertex shaders is described in the OpenGL Shading Language Specification.
To use a vertex shader, shader source code is first loaded into a shader object
and then compiled. One or more vertex shader objects are then attached to a program
object. A program object is then linked, which generates executable code
from all the compiled shader objects attached to to the program. When a linked
program object is used as the current program object, the executable code for the
vertex shaders it contains is used to process vertices.
In addition to vertex shaders, fragment shaders can be created, compiled, and
linked into program objects. Fragment shaders affect the processing of fragments
Version 2.0 - October 22, 2004