blob: 6dcd843749b225f7cdfde4f74ac20d42917a2a1a [file] [log] [blame]
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html lang="en">
<head>
<meta http-equiv="content-type" content="text/html; charset=utf-8">
<title>Mini GLX Specification</title>
</head>
<body>
<span style="font-style: italic;"></span><span
style="font-weight: bold;"></span>
<h1 style="text-align: center;">Mesa Subset Specification</h1>
<h2 style="text-align: center;">Tungsten Graphics, Inc.</h2>
<h2 style="text-align: center;">February 26, 2003</h2>
<p> Copyright &copy; 2002-2003 by Tungsten Graphics, Inc.,
Cedar Park, Texas. All Rights Reserved. <br>
<br>
Permission is granted to make and distribute verbatim copies of this
document provided the copyright notice and this permission notice are
preserved on all copies.<br>
</p>
<p> OpenGL is a trademark of <a href="http://www.sgi.com">Silicon
Graphics, Inc.</a>.</p>
<h1>1. Introduction</h1>
This document describes a subset of the Mesa implemented by Tungsten
Graphics, Inc. for embedded devices. &nbsp;Prior to reading this
document the reader should be familiar with the OpenGL 1.2.1
specification dated April 1, 1999 (available from <a
href="http://www.opengl.org/developers/documentation/specs.html">http://www.opengl.org/developers/documentation/specs.html</a>.)
&nbsp;Experience with OpenGL programming is highly advisable.<a
href="http://www.opengl.org/developers/documentation/specs.html"><br>
</a><br>
Tungsten Graphics, Inc. is working with industry standards
organizations +in an attempt to standardize this Mesa subset and any
other possible subsets +as a result of this work. <br>
<br>
Appendix A contains a list of issues of which some may not be resolved.<br>
<br>
To summarize, the following major features of Mesa are omitted from the
subset:<br>
<ul>
<li>Vertex arrays</li>
<li>Texture coordinate generation</li>
<li>Lighting</li>
<li>Point size</li>
<li>Polygon stipple</li>
<li>DrawPixels, CopyPixels, PixelZoom</li>
<li>1-D and 3-D textures</li>
<li>CopyTex[Sub]Image</li>
<li>Fog</li>
<li>Depth test</li>
<li>Color Index mode</li>
<li>Accumulation buffer</li>
<li>Feedback mode</li>
<li>Evaluators</li>
<li>Push/Pop attributes</li>
<li>Display lists<br>
</li>
</ul>
<p>Further reductions are made at a lower level of detail.<br>
</p>
<p>Mesa function names are printed in <span style="font-weight: bold;">bold
face</span>. &nbsp;Function parameters are printed in <span
style="font-style: italic;">italics</span>.<br>
</p>
<p>The Tungsten Graphics, Inc. Mesa subset library is hereafter
referred to as <span style="font-style: italic;">the subset.</span><br>
<br>
</p>
<h1>2. Primitive Specification</h1>
<h2>2.1 glBegin, glEnd and glVertex Commands</h2>
The basic rendering primitives are points, lines and triangles.
&nbsp;Quadrilaterals and polygons are composed of triangles.
&nbsp;Primitives are drawn with the <span style="font-weight: bold;">glBegin</span>
and <span style="font-weight: bold;">glEnd</span> commands and a subset
of the <span style="font-weight: bold;">glVertex</span> commands:<br>
<br>
<div style="margin-left: 40px;">void <span style="font-weight: bold;">glBegin</span>(GLenum<span
style="font-style: italic;">mode</span>)<br>
void <span style="font-weight: bold;">glEnd</span>(void)<br>
<br>
void <span style="font-weight: bold;">glVertex2f</span>(GLfloat <span
style="font-style: italic;">x</span>, GLfloat <span
style="font-style: italic;">y</span>)<br>
void <span style="font-weight: bold;">glVertex2fv</span>(const GLfloat
*<span style="font-style: italic;">v</span>)<br>
void <span style="font-weight: bold;">glVertex3f</span>(GLfloat <span
style="font-style: italic;">x</span>, GLfloat <span
style="font-style: italic;">y</span>, GLfloat <span
style="font-style: italic;">z</span>)<br>
void <span style="font-weight: bold;">glVertex3fv</span>(const GLfloat
*<span style="font-style: italic;">v</span>)<br>
</div>
<br>
The <span style="font-style: italic;">mode</span> parameter to <span
style="font-weight: bold;">glBegin</span> may be one of the following<br>
<br>
<div style="margin-left: 40px;">GL_POINTS - a series of individual
points<br>
GL_LINES - a series of disjoint line segments<br>
GL_LINE_STRIP - series of connected line segments<br>
GL_LINE_LOOP - a closed loop of line segments<br>
GL_TRIANGLES - a series of individual triangles<br>
GL_TRIANGLE_STRIP - a connected strip of triangles<br>
GL_TRIANGLE_FAN - a sequence of triangles all sharing a common vertex<br>
GL_QUADS - a sequence of individual quadrilaterals<br>
GL_QUAD_STRIP - a connected strip of quadrilaterals<br>
GL_POLYGON - a closed, convex polygon<br>
<br>
</div>
<br>
The <span style="font-weight: bold;">glVertex</span> commands take two
or three floating point coordinates, or a pointer to an array of two or
three floating point coordinates. &nbsp;Vertices are actually 4-element
homogeneous coordinates. &nbsp;The fourth component, unspecified by the
subset's <span style="font-weight: bold;">glVertex</span> commands, is
one.<br>
<br>
<span style="font-weight: bold;"></span>
<h2>2.2 Other Per-vertex Commands<br>
</h2>
The <span style="font-weight: bold;">glColor</span> and <span
style="font-weight: bold;">glTexCoord</span> commands may be used to
specify colors and texture coordinates for each vertex:<br>
<br>
<div style="margin-left: 40px;">void <span style="font-weight: bold;">glColor3f</span>(GLfloat<span
style="font-style: italic;">red</span>, GLfloat <span
style="font-style: italic;">green</span>, GLfloat <span
style="font-style: italic;">blue</span>)<br>
void <span style="font-weight: bold;">glColor3fv</span>(const GLfloat *<span
style="font-style: italic;">rgb</span>)<br>
void <span style="font-weight: bold;">glColor4f</span>(GLfloat <span
style="font-style: italic;">red,</span> GLfloat <span
style="font-style: italic;">green,</span> GLfloat <span
style="font-style: italic;">blue,</span> GLfloat <span
style="font-style: italic;">alpha</span>)<br>
void <span style="font-weight: bold;">glColor4fv</span>(const GLfloat *<span
style="font-style: italic;">rgba</span>)<br>
void <span style="font-weight: bold;">glTexCoord2f</span>(GLfloat <span
style="font-style: italic;">s</span>, GLfloat<span
style="font-style: italic;"> t</span>)<br>
void <span style="font-weight: bold;">glTexCoord2fv</span>(const
GLfloat *<span style="font-style: italic;">c</span>)<br>
<br>
</div>
The <span style="font-weight: bold;">glColor</span> commands specify
the color and optionally, the alpha value, for subsequent vertices.
&nbsp;For the <span style="font-weight: bold;">glColor3</span> commands,
alpha is set to one.<br>
<br>
The <span style="font-weight: bold;">glTexCoord2</span> commands
specify the texture coordinate for subsequent vertices. &nbsp;Texture
coordinates are actually four-component coordinates: (s, t, r, q).
&nbsp;The <span style="font-weight: bold;">glTexCoord2</span> commands
set s and t explicitly. &nbsp;The r and q components are zero and one,
respectively.<br>
<br>
<span style="font-weight: bold;"></span>Only <span
style="font-weight: bold;">glVertex, glColor</span> and <span
style="font-weight: bold;">glTexCoord</span> commands are allowed
between <span style="font-weight: bold;">glBegin</span> and <span
style="font-weight: bold;">glEnd.</span> &nbsp;Calling any other
command between <span style="font-weight: bold;">glBegin</span> and <span
style="font-weight: bold;">glEnd</span> will result in the error
GL_INVALID_OPERATION.<br>
<br>
<h2>2.3 Unsupported Commands</h2>
None of the following commands related to primitive specification are
supported by the subset:<br>
<br>
<div style="margin-left: 40px;">Per-Vertex commands:<br>
</div>
<div style="margin-left: 40px;">
<div style="margin-left: 40px;"><span style="font-weight: bold;">glVertex2d,
glVertex2i, glVertex2s, glVertex3d, glVertex3i, glVertex3s, glVertex4d,
glVertex4i, glVertex4s, glVertex2dv, glVertex2iv, glVertex2sv,
glVertex3dv, glVertex3iv, glVertex3sv, glVertex4dv, glVertex4iv,
glVertex4sv,<br>
glNormal3b, glNormal3d, glNormal3f, glNormal3i, glNormal3s, </span><span
style="font-weight: bold;">glNormal3bv, glNormal3dv, glNormal3fv,
glNormal3iv, glNormal3sv,<br>
glIndexd, glIndexf, glIndexi, glIndexs, glIndexub, glIndexdv,
glIndexfv, glIndexiv, glIndexsv, glIndexubv,<br>
glColor3b, glColor3d, glColor3i, glColor3s, glColor3ub, glColor3ui,
glColor3us, </span><span style="font-weight: bold;">glColor3bv,
glColor3dv, glColor3iv, glColor3sv, glColor3ubv, glColor3uiv,
glColor3usv,</span><span style="font-weight: bold;"> lColor4b,
glColor4d, glColor4i, glColor4s, glColor4ub, glColor4ui, glColor4us, </span><span
style="font-weight: bold;">glColor4bv, glColor4dv, glColor4iv,
glColor4sv, glColor4ubv, glColor4uiv, glColor4usv,<br>
</span><span style="font-weight: bold;">glTexCoord1d, glTexCoord1f,
glTexCoord1i, glTexCoord1s, glTexCoord2d, glTexCoord2i, glTexCoord2s,
glTexCoord3d, glTexCoord3f, glTexCoord3i, glTexCoord3s, glTexCoord4d,
glTexCoord4f, glTexCoord4i, glTexCoord4s, glTexCoord1dv, glTexCoord1fv,
glTexCoord1iv, glTexCoord1sv, glTexCoord2dv, glTexCoord2iv,
glTexCoord2sv, glTexCoord3dv, glTexCoord3fv, glTexCoord3iv,
glTexCoord3sv, glTexCoord4dv, glTexCoord4fv, glTexCoord4iv,
glTexCoord4sv,<br>
glEdgeFlag, glEdgeFlagv</span><br style="font-weight: bold;">
<br>
</div>
Vertex array commands:<br>
<div style="margin-left: 40px;"><span style="font-weight: bold;">glVertexPointer,
glColorPointer, glIndexPointer, glTexCoordPointer, glEdgeFlagPointer,
glNormalPointer, glInterleavedArrays, glArrayElement, glDrawArrays,
glDrawElements, glDrawRangeElements, glEnableClientState,
glDisableClientState</span><br>
</div>
</div>
<div style="margin-left: 40px;"><br>
Rectangle commands:<br>
<div style="margin-left: 40px;"><span style="font-weight: bold;">glRects,
glRecti, glRectf, glRectd, glRectsv, glRectiv, glRectfv, glRectdv,<br>
<br>
</span></div>
</div>
<div style="margin-left: 40px;">Lighting commands:<br>
</div>
<div style="margin-left: 80px;"><span style="font-weight: bold;">glMaterialf,
glMateriali, glMaterialfv, glMaterialiv<br>
</span><br>
</div>
<div style="margin-left: 40px;"> Evaluator commands:<br>
<div style="margin-left: 40px;"><span style="font-weight: bold;">glEvalCoord1d,
glEvalCoord1f, glEvalCoord1dv, glEvalCoord1fv,&nbsp;</span><span
style="font-weight: bold;">glEvalCoord2d, glEvalCoord2f,
glEvalCoord2dv, glEvalCoord2fv,<br>
</span><span style="font-weight: bold;">glEvalPoint1, glEvalPoint2</span><br>
<br>
</div>
</div>
<h1>3. Coordinate Transformation</h1>
<h2>3.1 Vertex Transformation</h2>
Vertex coordinates are transformed by the current modelview and
projection matrices then mapped to window coordinates as specified by
the viewport. &nbsp;The following coordinate transformation commands are
supported by the subset<br>
<br>
<div style="margin-left: 40px; font-weight: bold;">glMatrixMode<span
style="font-weight: normal;">(GLenum <span style="font-style: italic;">mode</span>)</span><br>
glLoadIdentity<span style="font-weight: normal;">(void)</span><br>
glPushMatrix<span style="font-weight: normal;">(void)</span><br>
glPopMatrix<span style="font-weight: normal;">(void)</span><br>
glLoadMatrixf<span style="font-weight: normal;">(const GLfloat *<span
style="font-style: italic;">m</span>)</span><br>
glMultMatrixf<span style="font-weight: normal;">(const GLfloat *<span
style="font-style: italic;">m</span>)</span><br>
glRotatef<span style="font-weight: normal;">(GLfloat <span
style="font-style: italic;">angle</span>, GLfloat <span
style="font-style: italic;">x</span>, GLfloat <span
style="font-style: italic;">y</span>, GLfloat <span
style="font-style: italic;">z</span>)</span><br>
glTranslatef<span style="font-weight: normal;">(GLfloat <span
style="font-style: italic;">x</span>, GLfloat <span
style="font-style: italic;">y</span>, GLfloat <span
style="font-style: italic;">z</span>)</span><br>
glScalef<span style="font-weight: normal;">(GLfloat <span
style="font-style: italic;">x</span>, GLfloat <span
style="font-style: italic;">y</span>, GLfloat <span
style="font-style: italic;">z</span>)<br>
<span style="font-weight: bold;">glFrustum(</span>GLdouble <span
style="font-style: italic;">left,</span> GLdouble <span
style="font-style: italic;">right,</span> GLdouble <span
style="font-style: italic;">bottom,</span> GLdouble <span
style="font-style: italic;">top,</span> GLdouble <span
style="font-style: italic;">near,</span> GLdouble <span
style="font-style: italic;">far</span>)</span><br>
<span style="font-weight: normal;"><span style="font-weight: bold;">glOrtho(</span>GLdouble<span
style="font-style: italic;"> left,</span> GLdouble <span
style="font-style: italic;">right,</span> GLdouble <span
style="font-style: italic;">bottom,</span> GLdouble <span
style="font-style: italic;">top,</span> GLdouble <span
style="font-style: italic;">near,</span> GLdouble <span
style="font-style: italic;">far</span>)</span><br>
glViewport<span style="font-weight: normal;">(GLint <span
style="font-style: italic;">x</span>, GLint <span
style="font-style: italic;">y</span>, GLsize <span
style="font-style: italic;">width,</span> GLsizei <span
style="font-style: italic;">height</span>)</span><br>
</div>
<br>
The <span style="font-weight: bold;">glMatrixMode</span> command
specifies the <span style="font-style: italic;">current matrix.</span>
&nbsp;The mode parameter may be GL_MODELVIEW or GL_PROJECTION to specify
the modelview matrix or projection matrix. &nbsp;Subsequent matrix
commands will effect the current matrix. &nbsp;Also associated with the
modelview and projection matrices are a modelview matrix stack and
projection matrix stack.<br>
<br>
The <span style="font-weight: bold;">glLoadIdentity</span> command
replaces the current matrix with the identity matrix. &nbsp;The matrix
elements are specified in column-major order.<br>
<br>
The <span style="font-weight: bold;">glPushMatrix</span> command pushes
a copy of the current matrix onto either the modelview matrix stack or
the projection matrix stack. &nbsp;The <span style="font-weight: bold;">glPopMatrix</span>
command replaces the current matrix with a copy of the top matrix off
the modelview matrix stack or projection matrix stack, the pops the
stack. &nbsp;Matrix stacks are useful for traversing and rendering
hierarchical models.<br>
<br>
The <span style="font-weight: bold;">glMultMatrixf</span> command
post-multiplies the current matrix by the specified matrix. &nbsp;The
matrix elements are specified in column-major order.<br>
<br>
The <span style="font-weight: bold;">glRotatef</span> command
post-multiplies the current matrix by a rotation matrix defined by the
angle and rotation axis defined by x, y and z.<br>
<br>
The <span style="font-weight: bold;">glTranslatef</span> command
post-multiplies the current matrix by a translation matrix defined by
the <span style="font-style: italic;">x</span>, <span
style="font-style: italic;">y</span> and <span
style="font-style: italic;">z</span> translation parameters.<br>
<span style="font-weight: bold;"></span><br>
The <span style="font-weight: bold;">glScalef</span> command
post-multiplies the current matrix by a scaling matrix defined by the <span
style="font-style: italic;">x</span>, <span
style="font-style: italic;">y</span> and <span
style="font-style: italic;">z</span> scale factors.<br>
<span style="font-weight: bold;"></span><br>
The <span style="font-weight: bold;">glFrustum</span> command
post-multiplies the current matrix by a perspective projection matrix.
&nbsp;The <span style="font-style: italic;">near</span> and <span
style="font-style: italic;">far</span> values specify the position of
the hither and yon Z-axis clipping planes. &nbsp;The <span
style="font-style: italic;">left, right, bottom</span> and <span
style="font-style: italic;">top</span> parameters are the X and Y
extents at the near clipping plane. &nbsp;<span
style="font-weight: bold;">glFrustum</span> is normally used to modify
the projection matrix.<br>
<br>
The <span style="font-weight: bold;">glOrtho</span> command
post-multiplies the current matrix by an orthographic projection matrix.
&nbsp;The <span style="font-style: italic;">near</span> and <span
style="font-style: italic;">far</span> values specify the position of
the hither and yon Z-axis clipping planes. &nbsp;The <span
style="font-style: italic;">left, right, bottom</span> and <span
style="font-style: italic;">top</span> parameters specify the X and
Y-axis clipping planes. &nbsp;<span style="font-weight: bold;">glOrtho</span>
is normally used to modify the projection matrix.<br>
<br>
The <span style="font-weight: bold;">glViewport</span> command
specifies the mapping of coordinates from normalized device coordinates
to window coordinates. &nbsp;The <span style="font-style: italic;">x</span>
and <span style="font-style: italic;">y</span> parameters specify the
viewport's lower-left corner in the window and the <span
style="font-style: italic;">width</span> and <span
style="font-style: italic;">height</span> parameters specify the size
of the viewport. &nbsp;<span style="font-weight: bold;">glViewport</span>
does not effect the current matrix.<br>
<br>
A coordinate transformed to window coordinates is hereafter known as (x<sub>w</sub>,
y<sub>w</sub>, z<sub>w</sub>).<br>
<br>
<h2>3.2 Clipping</h2>
View-volume clipping automatically discards or trims primitives which
lie completely or partially outside of the view volume specified by <span
style="font-weight: bold;">glFrustum</span> and <span
style="font-weight: bold;">glOrtho</span>. &nbsp;Note that the <span
style="font-weight: bold;">glViewport</span> command does not define a
clipping region.<br>
<br>
Clipping occurs in <span style="font-style: italic;">clip coordinate
space - </span>the coordinates produced after applying the projection
matrix.<br>
<br>
<h2>3.3 Current Raster Position</h2>
The current raster position specifies the location for drawing images
with <span style="font-weight: bold;">glBitmap.</span> &nbsp;The current
raster position is set with the commands:<br>
<br>
<div style="margin-left: 40px;">void <span style="font-weight: bold;">glRasterPos2f</span>(GLfloat<span
style="font-style: italic;">x</span>, GLfloat <span
style="font-style: italic;">y</span>)<br>
void <span style="font-weight: bold;">glRasterPos2fv</span>(const
GLfloat *<span style="font-style: italic;">v</span>)<br>
void <span style="font-weight: bold;">glRasterPos2i</span>(GLint <span
style="font-style: italic;">x</span>, GLint <span
style="font-style: italic;">y</span>)<br>
void <span style="font-weight: bold;">glRasterPos2iv</span>(const
GLint *<span style="font-style: italic;">v</span>)<br>
</div>
<br>
<span style="font-weight: bold;">glRasterPos</span> specifies a
4-component coordinate (x, y, 0, 1). &nbsp;The coordinate is processed
like a vertex; it is transformed by the modelview matrix, the projection
matrix and mapped to the viewport. &nbsp;The resulting window coordinate
is stored as the current raster position. &nbsp;The coordinate is
clipped-tested against the frustum like a vertex. &nbsp;If the
coordinate is clipped, then the current raster position becomes invalid
and subsequent <span style="font-weight: bold;">glBitmap</span> commands
have no effect.<br>
<br>
<span style="font-weight: bold;">glRasterPos</span> also updates the
current raster color and current raster texture coordinates. &nbsp;The
current raster color is updated (copied) from the current color (as
specified by <span style="font-weight: bold;">glColor</span>).
&nbsp;The current raster texture coordinate is updated (copied) from the
current texture coordinate (as specified by <span
style="font-weight: bold;">glTexCoord</span>).<br>
<br>
<h2>3.4 Unsupported Commands</h2>
The following commands related to vertex transformation are not
supported by the subset:<br>
<br>
<div style="margin-left: 40px;">User-defined clip plane commands:<br>
<div style="margin-left: 40px;"><span style="font-weight: bold;">glClipPlane</span><br>
</div>
<span style="font-weight: bold;"></span></div>
<br>
<div style="margin-left: 40px;">Lighting and material commands:</div>
<div style="margin-left: 80px;"><span style="font-weight: bold;">glLightModeli,
glLightModelf,&nbsp;</span><span style="font-weight: bold;">glLightModeliv,
glLightModelfv,</span><span style="font-weight: bold;"> glLightf,
glLighti, glLightfv, glLightiv, glColorMaterial</span><br>
</div>
<br>
<div style="margin-left: 40px;">Automatic texture coordinate generation
commands:<br>
</div>
<div style="margin-left: 40px;">
<div style="margin-left: 40px;"><span style="font-weight: bold;">glTexGend,
glTexGenf, glTexGeni, </span><span style="font-weight: bold;">glTexGendv,
glTexGenfv, glTexGeniv, </span><br>
<br style="font-weight: bold;">
</div>
Double-valued commands:<br>
<div style="margin-left: 40px;"><span style="font-weight: bold;">glLoadMatrixd,
glMultMatrixd, glRotated, glTranslated, glScaled</span><br
style="font-weight: bold;">
</div>
<br>
Depth Range command:<br>
<div style="margin-left: 40px;"><span style="font-weight: bold;">glDepthRange</span>
(the near value is always 0.0 and the far value is always 1.0)<br>
</div>
<br>
Extra RasterPos commands:<br>
<div style="margin-left: 40px;"><span style="font-weight: bold;">glRasterPos2d,
glRasterPos2s, glRasterPos3d, glRasterPos3f, glRasterPos3i,
glRasterPos3s, glRasterPos4d, glRasterPos4f, glRasterPos4i,
glRasterPos4s, glRasterPos2dv, glRasterPos2sv, glRasterPos3dv,
glRasterPos3fv, glRasterPos3iv, glRasterPos3sv, glRasterPos4dv,
glRasterPos4fv, glRasterPos4iv, glRasterPos4sv</span><br>
</div>
<br>
<br>
</div>
<h1>4. Rasterization</h1>
This section describes the commands and options for drawing points,
lines, triangles and bitmaps. &nbsp;<span style="font-style: italic;">Rasterization</span>
is the term for the process which produces fragments from the geometric
description of a primitive (a point, line, polygon or bitmap). &nbsp;For
example, given the two coordinates for the end-points of a line segment,
rasterization determines which pixels in the frame buffer are modified
to <span style="font-style: italic;">draw</span> the line. &nbsp;A
fragment is a tuple which consists of a window coordinate, colors and
texture coordinates. &nbsp;The fragments produced by rasterization are
subsequently processed by the per-fragment operations described later.<br>
<br>
<h2>4.1 Point Rasterization</h2>
Points are rendered with the command sequence <span
style="font-weight: bold;">glBegin</span>(GL_POINTS), <span
style="font-weight: bold;">glVertex</span>, ... <span
style="font-weight: bold;">glEnd</span>. &nbsp;The window coordinate (x<sub>w</sub>,
y<sub>w</sub>, z<sub>w</sub>) is truncated to rasterize the point.
&nbsp;The truncated coordinate with its associated color and texture
coordinate is sent as a single fragment to the per-fragment processing
stages.<br>
<br>
The <span style="font-weight: bold;">glPointSize</span> command is not
supported; only 1-pixel points are supported.<br>
<br>
Point smoothing (antialiasing) is also not supported.<br>
<br>
<h2>4.2 Line Rasterization</h2>
Lines are rendered with the command sequence <span
style="font-weight: bold;">glBegin</span>(<span
style="font-style: italic;">mode</span>), <span
style="font-weight: bold;">glVertex</span>, <span
style="font-weight: bold;">glVertex</span>, ... <span
style="font-weight: bold;">glEnd</span> where <span
style="font-style: italic;">mode</span> is one of GL_LINES,
GL_LINE_STRIP or GL_LINE_LOOP. &nbsp;Lines are rasterized as described
in the OpenGL specification. &nbsp;Note that OpenGL specifies the <span
style="font-style: italic;">half-open</span> convention for drawing
lines: the last fragment in a line segment is omitted so that endpoint
pixels shared by two line segments will only be drawn once instead of
twice.<br>
<br>
<h3>4.2.1 Line Width</h3>
The width of lines can be controlled by<br>
<br>
<div style="margin-left: 40px;">void <span style="font-weight: bold;">glLineWidth</span>(GLfloat<span
style="font-style: italic;">width</span>)<br>
</div>
<br>
where <span style="font-style: italic;">width</span> is the line width
in pixels. &nbsp;The width defaults to 1.0. &nbsp;Attempting to set the
width to a value less than or equal to zero will raise the error
GL_INVALID_VALUE.<br>
<br>
<h3>4.2.2 Line Stipple<br>
</h3>
Lines may be stippled (i.e. dashed) with the command<br>
<br>
<div style="margin-left: 40px;"><span style="font-weight: bold;">glLineStipple</span>(GLint<span
style="font-style: italic;">factor</span>, GLushort <span
style="font-style: italic;">pattern</span>)<br>
</div>
<br>
<span style="font-style: italic;">pattern</span> describes an on/off
pattern for the fragments produced by rasterization and <span
style="font-style: italic;">factor</span> specifies how many subsequent
fragments are kept or culled for each pattern bit. &nbsp;Line stippling
can be enabled or disabled by the commands <span
style="font-weight: bold;">glEnable</span>(GL_LINE_STIPPLE) and <span
style="font-weight: bold;">glDisable</span>(GL_LINE_STIPPLE).<br>
<br>
<h3>4.2.3 Line Antialiasing</h3>
Lines may be antialiased. &nbsp;For antialiased lines, each fragment
produced by rasterization is assigned a <span
style="font-style: italic;">coverage value</span> which describes how
much of the fragment's area is considered to be <span
style="font-style: italic;">inside</span> the line. &nbsp;Later, the
alpha value of each fragment is multiplied by the coverage value.
&nbsp;By blending the fragments into the frame buffer, the edges of
lines appear smoothed.<br>
<br>
Line antialiasing can be enabled or disabled with the commands <span
style="font-weight: bold;">glEnable</span>(GL_LINE_SMOOTH) and <span
style="font-weight: bold;">glDisable</span>(GL_LINE_SMOOTH).<br>
<br>
<h2>4.3 Polygon Rasterization</h2>
Polygons, quadrilaterals and triangles share the same polygon
rasterization options. <br>
<br>
Triangles are rendered by the command sequence <span
style="font-weight: bold;">glBegin</span><span
style="font-style: italic;"><span style="font-style: italic;">(mode</span></span>),<span
style="font-weight: bold;">glVertex</span>, <span
style="font-weight: bold;">glVertex</span>, ... <span
style="font-weight: bold;">glEnd</span> where <span
style="font-style: italic;">mode</span> may be one of GL_TRIANGLES,
GL_TRIANGLE_STRIP or GL_TRIANGLE_FAN.<span style="font-weight: bold;"></span>
&nbsp;For GL_TRIANGLES mode, the number of vertices should be a multiple
of three - extra vertices will be ignored. &nbsp;For GL_TRIANGLE_STRIP
and GL_TRIANGLE_FAN, at least three vertices should be specified.
&nbsp;If less than three are specified, nothing is drawn. &nbsp;<br>
<br>
Quadrilaterals are <span style="font-weight: bold;"></span>rendered by
the command sequence <span style="font-weight: bold;">glBegin</span>(<span
style="font-style: italic;"><span style="font-style: italic;">mode</span></span>),<span
style="font-weight: bold;">glVertex</span>, <span
style="font-weight: bold;">glVertex</span>, ... <span
style="font-weight: bold;">glEnd</span> where <span
style="font-style: italic;">mode</span> may be one of GL_QUADS or
GL_QUAD_STRIP.<span style="font-weight: bold;"></span> &nbsp; For
GL_QUADS, the number of vertices should be a multiple of four - extra
vertices will be ignored. &nbsp;For GL_QUAD_STRIP, the number of
vertices should be even and at least four. &nbsp;Extra vertices (one)
will be ignored.<br>
<br>
Convex polygons are <span style="font-weight: bold;"></span>rendered
by the command sequence <span style="font-weight: bold;">glBegin</span><span
style="font-style: italic;"><span style="font-style: italic;"></span></span>(GL_POLYGON),<span
style="font-weight: bold;">glVertex</span>, <span
style="font-weight: bold;">glVertex</span>, ... <span
style="font-weight: bold;">glEnd</span>.<span
style="font-style: italic;"></span><span style="font-weight: bold;"></span>
&nbsp;If less than three vertices are specified, nothing is drawn.<br>
<br>
<h3>4.3.1 Polygon Orientation</h3>
The <span style="font-style: italic;">winding order</span> of vertices
(clockwise or counter-clockwise) is significant. &nbsp;It is used to
determine the <span style="font-style: italic;">front-facing</span> or <span
style="font-style: italic;">back-facing</span> orientation of polygons.
&nbsp;By default, a front-facing polygon's vertices are in
counter-clockwise order (in window coordinates). &nbsp;Figures 2.4 and
2.5 of the OpenGL 1.2.1 specification illustrate the winding order for
front-facing triangles and quadrilaterals, respectively.<br>
<br>
The command<br>
<br>
<div style="margin-left: 40px;">void <span style="font-weight: bold;">glFrontFace</span>(GLenum<span
style="font-style: italic;"> mode</span>)<br>
</div>
<br>
specifies whether clockwise or counter-clockwise winding indicates a
front-facing polygon. &nbsp;If <span style="font-style: italic;">mode</span>
is GL_CW then polygons with clockwise winding are front-facing. &nbsp;If <span
style="font-style: italic;">mode</span> is GL_CCW then polygons with
counter-clockwise winding are front-facing. &nbsp;The default value is
GL_CCW. &nbsp;If <span style="font-style: italic;">mode</span> is not
GL_CCW or GL_CW then the error GL_INVALID_ENUM will be raised.<span
style="font-style: italic;"></span><span style="font-style: italic;"></span><br>
<br>
<h3>4.3.2 Polygon Culling</h3>
Polygons may be culled (discarded) depending on whether they are
front-facing or back-facing. &nbsp;The command<br>
<br>
<div style="margin-left: 40px;">void<span style="font-weight: bold;">
glCullFace</span>(GLenum <span style="font-style: italic;">mode</span>)<br>
</div>
<br>
specifies whether front-facing, back-facing or all polygons should be
culled. &nbsp;If <span style="font-style: italic;">mode</span> is
GL_FRONT then front-facing polygons will be culled. &nbsp;If <span
style="font-style: italic;">mode</span> is GL_BACK then back-facing
polygons will be culled. Otherwise, if <span style="font-style: italic;">mode</span>
is GL_FRONT_AND_BACK then all polygons will be culled. &nbsp;Any other
value for <span style="font-style: italic;">mode</span> will raise the
error GL_INVALID_ENUM.<br>
<br>
Polygon culling is enabled and disabled with the commands <span
style="font-weight: bold;">glEnable</span>(GL_CULL_FACE) and <span
style="font-weight: bold;">glDisable</span>(GL_CULL_FACE),
respectively.<br>
<br>
<h3>4.3.3 Polygon Antialiasing</h3>
Polygons may be antialiased in order to smooth their edges.
&nbsp;Polygon antialiasing is enabled and disabled with the commands <span
style="font-weight: bold;">glEnable</span>(GL_POLYGON_SMOOTH) and <span
style="font-weight: bold;">glDisable</span>(GL_POLYGON_SMOOTH).<br>
<br>
When polygon antialiasing is enabled each fragment produced by polygon,
triangle and quadrilateral rasterization will be given a <span
style="font-style: italic;">coverage</span> value which indicates how
much of the fragment is covered by the polygon. &nbsp;Fragments
completely inside the polygon have coverage 1.0. &nbsp;Fragments
completely outside the polygon have zero coverage (in theory).
&nbsp;Fragments which intersect the polygon's edge have a coverage value
in the range (0, 1).<br>
<br>
The fragment's alpha value is multiplied by the coverage value.
&nbsp;By enabling the appropriate blending mode, polygon edges will
appear smoothed.<br>
<br>
<h2>4.4 Shading</h2>
The command<br>
<br>
<div style="margin-left: 40px;"> void <span style="font-weight: bold;">glShadeModel</span>(GLenum<span
style="font-style: italic;">mode</span>)<br>
</div>
<br>
determines whether colors are interpolated between vertices during
rasterization. &nbsp;If <span style="font-style: italic;">mode</span> is
GL_FLAT then vertex colors are not interpolated. &nbsp;The color used
for drawing lines, triangles and quadrilaterals is that of the last
vertex used to specify each primitive. &nbsp;For polygons, the color of
the first vertex specifies the color for the entire polygon. &nbsp;If <span
style="font-style: italic;">mode</span> is GL_SMOOTH then vertex colors
are linearly interpolated to produce the fragment colors.<br>
<br>
<h2>4.5 Bitmap Rasterization</h2>
A bitmap is a monochromatic, binary image in which each image element
(or pixel) is represented by one bit. &nbsp;Fragments are only generated
for the bits (pixels) which are set. &nbsp;Bitmaps are commonly used to
draw text (glyphs) and markers.<br>
<br>
A bitmap is drawn with the command<br>
<br>
<div style="margin-left: 40px;">void <span style="font-weight: bold;">glBitmap</span>(GLsizei<span
style="font-style: italic;">width</span>, GLsizei <span
style="font-style: italic;">height</span>, GLfloat <span
style="font-style: italic;">xOrig</span>, GLfloat <span
style="font-style: italic;">yOrig</span>, GLfloat <span
style="font-style: italic;">xMove</span>, GLfloat <span
style="font-style: italic;">yMove</span>, const &nbsp;GLubyte *<span
style="font-style: italic;">image</span>)<br>
</div>
<br>
<span style="font-style: italic;">width </span>and <span
style="font-style: italic;">height</span> specify the image size in
pixels. &nbsp;<span style="font-style: italic;">xOrig</span> and <span
style="font-style: italic;">yOrig</span> specify the bitmap origin.
&nbsp;<span style="font-style: italic;">xMove</span> and <span
style="font-style: italic;">yMove</span> are added to the current
raster position after the bitmap is rasterized. &nbsp;<span
style="font-style: italic;">image</span> is a pointer to the bitmap
data.<br>
<br>
If the current raster position is not valid, <span
style="font-weight: bold;">glBitmap</span> has no effect.<br>
<br>
<h3>4.5.1 Bitmap Unpacking</h3>
The first step in bitmap rendering is <span style="font-style: italic;">unpacking.
&nbsp;</span>Unpacking is the process of extracting image data from
client memory subject to byte swapping, non-default row strides, etc.
&nbsp;The unpacking parameters are specified with the command<br>
<br>
<div style="margin-left: 40px;">void<span style="font-weight: bold;">
glPixelStorei</span>(GLenum pname, GLint value)<br>
</div>
<span style="font-style: italic;"></span><br>
The following unpacking parameters may be set:<br>
<br>
<table cellpadding="2" cellspacing="2" border="1"
style="text-align: left; width: 90%; margin-left: auto; margin-right: auto;">
<tbody>
<tr>
<td style="vertical-align: top;">Parameter (<span
style="font-style: italic;">pname</span>)<br>
</td>
<td style="vertical-align: top;">Value (<span
style="font-style: italic;">value</span>)<br>
</td>
<td style="vertical-align: top;">Default<br>
</td>
</tr>
<tr>
<td style="vertical-align: top;">GL_UNPACK_ROW_LENGTH<br>
</td>
<td style="vertical-align: top;">Width of the image in memory, in
pixels.<br>
</td>
<td style="vertical-align: top;">0<br>
</td>
</tr>
<tr>
<td style="vertical-align: top;">GL_UNPACK_LSB_FIRST<br>
</td>
<td style="vertical-align: top;">GL_FALSE indicates that the most
significant bit is unpacked first from each byte. &nbsp;GL_TRUE
indicates that the least significant bit is unpacked first from each
byte. <br>
</td>
<td style="vertical-align: top;">GL_FALSE<br>
</td>
</tr>
</tbody>
</table>
<br>
<br>
The GL_UNPACK_ROW_LENGTH specifies the stride (in pixels) for advancing
from one row of the image to the next.&nbsp; If it's zero, the <span
style="font-style: italic;">width</span> parameter to <span
style="font-weight: bold;">glBitmap</span> specifies the width of the
image in memory.<br>
<br>
GL_UNPACK_LSB_FIRST determines whether the least significant or most
significant bit in each byte is unpacked first. &nbsp;Unpacking occurs
in left to right order (in image space).<br>
<br>
The value of bit (i, j) of the image (where i is the image row and j is
the image column) is found as follows:<br>
<br>
<div style="margin-left: 40px;">rowLength = (GL_UNPACK_ROW_LENGTH != 0)
? GL_UNPACK_ROW_LENGTH : <span style="font-style: italic;">width</span>;<br>
<br>
byte = <span style="font-style: italic;">image</span>[((rowLength + 7)
/ 8) * i + j / 8];<br>
<br>
if (GL_UNPACK_LSB_FIRST != 0)<br>
&nbsp;&nbsp;&nbsp; bitMask = 1 &lt;&lt; (j % 8);<br>
else<br>
&nbsp;&nbsp;&nbsp; bitMask = 128 &gt;&gt; (j % 8);<br>
<br>
if (byte &amp; bitMask)<br>
&nbsp;&nbsp;&nbsp; bit = 1;<br>
else<br>
&nbsp;&nbsp;&nbsp; bit = 0;<br>
<br>
</div>
<span style="font-style: italic;"><span style="font-style: italic;"></span></span>
<h3>4.5.2 Rasterization</h3>
If the current raster position is (x<sub>rp</sub>, y<sub>rp</sub>, z<sub>rp</sub>,
w<sub>rp</sub>), then the bitmap is rasterized according to the
following algorithm:<br>
<br>
for (j = 0; j &lt; <span style="font-style: italic;">height</span>;
j++) {<br>
&nbsp;&nbsp;&nbsp; for (i = 0; i &lt; <span style="font-style: italic;">width</span>;
i++) {<br>
&nbsp;&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; if (bit(i,j)) {<br>
&nbsp;&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; fragment.x =
floor(x<sub>rp</sub> - <span style="font-style: italic;">xOrig</span>)
+ i;<br>
&nbsp;&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; fragment.y =
floor(y<sub>rp</sub> - <span style="font-style: italic;">yOrig</span>)
+ j;<br>
&nbsp;&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; fragment.color
= GL_CURRENT_RASTER_COLOR;<br>
&nbsp;&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; &nbsp;&nbsp;&nbsp;
fragment.texture = GL_CURRENT_RASTER_TEXTURE_COORDS;<br>
&nbsp;&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; &nbsp;&nbsp;&nbsp;
ProcessFragment(fragment)<br>
&nbsp;&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; &nbsp;}<br>
&nbsp;&nbsp;&nbsp; }<br>
}<br>
<br>
After the bitmap has been rendered the current raster position is
updated as follows:<br>
<br>
<div style="margin-left: 40px;">x<sub>rp</sub> = x<sub>rp</sub> + <span
style="font-style: italic;">xMove</span><br>
y<sub>rp</sub> = y<sub>rp</sub> + <span style="font-style: italic;">yMove</span><br>
</div>
<br>
<h3>4.5.3 Per-fragment Operations</h3>
XXX supported? &nbsp;See issue in appendix A.<br>
<br>
<h2>4.6 Unsupported Commands</h2>
The following commands related to rasterization are not supported by
the subset.<br>
<br>
<div style="margin-left: 40px;">Point commands:<br>
<div style="margin-left: 40px;"><span style="font-weight: bold;">glPointSize</span><br>
</div>
<br>
Polygon commands:<br>
<div style="margin-left: 40px; font-weight: bold;">glPolygonStipple<br>
glPolygonOffset<br>
glPolygonMode<br>
<br>
</div>
</div>
<div style="margin-left: 40px;">Pixel storage commands:<br>
</div>
<div style="font-weight: bold; margin-left: 80px;">glPixelStoref<br>
</div>
<br>
<br>
<h1>5. Texture Mapping<br>
</h1>
There are four elements to texture mapping: texture coordinate
specification, texture image specification, texture sampling and texture
application.<br>
<br>
Texture mapping is enabled and disabled with the commands <span
style="font-weight: bold;">glEnable</span>(GL_TEXTURE_2D) and <span
style="font-weight: bold;">glDisable</span>(GL_TEXTURE_2D).<br>
<br>
<h2>5.1 Texture Image Specification</h2>
A texture image is specified with the command:<br>
<br>
<div style="margin-left: 40px;">void <span style="font-weight: bold;">glTexImage2D</span>(GLenum<span
style="font-style: italic;"> target</span>, GLint <span
style="font-style: italic;">level</span>, GLint <span
style="font-style: italic;">internalFormat,</span> GLsizei <span
style="font-style: italic;">width,</span> GLsizei <span
style="font-style: italic;">height,</span> GLint <span
style="font-style: italic;">border,</span> GLenum <span
style="font-style: italic;">format,</span> GLenum <span
style="font-style: italic;">type,</span> const GLvoid *<span
style="font-style: italic;">pixels</span> )<br>
</div>
<br>
<span style="font-style: italic;">target</span> must be GL_TEXTURE_2D.
&nbsp;<span style="font-style: italic;">level </span>indicates the
mipmap level for mipmap textures. &nbsp;<span style="font-style: italic;">internalFormat</span>
is a hint to indicate the preferred internal storage format for the
texture. &nbsp;<span style="font-style: italic;">width</span> and <span
style="font-style: italic;">height </span>indicate the image size in
pixels (or texels). &nbsp;<span style="font-style: italic;">border </span>must
be zero. &nbsp;<span style="font-style: italic;">format</span> and <span
style="font-style: italic;">type</span> describe the pixel format and
data type for the incoming image. &nbsp;<span style="font-style: italic;">pixels</span>
points to the incoming texture image. &nbsp;These parameters are
described in more detail below.<br>
<br>
<h3>5.1.1 Texture Image Size and Mipmaps</h3>
<h3><span style="font-style: italic;"></span></h3>
Texture images must have dimensions (width and height) that are powers
of two. For example: 256 x 256, 32 x 1024, 1 x 8, etc. &nbsp;That is, it
must be the case that <span style="font-style: italic;">width </span>=
2<sup>n</sup> and <span style="font-style: italic;">height</span> = 2<sup>m</sup>
for some positive integers n and m.<br>
<br>
Mipmapping is a method of antialiasing or filtering textures to improve
their appearance. &nbsp;A mipmap is a set of images consisting of a base
image and a set of filtered, reduced-resolution images. &nbsp;If the
base image (<span style="font-style: italic;">level</span>=0) is of
width 2<sup>n</sup> and height 2<sup>m</sup> then the level 1 image must
be of width 2<sup>n-1</sup> and height 2<sup>m-1</sup>. &nbsp;Each mipmap
level is half the width and height of the previous level, or at least
one. &nbsp;The last mipmap level has a width and height of one.<br>
<br>
The following is an example of a mipmap's image levels:<br>
<br>
<table cellpadding="2" cellspacing="2" border="1"
style="text-align: left; width: 50%; margin-left: auto; margin-right: auto;">
<tbody>
<tr>
<td style="vertical-align: top;">mipmap level<br>
</td>
<td style="vertical-align: top;">width<br>
</td>
<td style="vertical-align: top;">height<br>
</td>
</tr>
<tr>
<td style="vertical-align: top;">0<br>
</td>
<td style="vertical-align: top;">256<br>
</td>
<td style="vertical-align: top;">64<br>
</td>
</tr>
<tr>
<td style="vertical-align: top;">1<br>
</td>
<td style="vertical-align: top;">128<br>
</td>
<td style="vertical-align: top;">32<br>
</td>
</tr>
<tr>
<td style="vertical-align: top;">2<br>
</td>
<td style="vertical-align: top;">64<br>
</td>
<td style="vertical-align: top;">16<br>
</td>
</tr>
<tr>
<td style="vertical-align: top;">3<br>
</td>
<td style="vertical-align: top;">32<br>
</td>
<td style="vertical-align: top;">8<br>
</td>
</tr>
<tr>
<td style="vertical-align: top;">4<br>
</td>
<td style="vertical-align: top;">16<br>
</td>
<td style="vertical-align: top;">4<br>
</td>
</tr>
<tr>
<td style="vertical-align: top;">5<br>
</td>
<td style="vertical-align: top;">8<br>
</td>
<td style="vertical-align: top;">2<br>
</td>
</tr>
<tr>
<td style="vertical-align: top;">6<br>
</td>
<td style="vertical-align: top;">4<br>
</td>
<td style="vertical-align: top;">1<br>
</td>
</tr>
<tr>
<td style="vertical-align: top;">7<br>
</td>
<td style="vertical-align: top;">2<br>
</td>
<td style="vertical-align: top;">1<br>
</td>
</tr>
<tr>
<td style="vertical-align: top;">8<br>
</td>
<td style="vertical-align: top;">1<br>
</td>
<td style="vertical-align: top;">1<br>
</td>
</tr>
</tbody>
</table>
<br>
If the <span style="font-style: italic;">width</span> or <span
style="font-style: italic;">height</span> parameters are not powers of
two, the error GL_INVALID_VALUE is raised. &nbsp;If the image levels in
a mipmap do not satisfy the restrictions listed above the texture is
considered to be <span style="font-style: italic;">inconsistent</span>
and the system will behave as if the texturing is disabled.<br>
<br>
<h3>5.1.2 Texture Image Formats and Unpacking</h3>
The <span style="font-weight: bold;">glTexImage2D</span> command's <span
style="font-style: italic;"><span style="font-weight: bold;"></span></span><span
style="font-style: italic;">format</span> and <span
style="font-style: italic;">type</span> parameters describe the format
of the incoming texture image.&nbsp; Accepted values for <span
style="font-style: italic;">format</span> are GL_INTENSITY, GL_RGB and
GL_RGBA. &nbsp;The <span style="font-style: italic;">type</span>
parameter must be GL_UNSIGNED_BYTE. &nbsp;Pixel component values are
thus in the range 0 through 255.<br>
<br>
If <span style="font-style: italic;">format</span> is GL_INTENSITY then
the image has one byte per pixel which specifies the pixel's red, green,
blue and alpha values.<span style="font-style: italic;"></span><br>
<br>
If <span style="font-style: italic;">format</span> is GL_RGB then the
image has three bytes per pixel which specify the pixel's red, green and
blue values (in that order). &nbsp;The alpha value defaults to 255.<br>
<br>
If <span style="font-style: italic;">format</span> is GL_RGBA then the
image has four bytes per pixel which specify the pixel's red, green,
blue and alpha values (in that order).<br>
<br>
The command<br>
<br>
<div style="margin-left: 40px;">void<span style="font-weight: bold;">
glPixelStorei</span>(GLenum <span style="font-style: italic;">pname</span>,
GLint <span style="font-style: italic;">value</span>)<br>
</div>
<br>
controls the unpacking of texture image data from client memory. &nbsp;<span
style="font-style: italic;">pname</span> may be GL_UNPACK_ROW_LENGTH to
indicate the stride, in pixels, between subsequent rows of the image in
client memory. &nbsp;If GL_UNPACK_ROW_LENGTH is zero (the default) then
the <span style="font-style: italic;">width</span> parameter to <span
style="font-weight: bold;">glTexImage2D </span>determines the stride.<span
style="font-style: italic;"></span><br>
<br>
<h3>5.1.3 Internal Texture Format</h3>
<span style="font-weight: bold;">glTexImage2D<span
style="font-style: italic;"> </span></span>converts the incoming
texture image to one of the supported internal texture formats.<br>
<br>
The <span style="font-style: italic;">internalFormat</span> parameter
indicates the desired internal format for the texture and may be either
GL_INTENSITY8, GL_RGB5 or GL_RGBA8.<br>
<br>
If <span style="font-style: italic;">internalFormat</span> is
GL_INTENSITY8 then the texture has one byte per texel (texture element)
which indicates the texel's intensity (or brightness). &nbsp;The
intensity is obtained from the incoming image's red channel.<br>
<br>
If <span style="font-style: italic;">internalFormat</span> is GL_RGB5
then the texture is stored with two bytes per texel: &nbsp;5 bits per
red value, 5 bits per green value and 5 bits per blue value.<br>
<br>
If <span style="font-style: italic;">internalFormat </span>is
GL_RGBA8 then the texture is stored with four bytes per texel: &nbsp;8
bits for each of the red, green, &nbsp;blue and alpha values.<br>
<br>
The internal format is also significant to texture application (see
section 5.4).<br>
<br>
<h2>5.2 Texture Coordinates</h2>
Texture coordinates control the mapping from local polygon space to
texture image space. &nbsp;Texture coordinates are set for each vertex
with the <span style="font-weight: bold;">glTexCoord</span> commands.
&nbsp;During line and polygon rasterization the vertex's texture
coordinates are interpolated across the primitive to produce a texture
coordinate for each fragment. &nbsp;The fragment texture coordinates are
used to sample the current texture image.<br>
<br>
Texture coordinates are normally in the range [0, 1]. &nbsp;Values
outside that range are processed according to the <span
style="font-style: italic;">texture wrap mode</span>. &nbsp;The
texture wrap mode is set with the command<br>
<br>
<div style="margin-left: 40px;">void <span style="font-weight: bold;">glTexParameteri</span>(GLenum<span
style="font-style: italic;"> target</span>, GLenum <span
style="font-style: italic;">pname</span>, GLint <span
style="font-style: italic;">value</span>)<br>
<br>
</div>
<span style="font-style: italic;">target</span> must be GL_TEXTURE_2D.
&nbsp;If <span style="font-style: italic;">pname</span> is
GL_TEXTURE_WRAP_S or GL_TEXTURE_WRAP_T then <span
style="font-style: italic;">value</span> must be either
GL_CLAMP_TO_EDGE or GL_REPEAT.<br>
<br>
For GL_CLAMP_TO_EDGE, texture coordinates are effectively clamped to
the interval [0, 1].<br>
<br>
For GL_REPEAT, the integer part of texture coordinates is ignored; only
the fractional part of the texture coordinates is used. &nbsp;This
allows texture images to repeated or tiled across an object.<br>
<br>
<h2>5.3 Texture Sampling</h2>
Texture sampling is the process of using texture coordinates to extract
a color from the texture image. &nbsp;Multiple, weighted samples may be
taken from the texture and combined during the filtering step.<br>
<br>
During texture coordinate interpolation a <span
style="font-style: italic;">level of detail</span> value (lambda) is
computed for each fragment. &nbsp;For a mipmapped texture, lambda
determines which level (or levels) of the mipmap will be sampled to
obtain the texture color.<br>
<br>
If lambda indicates that multiple texels map to a single screen pixel,
then the texture <span style="font-style: italic;">minification</span>
filter will be used. &nbsp;Otherwise, if lambda indicates that a single
texel maps to multiple screen pixels, then the texture <span
style="font-style: italic;">magnification</span> filter will be used.<br>
<span style="font-weight: bold;"></span><span
style="font-style: italic;"></span><br>
<h3>5.3.1 Texture Minification</h3>
The texture minification filter is set with the <span
style="font-weight: bold;">glTexParameteri </span><span
style="font-style: italic;"></span><span style="font-weight: bold;"></span><span
style="font-style: italic;"></span> command by setting <span
style="font-style: italic;">target</span> to GL_TEXTURE_2D, setting <span
style="font-style: italic;">pname</span> to GL_TEXTURE_MIN_FILTER and
setting <span style="font-style: italic;">value</span> to GL_NEAREST,
GL_LINEAR, GL_NEAREST_MIPMAP_NEAREST,&nbsp;
GL_NEAREST_MIPMAP_LINEAR,&nbsp; &nbsp;GL_LINEAR_MIPMAP_NEAREST or
GL_LINEAR_MIPMAP_LINEAR.<br>
<br>
GL_NEAREST samples the texel nearest the texture coordinate in the
level 0 texture image.<br>
<br>
GL_LINEAR samples the four texels around the texture coordinate in the
level 0 texture image. &nbsp;The four texels are linearly weighted to
compute the final texel value.<br>
<br>
GL_NEAREST_MIPMAP_NEAREST samples the texel nearest the texture
coordinate in the level N texture image. &nbsp;N is the level of detail
and is computed by the partial derivatives of the texture coordinates
with respect to the window coordinates.<br>
<br>
GL_NEAREST_MIPMAP_LINEAR samples two texels nearest the texture
coordinates in the level N and N+1 texture images. &nbsp;The two texels
are linearly weighted to compute the final texel value. &nbsp;N is the
level of detail and is computed by the partial derivatives of the
texture coordinates with respect to the window coordinates.<br>
<br>
GL_LINEAR_MIPMAP_NEAREST samples four texels around the texture
coordinate in the level N texture image. &nbsp;The four texels are
linearly weighted to compute the final texel value. &nbsp;N is the level
of detail and is computed by the partial derivatives of the texture
coordinates with respect to the window coordinates.<br>
<br>
GL_LINEAR_MIPMAP_LINEAR samples four texels around the texture
coordinate in the level N texture image and four texels around the
texture coordinate in the level N+1 texture image. &nbsp;The eight
texels are linearly weighted to compute the final texel value. &nbsp;N
is the level of detail and is computed by the partial derivatives of the
texture coordinates with respect to the window coordinates.<br>
<br>
Filter modes other than GL_LINEAR and GL_NEAREST requires that the
texture have a complete set of mipmaps. &nbsp;If the mipmap is
incomplete, it is as if texturing is disabled.<br>
&nbsp;<br>
<h3>5.3.2 Texture Magnification</h3>
The texture magnification filter is set with the <span
style="font-weight: bold;">glTexParameteri </span><span
style="font-style: italic;"></span><span style="font-weight: bold;"></span>command
by setting <span style="font-style: italic;">target</span> to
GL_TEXTURE_2D, setting <span style="font-style: italic;">pname</span> to
GL_TEXTURE_MAG_FILTER and setting <span style="font-style: italic;">value</span>
to GL_NEAREST or GL_LINEAR.<br>
<br>
GL_NEAREST samples the texel nearest the texture coordinate in the
level 0 texture image.<br>
<br>
GL_LINEAR samples the four texels around the texture coordinate in the
level 0 texture image. &nbsp;The four texels are linearly weighted to
compute the final texel value.<br>
<br>
<h2>5.4 Texture Application</h2>
The sampled texture value is combined with the incoming fragment color
to produce a new fragment color. &nbsp;The fragment and texture colors
are combined according to the texture environment mode and the current
texture's base internal format. &nbsp;The texture environment mode is
set with the command<br>
<br>
<div style="margin-left: 40px;">void<span style="font-weight: bold;">
glTexEnvi</span>(GLenum <span style="font-style: italic;">target</span>,
GLenum <span style="font-style: italic;">pname</span>, GLint <span
style="font-style: italic;">value</span>)<br>
</div>
<br>
<span style="font-style: italic;">target</span> must be GL_TEXTURE_ENV.
&nbsp;If <span style="font-style: italic;">pname</span> is
GL_TEXTURE_ENV_MODE then <span style="font-style: italic;">value</span>
must be one of GL_REPLACE, GL_MODULATE, GL_DECAL, or GL_BLEND.<br>
<br>
There is also a <span style="font-style: italic;">texture environment
color</span> that can factor into texture application. &nbsp;The texture
environment color can be set with the command<br>
<br>
<div style="margin-left: 40px;">void<span style="font-weight: bold;">
glTexEnvfv</span>(GLenum <span style="font-style: italic;">target</span>,
GLenum <span style="font-style: italic;">pname</span>, const GLfloat *<span
style="font-style: italic;">value</span>)<br>
</div>
<span style="font-style: italic;"></span><br>
<span style="font-style: italic;">target</span> must be GL_TEXTURE_ENV.
&nbsp;If <span style="font-style: italic;">pname</span> is
GL_TEXTURE_ENV_COLOR then <span style="font-style: italic;">value </span>must
point to an array of four values which specify the red, green, blue,
and alpha values of the texture environment color. &nbsp;The values are
clamped to the range [0, 1]. &nbsp;The default color is (0, 0, 0, 0).<br>
<span style="font-style: italic;"></span><br>
The following table describes the arithmetic used for each combination
of environment mode and base internal format. &nbsp;(Rf, Gf, Bf, Af) is
the incoming fragment color. &nbsp;(Rt, Gt, Bt, At) is the sampled
texture color. &nbsp;Lt is the sampled texture luminance. &nbsp;<span
style="font-style: italic;"></span>'It' is the sampled texture
intensity. &nbsp;(Rc, Gc, Bc, Ac) is the texture environment color.
&nbsp;(Rv, Gv, Bv, Av) is the resulting value.<br>
<br>
<br>
<table cellpadding="2" cellspacing="2" border="1"
style="text-align: left; width: 90%; margin-left: auto; margin-right: auto;">
<tbody>
<tr>
<td style="vertical-align: top;">Base Internal Format<br>
</td>
<td style="vertical-align: top;">GL_REPLACE<br>
</td>
<td style="vertical-align: top;">GL_MODULATE<br>
</td>
<td style="vertical-align: top;">GL_DECAL<br>
</td>
<td style="vertical-align: top;">GL_BLEND<br>
</td>
</tr>
<tr>
<td style="vertical-align: top;">GL_INTENSITY<br>
</td>
<td style="vertical-align: top;">Rv = It<br>
Gv = It<br>
Bv = It<br>
Bf = It<br>
</td>
<td style="vertical-align: top;">Rv = Rf * It<br>
Gv = Gf * It<br>
Bv = Bf * It<br>
Av = Af * It</td>
<td style="vertical-align: top;">undefined<br>
</td>
<td style="vertical-align: top;">Rv = Rf*(1-It) + Rc*It<br>
Gv = Gf*(1-It) + Gc*It<br>
Bv = Bf*(1-It) + Bc*It<br>
Av = Af*(1-It) + Ac*It</td>
</tr>
<tr>
<td style="vertical-align: top;">GL_RGB<br>
</td>
<td style="vertical-align: top;">Rv = Rt<br>
Gv = Gt<br>
Bv = Bt<br>
Av = Af<br>
</td>
<td style="vertical-align: top;">Rv = Rf * Rt<br>
Gv = Gf * Gt<br>
Bv = Bf * Bt<br>
Av = Af<br>
</td>
<td style="vertical-align: top;">Rv = Rt<br>
Gv = Gt<br>
Bv = Bt<br>
Av = Af</td>
<td style="vertical-align: top;">Rv = Rf*(1-Rt) + Rc*Rt<br>
Gv = Gf*(1-Gt) + Gc*Gt<br>
Bv = Bf*(1-Bt) + Bc*Bt<br>
Av = Af</td>
</tr>
<tr>
<td style="vertical-align: top;">GL_RGBA<br>
</td>
<td style="vertical-align: top;">Rv = Rt<br>
Gv = Gt<br>
Bv = Bt<br>
Av = At<br>
</td>
<td style="vertical-align: top;">Rv = Rf * Rt<br>
Gv = Gf * Gt<br>
Bv = Bf * Bt<br>
Av = Af * At</td>
<td style="vertical-align: top;">Rv = Rf*(1-At) + Rt*At<br>
Gv = Gf*(1-At) + Gt*At<br>
Bv = Bf*(1-At) + Bt*At<br>
Av = Af<br>
</td>
<td style="vertical-align: top;">Rv = Rf*(1-Rt) + Rc*Rt<br>
Gv = Gf*(1-Gt) + Gc*Gt<br>
Bv = Bf*(1-Bt) + Bc*Bt<br>
Av = Af*At</td>
</tr>
</tbody>
</table>
<br>
<br>
<br>
<h2>5.5 Texture Objects</h2>
Texture objects encapsulate a set of texture images (mipmap) and
related state into a named object. &nbsp;This facilitates use of
multiple textures in an application. &nbsp;Texture objects are named
with GLuints (unsigned integers). &nbsp;There is a default texture
object with the name/identifier zero which can never be deleted.<br>
<br>
<h3>5.5.1 Creating Texture Objects</h3>
A texture object is created by binding a new GLuint identifier to the
GL_TEXTURE_2D target with the command:<br>
<br>
<div style="margin-left: 40px;">void <span style="font-weight: bold;">glBindTexture</span>(GLenum<span
style="font-style: italic;"> target</span>, GLuint <span
style="font-style: italic;">textureID</span>)<br>
</div>
<br>
<span style="font-style: italic;">target</span> must be GL_TEXTURE_2D.
&nbsp;<span style="font-style: italic;">textureID</span> may be any
unsigned integer. &nbsp;If <span style="font-style: italic;">textureID</span>
does not name an existing texture object, a new texture object with that
ID will be created, initialized to the default state. &nbsp;Whether the
ID is new or existed previously, that named texture object is bound as
the <span style="font-style: italic;">current texture object</span>.
&nbsp;Subsequent <span style="font-weight: bold;">glTexParameter </span>and<span
style="font-weight: bold;">glTexImage2D<span
style="font-style: italic;"> </span></span>calls will effect the
current texture object.<br>
<span style="font-style: italic;"></span><span
style="font-weight: bold;"><span style="font-style: italic;"> </span></span><br>
<h3>5.5.2 Deleting Texture Objects</h3>
One or more texture objects may be deleted with the command:<br>
<br>
<div style="margin-left: 40px;">void <span style="font-weight: bold;">glDeleteTextures</span>(GLsizei<span
style="font-style: italic;">n</span>, const GLuint *<span
style="font-style: italic;">textureIDs</span>)<br>
</div>
<br>
<span style="font-style: italic;">textureIDs</span> is an array of <span
style="font-style: italic;">n</span> texture IDs. &nbsp;The named
texture objects will be deleted. &nbsp;If the current texture object is
deleted the default texture object (number 0) will be bound as the
current texture object.<br>
<br>
<h3>5.5.3 Allocating Texture Object Identifiers</h3>
A list of new, unused texture IDs can be obtained by calling the command<br>
<br>
<div style="margin-left: 40px;">void <span style="font-weight: bold;">glGenTextures</span>(GLsizei<span
style="font-style: italic;"> n</span>, GLuint *<span
style="font-style: italic;">textureIDs</span>)<br>
</div>
<br>
An array of <span style="font-style: italic;">n</span> unused texture
IDs will be returned in the <span style="font-style: italic;">textureIDs</span>
array.<br>
<br>
<br>
<h1>6. Per-fragment Operations</h1>
The fragments produced by rasterization are subjected to a number of
operations which either modify the fragment or test the fragment
(discarding the fragment if the test fails.) &nbsp;This chapter
describes the per-fragment operations. &nbsp;They are presented in the
order in which they're performed. &nbsp;If a fragment fails a test it is
discarded and not subjected to subsequent tests or modifications.<br>
<br>
<h2>6.1 Scissor Test</h2>
The scissor test limits rendering to a 2-D rectangular region of the
framebuffer. &nbsp;The command<br>
<br>
<div style="margin-left: 40px;">void <span style="font-weight: bold;">glScissor</span>(GLint<span
style="font-style: italic;">x</span>, GLint <span
style="font-style: italic;">y</span>, GLsizei <span
style="font-style: italic;">width</span>, GLsizei<span
style="font-style: italic;"> height</span>)<br>
</div>
<br>
defines a clipping region with the lower-left corner at (<span
style="font-style: italic;">x, y</span>) and the given <span
style="font-style: italic;">width</span> and <span
style="font-style: italic;">height</span>. &nbsp;The scissor test is
enabled and disabled with the command <span style="font-weight: bold;">glEnable</span>(GL_SCISSOR_TEST)
and <span style="font-weight: bold;">glDisable</span>(GL_SCISSOR_TEST).<br>
<br>
If the incoming fragment's position is (x<sub>f</sub>, y<sub>f</sub>)
then the fragment will pass the test if <span
style="font-style: italic;">x</span> &lt;= x<sub>f</sub> &lt; <span
style="font-style: italic;">x</span> + <span
style="font-style: italic;">width</span> and <span
style="font-style: italic;">y</span> &lt;= y<sub>f</sub> &lt; <span
style="font-style: italic;">y</span> + <span
style="font-style: italic;">height. &nbsp;</span>Otherwise, the
fragment is discarded.<br>
<br>
If <span style="font-style: italic;">width</span> or <span
style="font-style: italic;">height</span> is less than zero the error
GL_INVALID_VALUE is raised. &nbsp;The default scissor rectangle bounds
are (0, 0, w, h) where w is the initial window width and h is the
initial window height. &nbsp;The scissor test is disabled by default.<br>
<br>
<h2>6.2 Alpha Test</h2>
The alpha test compares the fragment's alpha value against a reference
value and discards the fragment if the comparison fails. &nbsp;The test
is specified by the command<br>
<br>
<div style="margin-left: 40px;">void <span style="font-weight: bold;">glAlphaFunc</span>(GLenum<span
style="font-style: italic;">mode</span>, GLclampf <span
style="font-style: italic;">reference</span>)<br>
</div>
<br>
<span style="font-style: italic;">mode</span> specifies an inequality
and <span style="font-style: italic;">reference</span> specifies a value
to compare against. &nbsp;The following table lists all possible
modes&nbsp;<span style="font-style: italic;"></span>and the
corresponding test:<br>
<br>
<table cellpadding="2" cellspacing="2" border="1"
style="text-align: left; width: 50%; margin-left: auto; margin-right: auto;">
<tbody>
<tr>
<td style="vertical-align: top;">Comparison mode<br>
</td>
<td style="vertical-align: top;">The test passes if<br>
</td>
</tr>
<tr>
<td style="vertical-align: top;">GL_LESS<br>
</td>
<td style="vertical-align: top;">alpha &lt; <span
style="font-style: italic;">reference</span><br>
</td>
</tr>
<tr>
<td style="vertical-align: top;">GL_LEQUAL<br>
</td>
<td style="vertical-align: top;">alpha &lt;= <span
style="font-style: italic;">reference</span></td>
</tr>
<tr>
<td style="vertical-align: top;">GL_GREATER<br>
</td>
<td style="vertical-align: top;">alpha &gt; <span
style="font-style: italic;">reference</span></td>
</tr>
<tr>
<td style="vertical-align: top;">GL_GEQUAL<br>
</td>
<td style="vertical-align: top;">alpha &gt;= <span
style="font-style: italic;">reference</span></td>
</tr>
<tr>
<td style="vertical-align: top;">GL_EQUAL<br>
</td>
<td style="vertical-align: top;">alpha == <span
style="font-style: italic;">reference</span></td>
</tr>
<tr>
<td style="vertical-align: top;">GL_NOTEQUAL<br>
</td>
<td style="vertical-align: top;">alpha != <span
style="font-style: italic;">reference</span></td>
</tr>
<tr>
<td style="vertical-align: top;">GL_NEVER<br>
</td>
<td style="vertical-align: top;">never pass<br>
</td>
</tr>
<tr>
<td style="vertical-align: top;">GL_ALWAYS<br>
</td>
<td style="vertical-align: top;">always passes<br>
</td>
</tr>
</tbody>
</table>
<br>
The <span style="font-style: italic;">reference</span> parameter is
clamped to the range [0, 1].<br>
<br>
The alpha test is enabled and disabled with the commands <span
style="font-weight: bold;">glEnable</span>(GL_ALPHA_TEST) and <span
style="font-weight: bold;">glDisable</span>(GL_ALPHA_TEST).<br>
<br>
The default mode is GL_ALWAYS and the default reference value is 0.<br>
<br>
<h2>6.3 Stencil Test</h2>
The stencil buffer stores an N-bit integer value for each pixel in the
frame buffer. &nbsp;The stencil test compares the stencil buffer value
at the fragment's position to a reference value and possibly discards
the fragment based on the outcome. &nbsp;Furthermore, the stencil buffer
value may be updated or modified depending on the outcome. &nbsp;If
there is no stencil buffer the stencil test is bypassed.<br>
<br>
Stenciling is controlled by the commands<br>
<br>
<div style="margin-left: 40px;">void <span style="font-weight: bold;">glStencilFunc</span>(GLenum<span
style="font-style: italic;">func</span>, GLint <span
style="font-style: italic;">ref</span>, GLuint <span
style="font-style: italic;">mask</span>)<br>
void <span style="font-weight: bold;">glStencilOp</span>(GLenum <span
style="font-style: italic;">stencilFail</span>, GLenum <span
style="font-style: italic;">depthTestFail</span>, GLenum <span
style="font-style: italic;">depthTestPass</span>)<br>
</div>
<br>
The <span style="font-weight: bold;">glStencilFunc<span
style="font-style: italic;"> </span></span>command controls the
stencil test while <span style="font-weight: bold;">glStencilOp</span>
command controls the how the stencil buffer is updated/modified after
the test.<br>
<br>
<span style="font-style: italic;">ref</span> is clamped to the range [0,
2<sup>N</sup>-1] where N is the number of bits per stencil value in the
stencil buffer.<span style="font-style: italic;"></span><br>
<br>
The following table lists all possible values for the <span
style="font-style: italic;">func</span> parameter and when the stencil
test will pass. &nbsp;Both the stencil buffer value and the stencil
reference value are bit-wise ANDed with the <span
style="font-style: italic;">mask</span> parameter before the test.<br>
<br>
<span style="font-style: italic;"></span><span
style="font-style: italic;"></span><span style="font-style: italic;"></span>
<table
style="text-align: left; margin-left: auto; margin-right: auto; width: 70%;"
border="1" cellspacing="2" cellpadding="2">
<tbody>
<tr>
<td style="vertical-align: top;">Stencil <span
style="font-style: italic;">func</span> value<br>
</td>
<td style="vertical-align: top;">Stencil test passes if<br>
</td>
</tr>
<tr>
<td style="vertical-align: top;">GL_LESS<br>
</td>
<td style="vertical-align: top;"><span style="font-style: italic;">(ref</span>&amp;<span
style="font-style: italic;">mask)</span> &lt; (stencil buffer value
&amp; <span style="font-style: italic;">mask)</span><br>
</td>
</tr>
<tr>
<td style="vertical-align: top;">GL_LEQUAL<br>
</td>
<td style="vertical-align: top;"><span style="font-style: italic;">(ref</span>
&amp; <span style="font-style: italic;">mask) </span>&lt;= (stencil
buffer value &amp; <span style="font-style: italic;">mask)</span></td>
</tr>
<tr>
<td style="vertical-align: top;">GL_GREATER<br>
</td>
<td style="vertical-align: top;"><span style="font-style: italic;">(ref</span>
&amp; <span style="font-style: italic;">mask) </span>&gt; (stencil
buffer value &amp; <span style="font-style: italic;">mask)</span></td>
</tr>
<tr>
<td style="vertical-align: top;">GL_GEQUAL<br>
</td>
<td style="vertical-align: top;"><span style="font-style: italic;">(ref</span>
&amp; <span style="font-style: italic;">mask) </span>&gt;= (stencil
buffer value &amp; <span style="font-style: italic;">mask)</span></td>
</tr>
<tr>
<td style="vertical-align: top;">GL_EQUAL<br>
</td>
<td style="vertical-align: top;"><span style="font-style: italic;">(ref</span>
&amp; <span style="font-style: italic;">mask) </span>== (stencil
buffer value &amp; <span style="font-style: italic;">mask)</span></td>
</tr>
<tr>
<td style="vertical-align: top;">GL_NOTEQUAL<br>
</td>
<td style="vertical-align: top;"><span style="font-style: italic;">(ref</span>
&amp; <span style="font-style: italic;">mask) </span>!= (stencil
buffer value &amp; <span style="font-style: italic;">mask)</span></td>
</tr>
<tr>
<td style="vertical-align: top;">GL_NEVER<br>
</td>
<td style="vertical-align: top;">never passes<br>
</td>
</tr>
<tr>
<td style="vertical-align: top;">GL_ALWAYS<br>
</td>
<td style="vertical-align: top;">always passes<br>
</td>
</tr>
</tbody>
</table>
<br>
<span style="font-style: italic;"></span><br>
If the stencil test passes, the fragment is passed to the next
per-fragment operation. &nbsp;Otherwise, if the stencil test fails, the
value in the stencil buffer is updated according to the value of the <span
style="font-style: italic;">stencilFail</span> parameter to <span
style="font-weight: bold;">glStencilOp</span>.<br>
<br>
<table cellpadding="2" cellspacing="2" border="1"
style="text-align: left; width: 70%; margin-left: auto; margin-right: auto;">
<tbody>
<tr>
<td style="vertical-align: top;"><span style="font-style: italic;">stencilFail</span>
value<br>
</td>
<td style="vertical-align: top;">New stencil buffer value<br>
</td>
</tr>
<tr>
<td style="vertical-align: top;">GL_KEEP<br>
</td>
<td style="vertical-align: top;">originalValue<br>
</td>
</tr>
<tr>
<td style="vertical-align: top;">GL_ZERO<br>
</td>
<td style="vertical-align: top;">0<br>
</td>
</tr>
<tr>
<td style="vertical-align: top;">GL_INVERT<br>
</td>
<td style="vertical-align: top;">BitWiseInvert(originalValue)
i.e. ~originalValue<br>
</td>
</tr>
<tr>
<td style="vertical-align: top;">GL_REPLACE<br>
</td>
<td style="vertical-align: top;"><span style="font-style: italic;">ref</span><br>
</td>
</tr>
<tr>
<td style="vertical-align: top;">GL_INCR<br>
</td>
<td style="vertical-align: top;">originalValue + 1, clamped to
[0, 2<sup>N</sup>-1]</td>
</tr>
<tr>
<td style="vertical-align: top;">GL_DECR<br>
</td>
<td style="vertical-align: top;">originalValue - 1, clamped to
[0, 2<sup>N</sup>-1]</td>
</tr>
</tbody>
</table>
<span style="font-style: italic;"></span><span
style="font-style: italic;"></span><br>
<br>
The <span style="font-style: italic;">depthTestFail</span> and <span
style="font-style: italic;">depthTestPass</span> parameters to <span
style="font-weight: bold;">glStencilOp</span> are ignored. &nbsp;Values
for <span style="font-style: italic;">func</span> and <span
style="font-style: italic;">stencilFail</span> other than those listed
in the table will cause the error GL_INVALID_ENUM to be raised.<br>
<br>
The stencil test is enabled and disabled with the commands <span
style="font-weight: bold;">glEnable</span>(GL_STENCIL_TEST) and <span
style="font-weight: bold;">glDisable</span>(GL_STENCIL_TEST).<br>
<br>
The default stencil function is GL_ALWAYS. &nbsp;The default stencil
reference value is 0. &nbsp;The default stencil mask is ~0. &nbsp;The
default stencil fail operation is GL_KEEP.<br>
<br>
Values written into the stencil buffer are masked with the command<br>
<br>
<div style="margin-left: 40px;">void <span style="font-weight: bold;">glStencilMask</span>(GLuint<span
style="font-style: italic;">mask</span>)<br>
</div>
<br>
Only the bits which are set in <span style="font-style: italic;">mask</span>
will be modified in the stencil buffer when written to. &nbsp;If each
stencil buffer value has N bits, only the least significant N bits of <span
style="font-style: italic;">mask</span> are relevant. &nbsp;The default
stencil mask is ~0.<br>
<br>
<h2>6.4 Blending and Logicop</h2>
Blending or a logic operation combines the incoming fragment color with
the destination frame buffer color according to a blending equation or
bit-wise Boolean logical operation.<br>
<br>
Blending is enabled and disabled with the commands <span
style="font-weight: bold;">glEnable</span>(GL_BLEND) and <span
style="font-weight: bold;">glDisable</span>(GL_BLEND).<br>
<br>
The logic operation is enabled and disabled with the commands <span
style="font-weight: bold;">glEnable</span>(GL_LOGIC_OP) and <span
style="font-weight: bold;">glDisable</span>(GL_LOGIC_OP).<br>
<br>
If both blending and the logic operation are enabled, the logic
operation has higher priority; blending is bypassed.<br>
<br>
<h3>6.4.1 Logic Op</h3>
The command<br>
<br>
<div style="margin-left: 40px;">void <span style="font-weight: bold;">glLogicop</span>(GLenum<span
style="font-style: italic;">mode</span>)<br>
<br>
</div>
Specifies the Boolean logic operation for combining the incoming
fragment color with the destination frame buffer color. &nbsp;Both the
incoming fragment color and destination frame buffer colors are
interpreted as four-tuples of unsigned integer color components in the
range [0, 2<sup>N</sup>-1] where N is the number of bits per color
channel. &nbsp;N may not be the same for all color channels.<br>
<br>
The following table lists all values for <span
style="font-style: italic;">mode</span> and the boolean arithmetic used
to combine the incoming fragment color value (src)<span
style="font-style: italic;"></span><span style="font-style: italic;"></span><span
style="font-style: italic;"></span><span style="font-style: italic;"></span><span
style="font-style: italic;"></span> with the destination framebuffer
color value (dst). &nbsp;Standard ANSI C operators used.<br>
<br>
<table cellpadding="2" cellspacing="2" border="1"
style="text-align: left; width: 50%; margin-left: auto; margin-right: auto;">
<tbody>
<tr>
<td style="vertical-align: top;">LogicOp <span
style="font-style: italic;">mode</span><br>
</td>
<td style="vertical-align: top;">Resulting channel value<br>
</td>
</tr>
<tr>
<td style="vertical-align: top;">GL_CLEAR<br>
</td>
<td style="vertical-align: top;">0<br>
</td>
</tr>
<tr>
<td style="vertical-align: top;">GL_SET<br>
</td>
<td style="vertical-align: top;">~0<br>
</td>
</tr>
<tr>
<td style="vertical-align: top;">GL_COPY<br>
</td>
<td style="vertical-align: top;">src<br>
</td>
</tr>
<tr>
<td style="vertical-align: top;">GL_COPY_INVERTED<br>
</td>
<td style="vertical-align: top;">~s<br>
</td>
</tr>
<tr>
<td style="vertical-align: top;">GL_NOOP<br>
</td>
<td style="vertical-align: top;">dst<br>
</td>
</tr>
<tr>
<td style="vertical-align: top;">GL_INVERT<br>
</td>
<td style="vertical-align: top;">~dst<br>
</td>
</tr>
<tr>
<td style="vertical-align: top;">GL_AND<br>
</td>
<td style="vertical-align: top;">src &amp; dst<br>
</td>
</tr>
<tr>
<td style="vertical-align: top;">GL_NAND<br>
</td>
<td style="vertical-align: top;">~(src &amp; dst)<br>
</td>
</tr>
<tr>
<td style="vertical-align: top;">GL_AND_REVERSE<br>
</td>
<td style="vertical-align: top;">src &amp; ~dst<br>
</td>
</tr>
<tr>
<td style="vertical-align: top;">GL_AND_INVERTED<br>
</td>
<td style="vertical-align: top;">~src &amp; dst<br>
</td>
</tr>
<tr>
<td style="vertical-align: top;">GL_OR<br>
</td>
<td style="vertical-align: top;">src | dst<br>
</td>
</tr>
<tr>
<td style="vertical-align: top;">GL_NOR<br>
</td>
<td style="vertical-align: top;">~(src | dst)<br>
</td>
</tr>
<tr>
<td style="vertical-align: top;">GL_OR_REVERSE<br>
</td>
<td style="vertical-align: top;">src | ~dst<br>
</td>
</tr>
<tr>
<td style="vertical-align: top;">GL_OR_INVERTED<br>
</td>
<td style="vertical-align: top;">~src | dst<br>
</td>
</tr>
<tr>
<td style="vertical-align: top;">GL_XOR<br>
</td>
<td style="vertical-align: top;">src ^ dst<br>
</td>
</tr>
<tr>
<td style="vertical-align: top;">GL_EQUIV<br>
</td>
<td style="vertical-align: top;">~(src ^ dst)<br>
</td>
</tr>
</tbody>
</table>
<br>
The fragment's color is replaced by the result of the logic operation.<br>
<br>
Specifying any value for <span style="font-style: italic;">mode</span>
other than those listed in the above table will cause the error
GL_INVALID_ENUM to be raised.<br>
<br>
The default value for <span style="font-style: italic;">mode</span> is
GL_COPY. &nbsp;The logic operation is disabled by default.<br>
<br>
<h3>6.4.2 Blending</h3>
The command<br>
<br>
<div style="margin-left: 40px;">void <span style="font-weight: bold;">glBlendFunc</span>(GLenum<span
style="font-style: italic;">srcTerm</span>, GLenum <span
style="font-style: italic;">dstTerm</span>)<br>
</div>
<br>
specifies the terms of the blending equation. &nbsp;If Cf = (Rf, Gf,
Bf, Af) is the incoming fragment color and Cb = (Rb, Gb, Bb, Ab) is the
frame buffer color, then the resulting color Cv = (Rv, Gv, Bv, Av) is
computed by:<br>
<br>
<div style="margin-left: 40px;">Cv = Cf * <span
style="font-style: italic;">srcTerm</span> + Cb * <span
style="font-style: italic;">dstTerm</span><br>
<span style="font-style: italic;"></span></div>
<span style="font-style: italic;"> </span><br>
All possible values for <span style="font-style: italic;">srcTerm</span>
and the corresponding arithmetic term are listed in the following table:<br>
<br>
<table cellpadding="2" cellspacing="2" border="1"
style="text-align: left; width: 70%; margin-left: auto; margin-right: auto;">
<tbody>
<tr>
<td style="vertical-align: top;"><span style="font-style: italic;">srcTerm</span><br>
</td>
<td style="vertical-align: top;"><span style="font-style: italic;">srcTerm</span>Arithmetic<br>
</td>
</tr>
<tr>
<td style="vertical-align: top;">GL_ZERO<br>
</td>
<td style="vertical-align: top;">(0, 0, 0, 0)<br>
</td>
</tr>
<tr>
<td style="vertical-align: top;">GL_ONE<br>
</td>
<td style="vertical-align: top;">(1, 1, 1, 1)<br>
</td>
</tr>
<tr>
<td style="vertical-align: top;">GL_DST_COLOR<br>
</td>
<td style="vertical-align: top;">(Rb, Gb, Bb, Ab)<br>
</td>
</tr>
<tr>
<td style="vertical-align: top;">GL_ONE_MINUS_DST_COLOR<br>
</td>
<td style="vertical-align: top;">(1-Rb, 1-Gb, 1-Bb, 1-Ab)<br>
</td>
</tr>
<tr>
<td style="vertical-align: top;">GL_SRC_ALPHA<br>
</td>
<td style="vertical-align: top;">(Af, Af, Af, AF)<br>
</td>
</tr>
<tr>
<td style="vertical-align: top;">GL_ONE_MINUS_SRC_ALPHA<br>
</td>
<td style="vertical-align: top;">(1-Af, 1-Af, 1-Af, 1-Af)<br>
</td>
</tr>
<tr>
<td style="vertical-align: top;">GL_DST_ALPHA<br>
</td>
<td style="vertical-align: top;">(Ab, Ab, Ab, Ab)<br>
</td>
</tr>
<tr>
<td style="vertical-align: top;">GL_ONE_MINUS_DST_ALPHA<br>
</td>
<td style="vertical-align: top;">(1-Ab, 1-Ab, 1-Ab, 1-Ab)<br>
</td>
</tr>
<tr>
<td style="vertical-align: top;">GL_SRC_ALPHA_SATURATE<br>
</td>
<td style="vertical-align: top;">(m, m, m, 1) where m = MIN(Af,
1-Ab)<br>
</td>
</tr>
</tbody>
</table>
<br>
All possible values for <span style="font-style: italic;">srcTerm</span>
and the corresponding arithmetic term are listed in the following table:<br>
<br>
<table cellpadding="2" cellspacing="2" border="1"
style="text-align: left; width: 70%; margin-left: auto; margin-right: auto;">
<tbody>
<tr>
<td style="vertical-align: top;"><span style="font-style: italic;">dstTerm</span><br>
</td>
<td style="vertical-align: top;"><span style="font-style: italic;">dstTerm</span>Arithmetic<br>
</td>
</tr>
<tr>
<td style="vertical-align: top;">GL_ZERO<br>
</td>
<td style="vertical-align: top;">(0, 0, 0, 0)<br>
</td>
</tr>
<tr>
<td style="vertical-align: top;">GL_ONE<br>
</td>
<td style="vertical-align: top;">(1, 1, 1, 1)<br>
</td>
</tr>
<tr>
<td style="vertical-align: top;">GL_SRC_COLOR<br>
</td>
<td style="vertical-align: top;">(Rf, Gf, Bf, Af)<br>
</td>
</tr>
<tr>
<td style="vertical-align: top;">GL_ONE_MINUS_SRC_COLOR<br>
</td>
<td style="vertical-align: top;">(1-Rf, 1-Gf, 1-Bf, 1-Af)<br>
</td>
</tr>
<tr>
<td style="vertical-align: top;">GL_SRC_ALPHA<br>
</td>
<td style="vertical-align: top;">(Af, Af, Af, AF)<br>
</td>
</tr>
<tr>
<td style="vertical-align: top;">GL_ONE_MINUS_SRC_ALPHA<br>
</td>
<td style="vertical-align: top;">(1-Af, 1-Af, 1-Af, 1-Af)<br>
</td>
</tr>
<tr>
<td style="vertical-align: top;">GL_DST_ALPHA<br>
</td>
<td style="vertical-align: top;">(Ab, Ab, Ab, Ab)<br>
</td>
</tr>
<tr>
<td style="vertical-align: top;">GL_ONE_MINUS_DST_ALPHA<br>
</td>
<td style="vertical-align: top;">(1-Ab, 1-Ab, 1-Ab, 1-Ab)<br>
</td>
</tr>
</tbody>
</table>
<br>
The fragment's color is replaced by the result of the blending equation.<br>
<br>
Values for <span style="font-style: italic;">srcTerm</span> and <span
style="font-style: italic;">dstTerm</span> other than those listed in
the table will cause the error GL_INVALID_ENUM to be raised.<br>
<br>
The default value for <span style="font-style: italic;">srcTerm</span>
is GL_ONE. &nbsp;The default value for <span style="font-style: italic;">dstTerm</span>
is GL_ZERO. &nbsp;Blending is disabled by default.<br>
<br>
<h2>6.5 Color Mask</h2>
The final fragment color is written into the current color buffer at
the end of the per-fragment operations. &nbsp;Normally, all color
channels in the frame buffer are replaced with the final fragment color.
&nbsp;However, the command<br>
<br>
<div style="margin-left: 40px;">void <span style="font-weight: bold;">glColorMask</span>(GLboolean<span
style="font-style: italic;">redMask</span>, GLboolean <span
style="font-style: italic;">greenMask</span>, GLboolean <span
style="font-style: italic;">blueMask</span>, GLboolean <span
style="font-style: italic;">alphaMask</span>)<br>
</div>
<br>
allows selective writing to individual color channels. &nbsp;If <span
style="font-style: italic;">redMask</span> is GL_TRUE then writing to
the red color channel is enabled, otherwise it's disabled.
&nbsp;Similarly, the green, blue and alpha channels can also be masked.<br>
<br>
Initially all four mask values are GL_TRUE.<br>
<br>
Color masking is not enabled/disabled with the <span
style="font-weight: bold;">glEnable</span>/<span
style="font-weight: bold;">glDisable</span> commands.<br>
<br>
<h1>7. Frame Buffer Operations</h1>
The frame buffer is considered to be a two-dimensional array of pixels.
&nbsp;The frame buffer is also organized into layers or logical buffers.
&nbsp;There may be a front color buffer, back color buffer and stencil
buffer. &nbsp;A double-buffered frame buffer has both a front color
buffer and back color buffer. &nbsp;A single-buffered framebuffer only
has a front color buffer. &nbsp;Each pixel in a color buffer has a red,
green and blue value and an optional alpha value.<br>
<br>
<h2>7.1 Clearing Buffers</h2>
Buffers are cleared (set to uniform values) with the command<br>
<br>
<div style="margin-left: 40px;">void <span style="font-weight: bold;">glClear</span>(GLbitfield<span
style="font-style: italic;">buffers</span>)<br>
</div>
<br>
<span style="font-style: italic;">buffers</span> is a bitmask for which
the value may be the bitwise-OR of the values GL_COLOR_BUFFER_BIT and
GL_STENCIL_BUFFER_BIT. &nbsp;If the GL_COLOR_BUFFER_BIT bit is
specified, the current color buffer will be cleared. &nbsp;If the
GL_STENCIL_BUFFER_BIT bit is specified, the stencil buffer will be
cleared.<br>
<br>
The current color buffer is specified with the command<br>
<br>
<div style="margin-left: 40px;">void <span style="font-weight: bold;">glDrawBuffer</span>(GLenum<span
style="font-style: italic;"> buffer</span>)<br>
</div>
<br>
<span style="font-style: italic;">buffer</span> may be either GL_FRONT,
GL_BACK or GL_NONE. &nbsp;GL_FRONT indicates that the front color buffer
will be modified by <span style="font-weight: bold;">glClear</span> and
any drawing command. &nbsp;GL_BACK indicates that the back color buffer
will be modified by <span style="font-weight: bold;">glClear</span> and
any drawing command. &nbsp;GL_NONE indicates that neither color buffer
will be modified by <span style="font-weight: bold;">glClear</span> or
any drawing command. &nbsp;GL_BACK is only valid for double-buffered
frame buffers.<br>
<br>
The current scissor rectangle, set by the <span
style="font-weight: bold;">glScissor</span> command, effects <span
style="font-weight: bold;">glClear</span><span
style="font-style: italic;">,</span><span style="font-style: italic;"> </span>limiting
the clear to the scissor rectangle, if it's enabled. &nbsp;Furthermore, <span
style="font-weight: bold;"></span>only the color channels enabled by <span
style="font-weight: bold;">glColorMask</span> will be effected by <span
style="font-weight: bold;">glClear</span>(GL_COLOR_BUFFER_BIT).
&nbsp;Likewise, only the stencil bits enabled by <span
style="font-weight: bold;">glStencilMask</span> will be effected by <span
style="font-weight: bold;">glClear</span>(GL_STENCIL_BUFFER_BIT).<br>
<br>
The current clear color is set with the command<br>
<br>
<div style="margin-left: 40px;">void <span style="font-weight: bold;">glClearColor</span>(GLclampf<span
style="font-style: italic;">red</span>, GLclampf <span
style="font-style: italic;">green</span>, GLclampf <span
style="font-style: italic;">blue</span>, GLclampf <span
style="font-style: italic;">alpha</span>)<br>
</div>
<br>
Subsequent calls to <span style="font-weight: bold;">glClear</span>
will use the color (<span style="font-style: italic;">red, green, blue,
alpha</span>) to clear the front or back color buffers.<br>
<span style="font-style: italic;"></span><br>
The current stencil clear value is set with the command<br>
<br>
<div style="margin-left: 40px;">void <span style="font-weight: bold;">glClearStencil</span>(GLint<span
style="font-style: italic;">clearValue</span>)<br>
</div>
<br>
If the stencil buffer is N bits deep, the least significant N bits of <span
style="font-style: italic;">clearValue</span> will be used to clear the
stencil buffer.<br>
<br>
<br>
<h1>8. Other Features</h1>
<h2>8.1 Frame Buffer Readback</h2>
A rectangular region of pixels can be read from the frame buffer and
placed in client memory with the command<br>
<br>
<div style="margin-left: 40px;">void <span style="font-weight: bold;">glReadPixels</span>(GLint<span
style="font-style: italic;">x</span>, GLint <span
style="font-style: italic;">y</span>, GLsizei <span
style="font-style: italic;">width</span>, GLsizei <span
style="font-style: italic;">height</span>, GLenum <span
style="font-style: italic;">format</span>, GLenum <span
style="font-style: italic;">type</span>, GLvoid *<span
style="font-style: italic;">data</span>)<br>
</div>
<br>
<span style="font-style: italic;">x</span> and <span
style="font-style: italic;">y</span> specify the coordinate of the
lower-left corner of the region to read and <span
style="font-style: italic;">width</span> and <span
style="font-style: italic;">height</span> specify the size of the
rectangular region to read. &nbsp;<span style="font-style: italic;">format</span>
specifies the format of image data and must be either GL_RGB or
GL_RGBA.&nbsp; <span style="font-style: italic;">type</span> specify the
data type of the image data and must be either GL_UNSIGNED_BYTE or
GL_FLOAT. &nbsp;Other values for <span style="font-style: italic;">format</span>
or <span style="font-style: italic;">type</span> will cause the error
GL_INVALID_ENUM to be raised.<br>
<br>
The framebuffer may contain 3-component colors (red, green, blue) or
4-component colors (red, green, blue, alpha). &nbsp;If an alpha channel
is not present, alpha values default to 1.0.<br>
<br>
The frame buffer color components (red, green, blue, alpha) are either
converted to 8-bit unsigned integers in the range[0, 255] if <span
style="font-style: italic;">type </span>is GL_UNSIGNED_BYTE or
converted to floating point values in the range [0, 1] if <span
style="font-style: italic;">type</span> is GL_FLOAT. &nbsp;The (red,
green, blue, alpha) tuples are then stored as GL_RGB triplets (by
dropping the alpha component) or GL_RGBA quadruples in client memory.<br>
<br>
Image data is <span style="font-style: italic;">packed</span> into
client memory according to the pixel packing parameters which are set by
the command<br>
<br>
<div style="margin-left: 40px;">void <span style="font-weight: bold;">glPixelStorei</span>(GLenum<span
style="font-style: italic;"> pname</span>, GLint <span
style="font-style: italic;">value</span>)<br>
</div>
<br>
<span style="font-style: italic;">pname</span> must be
GL_PACK_ROW_LENGTH. &nbsp;<span style="font-style: italic;">value</span>
indicates the stride (in pixels) between subsequent rows in the
destination image. &nbsp;If GL_PACK_ROW_LENGTH is zero (the default)
then the <span style="font-style: italic;">width</span> parameter to <span
style="font-weight: bold;">glReadPixels</span> indicates the row stride.<br>
<br>
Pixel readback takes place as follows:<br>
<br>
<div style="margin-left: 40px;">if (GL_PACK_ROW_LENGTH == 0)<br>
&nbsp;&nbsp;&nbsp; rowLength = <span style="font-style: italic;">width</span>;<br>
else<br>
&nbsp;&nbsp;&nbsp; rowLength = GL_PACK_ROW_LENGTH<br>
<br>
if (<span style="font-style: italic;">format</span> == GL_RGB) {<br>
&nbsp;&nbsp;&nbsp; for (i = 0; i &lt; <span style="font-style: italic;">height</span>;
i++) {<br>
&nbsp;&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; for (j = 0; j &lt; <span
style="font-style: italic;">width</span>; j++) {<br>
&nbsp;&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; k = (i *
rowLength + j) * 3;<br>
&nbsp;&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; <span
style="font-style: italic;">data</span>[k+0] = FrameBuffer(<span
style="font-style: italic;">x</span> + j, <span
style="font-style: italic;">y</span> + i).red;<br>
&nbsp;&nbsp;&nbsp; &nbsp;&nbsp; &nbsp; &nbsp;&nbsp; <span
style="font-style: italic;">data</span>[k+1] = FrameBuffer(<span
style="font-style: italic;">x</span> + j, <span
style="font-style: italic;">y</span> + i).green;<br>
&nbsp;&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; <span
style="font-style: italic;">data</span>[k+2] = FrameBuffer(<span
style="font-style: italic;">x</span> + j, <span
style="font-style: italic;">y</span> + i).blue;<span
style="font-style: italic;"></span><br>
&nbsp;&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; }<br>
&nbsp;&nbsp;&nbsp; }<br>
}<br>
else {<br>
&nbsp;&nbsp;&nbsp; for (i = 0; i &lt; <span style="font-style: italic;">height</span>;
i++) {<br>
&nbsp;&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; for (j = 0; j &lt; <span
style="font-style: italic;">width</span>; j++) {<br>
&nbsp;&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; k = (i *
rowLength + j) * 4;<br>
&nbsp;&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; <span
style="font-style: italic;">data</span>[k+0] = FrameBuffer(<span
style="font-style: italic;">x</span> + j, <span
style="font-style: italic;">y</span> + i).red;<br>
&nbsp;&nbsp;&nbsp; &nbsp;&nbsp; &nbsp; &nbsp;&nbsp; <span
style="font-style: italic;">data</span>[k+1] = FrameBuffer(<span
style="font-style: italic;">x</span> + j, <span
style="font-style: italic;">y</span> + i).green;<br>
&nbsp;&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; <span
style="font-style: italic;">data</span>[k+2] = FrameBuffer(<span
style="font-style: italic;">x</span> + j, <span
style="font-style: italic;">y</span> + i).blue;<span
style="font-style: italic;"></span><br>
&nbsp;&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; <span
style="font-style: italic;">data</span>[k+3] = FrameBuffer(<span
style="font-style: italic;">x</span> + j, <span
style="font-style: italic;">y</span> + i).alpha;<span
style="font-style: italic;"></span><br>
&nbsp;&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; }<br>
&nbsp;&nbsp;&nbsp; }<br>
}<br>
</div>
<br>
The function FrameBuffer(<span style="font-style: italic;">c, r</span>)
returns the pixel in the frame buffer at column <span
style="font-style: italic;">c</span> of row <span
style="font-style: italic;">r. &nbsp;</span><span
style="font-style: italic;">data</span> is considered to be either a
GLubyte pointer or a GLfloat pointer, depending on the <span
style="font-style: italic;">type</span> parameter. &nbsp;Similarly, the
FrameBuffer function returns either GLubyte values in the range [0, 255]
or GLfloat values in the range [0,1], depending on the <span
style="font-style: italic;">type</span> parameter.<br>
<br>
Pixels may be read from either the front or back color buffer.
&nbsp;The command<br>
<br>
<div style="margin-left: 40px;">void <span style="font-weight: bold;">glReadBuffer</span>(GLenum<span
style="font-style: italic;">buffer</span>)<br>
</div>
<br>
specifies the source for reading images with <span
style="font-weight: bold;">glReadPixels</span>. &nbsp;If <span
style="font-style: italic;">buffer</span> is GL_FRONT then front color
buffer is the source. &nbsp;If <span style="font-style: italic;">buffer</span>
is GL_BACK then the back color buffer is the source. &nbsp;It is illegal
to specify GL_BACK when the color buffer is not double buffered.
&nbsp;Any invalid value for <span style="font-style: italic;">buffer</span>
will raise the error GL_INVALID_ENUM.<br>
<br>
The default read source is GL_BACK if the frame buffer is double
buffered. &nbsp;Otherwise, the default read source is GL_FRONT.<br>
<br>
<h2>8.2 Selection Mode</h2>
Selection mode is typically used to implement <span
style="font-style: italic;">picking</span>: determining which
primitive(s) are present at particular window positions. &nbsp;The
command<br>
<br>
<div style="margin-left: 40px;">GLint <span style="font-weight: bold;">glRenderMode</span>(GLenum<span
style="font-style: italic;">mode</span>)<br>
</div>
<br>
is used to enable selection mode. &nbsp;If <span
style="font-style: italic;">mode</span> is GL_SELECTION the graphics
library is put into selection mode. &nbsp;If <span
style="font-style: italic;">mode</span> is GL_RENDER the graphic
library is put into normal rendering mode. &nbsp;Any other value for <span
style="font-style: italic;">mode</span> will raise the error
GL_INVALID_ENUM.<br>
<br>
When in selection mode rendering commands will not effect the
framebuffer. &nbsp;Instead, a record of the primitives that would have
been drawn is placed in the <span style="font-style: italic;">selection</span> <span
style="font-style: italic;">buffer</span>. &nbsp;The selection buffer
is specified with the command<br>
<br>
<div style="margin-left: 40px;">void <span style="font-weight: bold;">glSelectionBuffer</span>(GLsizei<span
style="font-style: italic;">n</span>, GLuint *<span
style="font-style: italic;">buffer</span>)<br>
</div>
<span style="font-style: italic;"></span><span
style="font-style: italic;"><br>
buffer</span> is an array of <span style="font-style: italic;">n</span>
unsigned integers. &nbsp;No more than <span style="font-style: italic;">n</span>
values will be placed in the buffer.<br>
<br>
The <span style="font-style: italic;">name stack</span> is a stack
(LIFO) of unsigned integer names. &nbsp;The following commands
manipulate the name stack:<br>
<br>
<div style="margin-left: 40px;">void <span style="font-weight: bold;">glInitNames</span>(void)<br>
void <span style="font-weight: bold;">glPushName</span>(GLuint <span
style="font-style: italic;">name</span>)<br>
void <span style="font-weight: bold;">glPopName</span>(void)<br>
void <span style="font-weight: bold;">glLoadName</span>(GLuint <span
style="font-style: italic;">name</span>)<br>
</div>
<br>
<span style="font-weight: bold;">glInitNames</span> resets the name
stack to an empty state. &nbsp;<span style="font-weight: bold;">glPushName<span
style="font-style: italic;"> </span></span>pushes the given <span
style="font-style: italic;">name</span> value onto the stack. &nbsp;<span
style="font-weight: bold;">glPopName</span> pops the top name from the
stack. &nbsp;<span style="font-weight: bold;">glLoadName<span
style="font-style: italic;"> </span></span>replaces the top value on
the stack with the specified <span style="font-style: italic;">name</span>.
&nbsp;Stack underflow and overflow conditions cause the errors
GL_STACK_OVERFLOW and GL_STACK_UNDERFLOW to be raised.<br>
<br>
While in selection mode, primitives (points, lines, polygons) are
transformed and clip-tested normally. &nbsp;Primitives which aren't
discarded by clipping cause the <span style="font-style: italic;">hit</span> <span
style="font-style: italic;">data</span> to be updated. &nbsp;The hit
data consists of three pieces of information: a hit flag, a minimum Z
value and a maximum Z value. &nbsp;First, the hit flag is set.
&nbsp;Then, for each of the primitive's vertices, the vertex Z value is
compared to the minimum and maximum Z values. &nbsp;The minimum Z value
is updated if the vertex's Z value is less than the minimum Z value.
&nbsp;The maximum Z value is updated if the vertex's Z value is greater
than the maximum Z value.<br>
<br>
When any of <span style="font-weight: bold;">glInitNames</span><span
style="font-style: italic;"><span style="font-style: italic;">, </span></span><span
style="font-weight: bold;">glPushName</span>, <span
style="font-weight: bold;">glPopName</span>, <span
style="font-weight: bold;">glLoadName</span> or <span
style="font-weight: bold;">glRenderMode</span> are called and the hit
flag is set, a <span style="font-style: italic;">hit record</span> is
written to the selection buffer.<br>
<br>
A hit record consists of a sequence of unsigned integers. &nbsp;The
first value is the size of the name stack. &nbsp;The second value is the
minimum Z value multiplied by 2<sup>32</sup>-1. &nbsp;The third value is
the maximum Z value multiplied by 2<sup>32</sup>-1. &nbsp;The remaining
values are the values in the name stack, in bottom to top order.
&nbsp;The hit flag is cleared after a hit record is written to the
selection buffer. &nbsp;Hit records are places sequentially into the
selection buffer until it is full or selection mode is terminated.<br>
<br>
Selection mode is terminated by calling <span
style="font-weight: bold;">glRenderMode</span>(GL_RENDER). &nbsp; The
return value of <span style="font-weight: bold;">glRenderMode</span>
will be -1 if the selection buffer overflowed. &nbsp;Otherwise, the
return value will indicate the number of values written into the
selection buffer.<br>
<br>
<h2>8.3 Synchronization</h2>
The command<br>
<br>
<div style="margin-left: 40px;">void <span style="font-weight: bold;">glFlush</span>(void)<br>
</div>
<br>
makes the graphics library to flush all pending graphics commands.
&nbsp;The command<br>
<div style="margin-left: 40px;"><br>
void <span style="font-weight: bold;">glFinish</span>(void)<br>
</div>
<br>
makes the graphics library flush the command queue and wait until those
commands are completed. &nbsp;