values for each color in the multisample buffer are combined to produce a single color value, and that value is written into the corresponding color buffers selected by DrawBuffer or DrawBuffers. An implementation may defer the writing of the color buffers until a later time, but the state of the framebuffer must behave as if the color buffers were updated as each fragment was processed. The method of combination is not specified, though a simple average computed independently for each color component is recommended.

4.2Whole Framebuffer Operations

The preceding sections described the operations that occur as individual fragments are sent to the framebuffer. This section describes operations that control or affect the whole framebuffer.

4.2.1 Selecting a Buffer for Writing

The first such operation is controlling the color buffers into which each of the fragment colors are written. This is accomplished with either DrawBuffer or DrawBuffers.

The command

void DrawBuffer( enum buf );

defines the set of color buffers to which fragment color zero is written. buf is a symbolic constant specifying zero, one, two, or four buffers for writing. The constants are NONE, FRONT LEFT, FRONT RIGHT, BACK LEFT, BACK RIGHT, FRONT, BACK, LEFT, RIGHT, FRONT AND BACK, and AUX0 through AUXm, where m + 1 is the number of available auxiliary buffers.

The constants refer to the four potentially visible buffers front left, front right, back left, and back right, and to the auxiliary buffers. Arguments other than AUXi that omit reference to LEFT or RIGHT refer to both left and right buffers. Arguments other than AUXi that omit reference to FRONT or BACK refer to both front and back buffers. AUXi enables drawing only to auxiliary buffer i. Each AUXi adheres to AUXi = AUX0 + i. The constants and the buffers they indicate are summarized in table 4.4. If DrawBuffer is is supplied with a constant (other than NONE) that does not indicate any of the color buffers allocated to the GL context, the error

INVALID OPERATION results.

DrawBuffer will set the draw buffer for fragment colors other than zero to

NONE.

The command

Version 2.0 - October 22, 2004

Table 4.4: Arguments to DrawBuffer and the buffers that they indicate.

void DrawBuffers( sizei n, const enum *bufs );

defines the draw buffers to which all fragment colors are written. n specifies the number of buffers in bufs. bufs is a pointer to an array of symbolic constants specifying the buffer to which each fragment color is written. The constants may be

NONE, FRONT LEFT, FRONT RIGHT, BACK LEFT, BACK RIGHT, and AUX0 through

AUXm, where m+ 1 is the number of available auxiliary buffers. The draw buffers being defined correspond in order to the respective fragment colors. The draw buffer for fragment colors beyond n is set to NONE.

Except for NONE, a buffer may not appear more then once in the array pointed to by bufs. Specifying a buffer more then once will result in the error

INVALID OPERATION.

If fixed-function fragment shading is being performed, DrawBuffers specifies a set of draw buffers into which the fragment color is written.

If a fragment shader writes to gl FragColor, DrawBuffers specifies a set of draw buffers into which the single fragment color defined by gl FragColor is written. If a fragment shader writes to gl FragData, DrawBuffers specifies a set of draw buffers into which each of the multiple fragment colors defined by gl FragData are separately written. If a fragment shader writes to neither gl FragColor nor gl FragData, the values of the fragment colors following shader execution are undefined, and may differ for each fragment color.

The maximum number of draw buffers is implementation dependent and must be at least 1. The number of draw buffers supported can be queried by calling

Version 2.0 - October 22, 2004

valid in the bufs array passed to DrawBuffers, and will result in the error INVALID OPERATION. This restriction is because these constants may themselves refer to multiple buffers, as shown in table 4.4.

If DrawBuffers is supplied with a constant (other than NONE) that does not indicate any of the color buffers allocated to the GL context, the error INVALID OPERATION will be generated. If n is greater than the value of

MAX DRAW BUFFERS, the error INVALID VALUE will be generated.

Indicating a buffer or buffers using DrawBuffer or DrawBuffers causes subsequent pixel color value writes to affect the indicated buffers.

Specifying NONE as the draw buffer for an fragment color will inhibit that fragment color from being written to any buffer.

Monoscopic contexts include only left buffers, while stereoscopic contexts include both left and right buffers. Likewise, single buffered contexts include only front buffers, while double buffered contexts include both front and back buffers. The type of context is selected at GL initialization.

The state required to handle color buffer selection is an integer for each supported fragment color. In the initial state, the draw buffer for fragment color zero is FRONT if there are no back buffers; otherwise it is BACK. The initial state of draw buffers for fragment colors other then zero is NONE.

4.2.2 Fine Control of Buffer Updates

Four commands are used to mask the writing of bits to each of the logical framebuffers after all per-fragment operations have been performed. The commands

void IndexMask( uint mask );

void ColorMask( boolean r, boolean g, boolean b, boolean a );

control the color buffer or buffers (depending on which buffers are currently indicated for writing). The least significant n bits of mask, where n is the number of bits in a color index buffer, specify a mask. Where a 1 appears in this mask, the corresponding bit in the color index buffer (or buffers) is written; where a 0 appears, the bit is not written. This mask applies only in color index mode. In RGBA mode, ColorMask is used to mask the writing of R, G, B and A values to the color buffer or buffers. r, g, b, and a indicate whether R, G, B, or A values, respectively, are written or not (a value of TRUE means that the corresponding value is written). In the initial state, all bits (in color index mode) and all color values (in RGBA mode) are enabled for writing.

Version 2.0 - October 22, 2004

The depth buffer can be enabled or disabled for writing zw values using

void DepthMask( boolean mask );

If mask is non-zero, the depth buffer is enabled for writing; otherwise, it is disabled. In the initial state, the depth buffer is enabled for writing.

The commands

void StencilMask( uint mask );

void StencilMaskSeparate( enum face, uint mask );

control the writing of particular bits into the stencil planes.

The least significant s bits of mask comprise an integer mask (s is the number of bits in the stencil buffer), just as for IndexMask. The face parameter of StencilMaskSeparate can be FRONT, BACK, or FRONT AND BACK and indicates whether the front or back stencil mask state is affected. StencilMask sets both front and back stencil mask state to identical values.

Fragments generated by front facing primitives use the front mask and fragments generated by back facing primitives use the back mask (see section 4.1.5). The clear operation always uses the front stencil write mask when clearing the stencil buffer.

The state required for the various masking operations is three integers and a bit: an integer for color indices, an integer for the front and back stencil values, and a bit for depth values. A set of four bits is also required indicating which color components of an RGBA value should be written. In the initial state, the integer masks are all ones, as are the bits controlling depth value and RGBA component writing.

Fine Control of Multisample Buffer Updates

When the value of SAMPLE BUFFERS is one, ColorMask, DepthMask, and StencilMask or StencilMaskSeparate control the modification of values in the multisample buffer. The color mask has no effect on modifications to the color buffers. If the color mask is entirely disabled, the color sample values must still be combined (as described above) and the result used to replace the color values of the buffers enabled by DrawBuffer.

4.2.3 Clearing the Buffers

The GL provides a means for setting portions of every pixel in a particular buffer to the same value. The argument to

Version 2.0 - October 22, 2004

STENCIL BUFFER BIT, and ACCUM BUFFER BIT, indicating the buffers currently enabled for color writing, the depth buffer, the stencil buffer, and the accumulation buffer (see below), respectively. The value to which each buffer is cleared depends on the setting of the clear value for that buffer. If the mask is not a bitwise OR of the specified values, then the error INVALID VALUE is generated.

void ClearColor( clampf r, clampf g, clampf b, clampf a );

sets the clear value for the color buffers in RGBA mode. Each of the specified components is clamped to [0, 1] and converted to fixed-point according to the rules of section 2.14.9.

void ClearIndex( float index );

sets the clear color index. index is converted to a fixed-point value with unspecified precision to the left of the binary point; the integer part of this value is then masked with 2m − 1, where m is the number of bits in a color index value stored in the framebuffer.

void ClearDepth( clampd d );

takes a floating-point value that is clamped to the range [0, 1] and converted to fixed-point according to the rules for a window z value given in section 2.11.1. Similarly,

void ClearStencil( int s );

takes a single integer argument that is the value to which to clear the stencil buffer. s is masked to the number of bitplanes in the stencil buffer.

void ClearAccum( float r, float g, float b, float a );

takes four floating-point arguments that are the values, in order, to which to set the R, G, B, and A values of the accumulation buffer (see the next section). These values are clamped to the range [−1, 1] when they are specified.

When Clear is called, the only per-fragment operations that are applied (if enabled) are the pixel ownership test, the scissor test, and dithering. The masking

Version 2.0 - October 22, 2004